Download data/lean/OAI/GroupTheory/UniversalGroup/CellularApproximation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 31.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/GroupTheory/UniversalGroup/CellularApproximation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/GroupTheory/UniversalGroup/CellularApproximation.lean
-
curl -L -o CellularApproximation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/GroupTheory/UniversalGroup/CellularApproximation.lean
31.7 kB
| import OAI.GroupTheory.UniversalGroup.GeneralPosition | |
| 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 | |
| namespace UniversalFInfinity.Cellular | |
| section | |
| open Set Metric Topology | |
| universe u | |
| variable {X : Type u} [TopologicalSpace X] [T2Space X] | |
| variable {C : Set X} [CWComplex C] | |
| def skeletonBoundary (n : β) (i : RelCWComplex.cell C n) : | |
| C(Attachment.Sphere n,Skeleton C n) := | |
| β¨fun x => β¨characteristic n i (boundary n x),sphere_mem_skeleton n i xβ©, | |
| ((characteristic n i).continuous.comp (continuous_boundary n)).subtype_mk _β© | |
| def skeletonBase (n : β) : C(Skeleton C n,Skeleton C (n+1)) := | |
| β¨fun x => β¨x.1,skeleton_mono (Nat.le_succ n) x.2β©,continuous_subtype_val.subtype_mk _β© | |
| def skeletonCell (n : β) (i : RelCWComplex.cell C n) : | |
| C(Attachment.Disk n,Skeleton C (n+1)) := | |
| β¨fun x => β¨characteristic n i x,characteristic_mem_skeleton (Nat.lt_succ_self n) i xβ©, | |
| (characteristic n i).continuous.subtype_mk _β© | |
| def skeletonAssembly (n : β) : C(Attachment.Space (skeletonBoundary (C := C) n),Skeleton C (n+1)) := | |
| Attachment.lift _ (skeletonBase n) (skeletonCell n) (fun _ _ => rfl) | |
| lemma skeletonAssembly_base (n : β) (x : Skeleton C n) : | |
| skeletonAssembly n (Attachment.base _ x) = skeletonBase n x := | |
| Attachment.lift_base _ _ _ _ x | |
| lemma skeletonAssembly_cell (n : β) (i : RelCWComplex.cell C n) (x : Disk n) : | |
| skeletonAssembly n (Attachment.cell _ i x) = skeletonCell n i x := | |
| Attachment.lift_cell _ _ _ _ i x | |
| lemma skeletonAssembly_interior (n : β) (i : RelCWComplex.cell C n) (x : Attachment.OpenDisk n) : | |
| skeletonAssembly n (Sum.inr β¨i,xβ©) = skeletonCell n i (Attachment.interior n x) := by | |
| rw [β Attachment.cell_interior (skeletonBoundary n) i x,skeletonAssembly_cell] | |
| lemma skeletonAssembly_injective (n : β) : Function.Injective (skeletonAssembly (C := C) n) := by | |
| intro a b hab | |
| rcases a with a|β¨i,aβ© <;> rcases b with b|β¨j,bβ© | |
| Β· change skeletonAssembly n (Attachment.base _ a) = skeletonAssembly n (Attachment.base _ b) at hab | |
| rw [skeletonAssembly_base,skeletonAssembly_base] at hab | |
| exact congrArg Sum.inl (Subtype.ext (congrArg (fun z : Skeleton C (n+1) => z.1) hab)) | |
| Β· have hh := congrArg Subtype.val hab | |
| rw [β show Attachment.base (skeletonBoundary n) a = Sum.inl a from rfl, | |
| skeletonAssembly_base,skeletonAssembly_interior] at hh | |
| have hm : a.1 β CWComplex.openCell n j := β¨b.1,b.2,hh.symmβ© | |
| exact False.elim (openCell_not_skeleton n j hm a.2) | |
| Β· have hh := congrArg Subtype.val hab | |
| rw [skeletonAssembly_interior, | |
| β show Attachment.base (skeletonBoundary n) b = Sum.inl b from rfl, | |
| skeletonAssembly_base] at hh | |
| have hm : b.1 β CWComplex.openCell n i := β¨a.1,a.2,hhβ© | |
| exact False.elim (openCell_not_skeleton n i hm b.2) | |
| Β· have hh := congrArg Subtype.val hab | |
| rw [skeletonAssembly_interior,skeletonAssembly_interior] at hh | |
| have hij : i = j := by | |
| by_contra hne | |
| have hd := CWComplex.disjoint_openCell_of_ne (C := C) (i := i) (j := j) | |
| (fun h => hne (sigma_mk_injective h)) | |
| exact Set.disjoint_left.mp hd β¨a.1,a.2,rflβ© β¨b.1,b.2,hh.symmβ© | |
| subst j | |
| have he : a = b := Subtype.ext ((RelCWComplex.map n i).injOn | |
| (by simpa only [RelCWComplex.source_eq] using a.2) | |
| (by simpa only [RelCWComplex.source_eq] using b.2) hh) | |
| subst b; rfl | |
| lemma skeletonAssembly_surjective (n : β) : Function.Surjective (skeletonAssembly (C := C) n) := by | |
| intro x | |
| have hx := x.2 | |
| 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 | |
| have hx' := (congrArg (fun S : Set X => x.1 β S) heq).mp hx | |
| rcases hx' with hx|hx | |
| Β· exact β¨Attachment.base _ β¨x.1,hxβ©,skeletonAssembly_base n _β© | |
| Β· obtain β¨i,y,hy,heβ© := Set.mem_iUnion.mp hx | |
| refine β¨Attachment.cell _ i β¨y,hyβ©,?_β© | |
| rw [skeletonAssembly_cell] | |
| exact Subtype.ext he | |
| lemma skeletonAssembly_closed (n : β) : IsClosedMap (skeletonAssembly (C := C) n) := by | |
| intro S hS | |
| let e : Attachment.Space (skeletonBoundary (C := C) n) β X := | |
| fun x => (skeletonAssembly n x).1 | |
| have hei : Function.Injective e := Subtype.val_injective.comp (skeletonAssembly_injective n) | |
| have hclosed : IsClosed (e '' S) := by | |
| apply (CWComplex.closed (Skeleton C (n+1)) _ ?_).mpr | |
| Β· intro m j | |
| have hm : m < n+1 := by | |
| have hh : (m : ββ) < ((n+1 : β) : ββ) := by | |
| simpa only [RelCWComplex.skeletonLT_I,Set.mem_ofPred_eq] using j.2 | |
| exact_mod_cast hh | |
| have hu : β u : C(Disk m,Attachment.Space (skeletonBoundary (C := C) n)), | |
| β x, e (u x) = characteristic m j.1 x := by | |
| rcases Nat.lt_succ_iff_lt_or_eq.mp hm with hm|hm | |
| Β· refine β¨β¨fun x => Attachment.base _ | |
| β¨characteristic m j.1 x,characteristic_mem_skeleton hm j.1 xβ©, | |
| (Attachment.continuous_base _).comp ((characteristic m j.1).continuous.subtype_mk _)β©,?_β© | |
| intro x; exact congrArg Subtype.val (skeletonAssembly_base n _) | |
| Β· subst m | |
| exact β¨Attachment.cell _ j.1,fun x => congrArg Subtype.val (skeletonAssembly_cell n j.1 x)β© | |
| obtain β¨u,huβ© := hu | |
| have heq : (e '' S) β© CWComplex.closedCell m j = | |
| characteristic m j.1 '' (u β»ΒΉ' S) := by | |
| ext x | |
| constructor | |
| Β· rintro β¨β¨y,hy,rflβ©,z,hz,heβ© | |
| refine β¨β¨z,hzβ©,?_,heβ© | |
| change u β¨z,hzβ© β S | |
| have hh : u β¨z,hzβ© = y := hei ((hu _).trans he) | |
| rwa [hh] | |
| Β· rintro β¨z,hz,rflβ© | |
| exact β¨β¨u z,hz,hu zβ©,z.1,z.2,rflβ© | |
| rw [heq] | |
| exact ((hS.preimage u.continuous).isCompact.image (characteristic m j.1).continuous).isClosed | |
| Β· rintro x β¨y,hy,rflβ© | |
| exact (skeletonAssembly n y).2 | |
| have h : IsClosed ((Subtype.val : Skeleton C (n+1) β X) β»ΒΉ' (e '' S)) := | |
| hclosed.preimage continuous_subtype_val | |
| convert h using 1 | |
| ext x | |
| constructor | |
| Β· rintro β¨y,hy,rflβ©; exact β¨y,hy,rflβ© | |
| Β· rintro β¨y,hy,heβ©; exact β¨y,hy,Subtype.ext heβ© | |
| def skeletonHomeomorph (n : β) : | |
| Attachment.Space (skeletonBoundary (C := C) n) ββ Skeleton C (n+1) := | |
| (isHomeomorph_iff_continuous_isClosedMap_bijective.mpr | |
| β¨(skeletonAssembly n).continuous,skeletonAssembly_closed n, | |
| skeletonAssembly_injective n,skeletonAssembly_surjective nβ©).homeomorph _ | |
| end | |
| section | |
| open Set Metric Topology | |
| universe u | |
| variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X] [T2Space X] | |
| [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)] | |
| variable {ΞΉ : β β Type u} | |
| variable (Ο : β n, (G Γ ΞΉ n) β RelCWComplex.cell (univ : Set X) n) | |
| variable (hΟ : β n (g h : G) (i : ΞΉ n) (x : Fin n β β), | |
| RelCWComplex.map n (Ο n (g*h,i)) x = g β’ RelCWComplex.map n (Ο n (h,i)) x) | |
| omit [ContinuousConstSMul G X] in | |
| include hΟ in | |
| lemma skeleton_smul_mem (n : β) (g : G) {x : X} (hx : x β Skeleton (univ : Set X) n) : | |
| g β’ x β Skeleton (univ : Set X) n := by | |
| obtain β¨m,hm,j,y,hy,rflβ© := (CWComplex.mem_skeletonLT_iff (C := (univ : Set X))).mp hx | |
| let i := (Ο m).symm j | |
| have hj : Ο m i = j := (Ο m).apply_symm_apply j | |
| apply (CWComplex.mem_skeletonLT_iff (C := (univ : Set X))).mpr | |
| refine β¨m,hm,Ο m (g*i.1,i.2),y,hy,?_β© | |
| rw [hΟ] | |
| exact congrArg (fun j => g β’ RelCWComplex.map m j y) hj | |
| def skeletonTranslate (n : β) (g : G) : C(Skeleton (univ : Set X) n,Skeleton (univ : Set X) n) := | |
| β¨fun x => β¨g β’ x.1,skeleton_smul_mem Ο hΟ n g x.2β©, | |
| ((continuous_const_smul g).comp continuous_subtype_val).subtype_mk _β© | |
| lemma skeletonTranslate_base (n : β) (g : G) (x : Skeleton (univ : Set X) n) : | |
| skeletonTranslate Ο hΟ (n+1) g (skeletonBase n x) = | |
| skeletonBase n (skeletonTranslate Ο hΟ n g x) := rfl | |
| lemma skeletonTranslate_cell (n : β) (g h : G) (i : ΞΉ n) (x : Disk n) : | |
| skeletonTranslate Ο hΟ (n+1) g (skeletonCell n (Ο n (h,i)) x) = | |
| skeletonCell n (Ο n (g*h,i)) x := by | |
| apply Subtype.ext | |
| exact (hΟ n g h i x.1).symm | |
| variable {E : Type u} [TopologicalSpace E] [MulAction G E] [ContinuousConstSMul G E] | |
| lemma exists_equivariant_skeleton_extension (n : β) | |
| (b : C(Skeleton (univ : Set X) n,E)) | |
| (hb : β (g : G) x, b (skeletonTranslate Ο hΟ n g x) = g β’ b x) | |
| (hfill : β a : C(Sphere n,E), β d : C(Disk n,E), β x, d (boundary n x) = a x) : | |
| β e : C(Skeleton (univ : Set X) (n+1),E), | |
| (β x, e (skeletonBase n x) = b x) β§ | |
| β (g : G) x, e (skeletonTranslate Ο hΟ (n+1) g x) = g β’ e x := by | |
| let a (i : ΞΉ n) := b.comp (skeletonBoundary n (Ο n (1,i))) | |
| choose d hd using fun i => hfill (a i) | |
| let D (j : RelCWComplex.cell (univ : Set X) n) : C(Disk n,E) := | |
| β¨fun x => ((Ο n).symm j).1 β’ d ((Ο n).symm j).2 x, | |
| (continuous_const_smul _).comp (d _).continuousβ© | |
| have hD (j : RelCWComplex.cell (univ : Set X) n) (x : Sphere n) : | |
| D j (boundary n x) = b (skeletonBoundary n j x) := by | |
| obtain β¨β¨g,iβ©,rflβ© := (Ο n).surjective j | |
| change ((Ο n).symm (Ο n (g,i))).1 β’ d ((Ο n).symm (Ο n (g,i))).2 (boundary n x) = _ | |
| rw [Equiv.symm_apply_apply,hd] | |
| change g β’ b (skeletonBoundary n (Ο n (1,i)) x) = _ | |
| rw [βhb] | |
| congr 1 | |
| apply Subtype.ext | |
| exact (hΟ n g 1 i x.1).symm.trans (by rw [mul_one]; rfl) | |
| let f := Attachment.lift (skeletonBoundary (C := (univ : Set X)) n) b D hD | |
| let e : C(Skeleton (univ : Set X) (n+1),E) := f.comp β¨(skeletonHomeomorph n).symm,(skeletonHomeomorph n).symm.continuousβ© | |
| have he_base (x : Skeleton (univ : Set X) n) : e (skeletonBase n x) = b x := by | |
| change f ((skeletonHomeomorph n).symm (skeletonBase n x)) = _ | |
| rw [βskeletonAssembly_base] | |
| change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.base _ x))) = _ | |
| rw [Homeomorph.symm_apply_apply] | |
| rfl | |
| have he_cell (j : RelCWComplex.cell (univ : Set X) n) (x : Disk n) : | |
| e (skeletonCell n j x) = D j x := by | |
| change f ((skeletonHomeomorph n).symm (skeletonCell n j x)) = _ | |
| rw [βskeletonAssembly_cell] | |
| change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.cell _ j x))) = _ | |
| rw [Homeomorph.symm_apply_apply] | |
| exact Attachment.lift_cell _ _ _ _ _ _ | |
| refine β¨e,he_base,?_β© | |
| intro g x | |
| obtain β¨y,rflβ© := skeletonAssembly_surjective n x | |
| cases y with | |
| | inl x => | |
| change e (skeletonTranslate Ο hΟ (n+1) g (skeletonBase n x)) = g β’ e (skeletonBase n x) | |
| rw [skeletonTranslate_base,he_base,he_base,hb] | |
| | inr p => | |
| obtain β¨β¨h,iβ©,hjβ© := (Ο n).surjective p.1 | |
| have heq : skeletonAssembly n (Sum.inr p) = skeletonCell n p.1 (Attachment.interior n p.2) := by | |
| exact skeletonAssembly_interior n p.1 p.2 | |
| rw [heq,βhj,skeletonTranslate_cell,he_cell,he_cell] | |
| change ((Ο n).symm (Ο n (g*h,i))).1 β’ d ((Ο n).symm (Ο n (g*h,i))).2 _ = | |
| g β’ (((Ο n).symm (Ο n (h,i))).1 β’ d ((Ο n).symm (Ο n (h,i))).2 _) | |
| simp only [Equiv.symm_apply_apply,mul_smul] | |
| end | |
| section | |
| open Set Metric Topology | |
| universe u | |
| variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X] [T2Space X] | |
| [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)] | |
| variable {ΞΉ : β β Type u} | |
| variable (Ο : β n, (G Γ ΞΉ n) β RelCWComplex.cell (univ : Set X) n) | |
| variable (hΟ : β n (g h : G) (i : ΞΉ n) (x : Fin n β β), | |
| RelCWComplex.map n (Ο n (g*h,i)) x = g β’ RelCWComplex.map n (Ο n (h,i)) x) | |
| variable {E B : Type u} [TopologicalSpace E] [TopologicalSpace B] | |
| [MulAction G E] [ContinuousConstSMul G E] [MulAction G B] | |
| lemma exists_equivariant_skeleton_lift (n : β) (p : C(E,B)) | |
| (hp : β (g : G) e, p (g β’ e) = g β’ p e) (hRLP : DiskRLP p) | |
| (F : C(Skeleton (univ : Set X) (n+1),B)) | |
| (hF : β (g : G) x, F (skeletonTranslate Ο hΟ (n+1) g x) = g β’ F x) | |
| (b : C(Skeleton (univ : Set X) n,E)) | |
| (hb : β (g : G) x, b (skeletonTranslate Ο hΟ n g x) = g β’ b x) | |
| (hbF : β x, p (b x) = F (skeletonBase n x)) : | |
| β e : C(Skeleton (univ : Set X) (n+1),E), | |
| (β x, e (skeletonBase n x) = b x) β§ (β x, p (e x) = F x) β§ | |
| β (g : G) x, e (skeletonTranslate Ο hΟ (n+1) g x) = g β’ e x := by | |
| let a (i : ΞΉ n) := b.comp (skeletonBoundary n (Ο n (1,i))) | |
| let c (i : ΞΉ n) := F.comp (skeletonCell n (Ο n (1,i))) | |
| have hsq (i : ΞΉ n) (x : Sphere n) : p (a i x) = c i (boundary n x) := by | |
| change p (b (skeletonBoundary n (Ο n (1,i)) x)) = F (skeletonCell n (Ο n (1,i)) (boundary n x)) | |
| rw [hbF] | |
| rfl | |
| choose d hd hf using fun i => hRLP n (a i) (c i) (hsq i) | |
| let D (j : RelCWComplex.cell (univ : Set X) n) : C(Disk n,E) := | |
| β¨fun x => ((Ο n).symm j).1 β’ d ((Ο n).symm j).2 x, | |
| (continuous_const_smul _).comp (d _).continuousβ© | |
| have hD (j : RelCWComplex.cell (univ : Set X) n) (x : Sphere n) : | |
| D j (boundary n x) = b (skeletonBoundary n j x) := by | |
| obtain β¨β¨g,iβ©,rflβ© := (Ο n).surjective j | |
| change ((Ο n).symm (Ο n (g,i))).1 β’ d ((Ο n).symm (Ο n (g,i))).2 (boundary n x) = _ | |
| rw [Equiv.symm_apply_apply,hd] | |
| change g β’ b (skeletonBoundary n (Ο n (1,i)) x) = _ | |
| rw [βhb] | |
| congr 1 | |
| apply Subtype.ext | |
| exact (hΟ n g 1 i x.1).symm.trans (by rw [mul_one]; rfl) | |
| let f := Attachment.lift (skeletonBoundary (C := (univ : Set X)) n) b D hD | |
| let e : C(Skeleton (univ : Set X) (n+1),E) := f.comp β¨(skeletonHomeomorph n).symm,(skeletonHomeomorph n).symm.continuousβ© | |
| have he_base (x : Skeleton (univ : Set X) n) : e (skeletonBase n x) = b x := by | |
| change f ((skeletonHomeomorph n).symm (skeletonBase n x)) = _ | |
| rw [βskeletonAssembly_base] | |
| change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.base _ x))) = _ | |
| rw [Homeomorph.symm_apply_apply] | |
| rfl | |
| have he_cell (j : RelCWComplex.cell (univ : Set X) n) (x : Disk n) : | |
| e (skeletonCell n j x) = D j x := by | |
| change f ((skeletonHomeomorph n).symm (skeletonCell n j x)) = _ | |
| rw [βskeletonAssembly_cell] | |
| change f ((skeletonHomeomorph n).symm ((skeletonHomeomorph n) (Attachment.cell _ j x))) = _ | |
| rw [Homeomorph.symm_apply_apply] | |
| exact Attachment.lift_cell _ _ _ _ _ _ | |
| have he (g : G) (x : Skeleton (univ : Set X) (n+1)) : | |
| e (skeletonTranslate Ο hΟ (n+1) g x) = g β’ e x := by | |
| obtain β¨y,rflβ© := skeletonAssembly_surjective n x | |
| cases y with | |
| | inl x => | |
| change e (skeletonTranslate Ο hΟ (n+1) g (skeletonBase n x)) = g β’ e (skeletonBase n x) | |
| rw [skeletonTranslate_base,he_base,he_base,hb] | |
| | inr q => | |
| obtain β¨β¨h,iβ©,hjβ© := (Ο n).surjective q.1 | |
| have heq : skeletonAssembly n (Sum.inr q) = skeletonCell n q.1 (Attachment.interior n q.2) := | |
| skeletonAssembly_interior n q.1 q.2 | |
| rw [heq,βhj,skeletonTranslate_cell,he_cell,he_cell] | |
| change ((Ο n).symm (Ο n (g*h,i))).1 β’ d ((Ο n).symm (Ο n (g*h,i))).2 _ = | |
| g β’ (((Ο n).symm (Ο n (h,i))).1 β’ d ((Ο n).symm (Ο n (h,i))).2 _) | |
| simp only [Equiv.symm_apply_apply,mul_smul] | |
| refine β¨e,he_base,?_,heβ© | |
| intro x | |
| obtain β¨y,rflβ© := skeletonAssembly_surjective n x | |
| cases y with | |
| | inl x => | |
| change p (e (skeletonBase n x)) = F (skeletonBase n x) | |
| rw [he_base,hbF] | |
| | inr q => | |
| rw [skeletonAssembly_interior,he_cell] | |
| obtain β¨β¨g,iβ©,hjβ© := (Ο n).surjective q.1 | |
| rw [βhj] | |
| change p (((Ο n).symm (Ο n (g,i))).1 β’ d ((Ο n).symm (Ο n (g,i))).2 _) = _ | |
| rw [Equiv.symm_apply_apply,hp,hf] | |
| change g β’ F (skeletonCell n (Ο n (1,i)) _) = _ | |
| rw [βhF,skeletonTranslate_cell,mul_one] | |
| end | |
| section | |
| open Set Metric Topology | |
| universe u | |
| variable {G : Type u} [Group G] {X : Type u} [TopologicalSpace X] [T2Space X] | |
| [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)] | |
| variable {ΞΉ : β β Type u} | |
| variable (Ο : β n, (G Γ ΞΉ n) β RelCWComplex.cell (univ : Set X) n) | |
| variable (hΟ : β n (g h : G) (i : ΞΉ n) (x : Fin n β β), | |
| RelCWComplex.map n (Ο n (g*h,i)) x = g β’ RelCWComplex.map n (Ο n (h,i)) x) | |
| omit [MulAction G X] [ContinuousConstSMul G X] in | |
| lemma isEmpty_skeleton_zero : IsEmpty (Skeleton (univ : Set X) 0) := by | |
| refine β¨fun x => ?_β© | |
| have hx := x.2 | |
| change x.1 β (CWComplex.skeletonLT (univ : Set X) 0 : Set X) at hx | |
| rw [CWComplex.skeletonLT_zero_eq_empty] at hx | |
| exact hx | |
| variable {E B : Type u} [TopologicalSpace E] [TopologicalSpace B] | |
| [MulAction G E] [ContinuousConstSMul G E] [MulAction G B] | |
| lemma exists_equivariant_lift_on_skeleton (d : β) (p : C(E,B)) | |
| (hp : β (g : G) e, p (g β’ e) = g β’ p e) (hRLP : DiskRLP p) | |
| (F : C(Skeleton (univ : Set X) d,B)) | |
| (hF : β (g : G) x, F (skeletonTranslate Ο hΟ d g x) = g β’ F x) : | |
| β e : C(Skeleton (univ : Set X) d,E), (β x, p (e x) = F x) β§ | |
| β (g : G) x, e (skeletonTranslate Ο hΟ d g x) = g β’ e x := by | |
| induction d with | |
| | zero => | |
| let := isEmpty_skeleton_zero (X := X) | |
| exact β¨β¨isEmptyElim,continuous_of_discreteTopologyβ©,fun x => isEmptyElim x,fun _ x => isEmptyElim xβ© | |
| | succ d ih => | |
| obtain β¨b,hbF,hbβ© := ih (F.comp (skeletonBase d)) (fun g x => by | |
| change F (skeletonBase d (skeletonTranslate Ο hΟ d g x)) = g β’ F (skeletonBase d x) | |
| rw [βskeletonTranslate_base,hF]) | |
| obtain β¨e,_,heF,heβ© := exists_equivariant_skeleton_lift Ο hΟ d p hp hRLP F hF b hb hbF | |
| exact β¨e,heF,heβ© | |
| lemma exists_equivariant_map_on_skeleton (d : β) | |
| (hfill : β n < d, β a : C(Sphere n,E), β e : C(Disk n,E), β x, e (boundary n x) = a x) : | |
| β e : C(Skeleton (univ : Set X) d,E), | |
| β (g : G) x, e (skeletonTranslate Ο hΟ d g x) = g β’ e x := by | |
| induction d with | |
| | zero => | |
| let := isEmpty_skeleton_zero (X := X) | |
| exact β¨β¨isEmptyElim,continuous_of_discreteTopologyβ©,fun _ x => isEmptyElim xβ© | |
| | succ d ih => | |
| obtain β¨b,hbβ© := ih (fun n hn => hfill n (Nat.lt_succ_of_lt hn)) | |
| obtain β¨e,_,heβ© := exists_equivariant_skeleton_extension Ο hΟ d b hb (hfill d (Nat.lt_succ_self d)) | |
| exact β¨e,heβ© | |
| variable {Y : Type u} [TopologicalSpace Y] [MulAction G Y] [ContinuousConstSMul G Y] | |
| lemma exists_equivariant_homotopy_on_skeleton (d : β) (hY : SphereFillable Y) | |
| (a b : C(Skeleton (univ : Set X) d,Y)) | |
| (ha : β (g : G) x, a (skeletonTranslate Ο hΟ d g x) = g β’ a x) | |
| (hb : β (g : G) x, b (skeletonTranslate Ο hΟ d g x) = g β’ b x) : | |
| β H : a.Homotopy b, β (g : G) t x, | |
| H (t,skeletonTranslate Ο hΟ d g x) = g β’ H (t,x) := by | |
| let F : C(Skeleton (univ : Set X) d,Y Γ Y) := a.prodMk b | |
| have hF (g : G) x : F (skeletonTranslate Ο hΟ d g x) = g β’ F x := by | |
| exact Prod.ext (ha g x) (hb g x) | |
| obtain β¨e,heF,heβ© := exists_equivariant_lift_on_skeleton Ο hΟ d pathEndpoint | |
| (fun _ _ => rfl) (pathEndpoint_RLP hY) F hF | |
| let H : a.Homotopy b := | |
| { toFun := fun z => e z.2 z.1 | |
| continuous_toFun := e.continuous.comp continuous_snd |>.eval continuous_fst | |
| map_zero_left := fun x => congrArg Prod.fst (heF x) | |
| map_one_left := fun x => congrArg Prod.snd (heF x) } | |
| refine β¨H,?_β© | |
| intro g t x | |
| exact ContinuousMap.congr_fun (he g x) t | |
| omit [MulAction G X] [ContinuousConstSMul G X] in | |
| def skeletonChart (n m : β) (hm : m < n) (i : RelCWComplex.cell (univ : Set X) m) : | |
| C(Disk m,Skeleton (univ : Set X) n) := | |
| β¨fun z => β¨characteristic m i z,characteristic_mem_skeleton hm i zβ©, | |
| (characteristic m i).continuous.subtype_mk _β© | |
| lemma skeleton_compact_representatives (n : β) [β m,Finite (ΞΉ m)] : | |
| β K : Set (Skeleton (univ : Set X) n), IsCompact K β§ | |
| β x, β g : G, β y β K, x = skeletonTranslate Ο hΟ n g y := by | |
| let K := β m : Fin n, β i : ΞΉ m, Set.range (skeletonChart n m m.2 (Ο m (1,i))) | |
| have hK : IsCompact K := isCompact_iUnion fun m => isCompact_iUnion fun i => | |
| isCompact_range (skeletonChart n m m.2 (Ο m (1,i))).continuous | |
| refine β¨K,hK,?_β© | |
| intro x | |
| obtain β¨m,hm,j,z,hz,hjβ© := (CWComplex.mem_skeletonLT_iff (C := (univ : Set X))).mp x.2 | |
| obtain β¨β¨g,iβ©,rflβ© := (Ο m).surjective j | |
| have hmn : m < n := by exact_mod_cast hm | |
| let y := skeletonChart n m hmn (Ο m (1,i)) β¨z,ball_subset_closedBall hzβ© | |
| refine β¨g,y,Set.mem_iUnion.mpr β¨β¨m,hmnβ©,Set.mem_iUnion.mpr β¨i,Set.mem_range_self _β©β©,?_β© | |
| apply Subtype.ext | |
| change x.1 = g β’ RelCWComplex.map m (Ο m (1,i)) z | |
| rw [βhΟ,mul_one] | |
| exact hj.symm | |
| end | |
| open Set Metric Topology | |
| universe u v | |
| variable {X : Type u} [TopologicalSpace X] [T2Space X] | |
| variable {C : Set X} [CWComplex C] | |
| variable {K : Type v} [MetricSpace K] [CompactSpace K] | |
| def skeletonInclusion (n : β) : C(Skeleton C n,X) := β¨Subtype.val,continuous_subtype_valβ© | |
| lemma deform_skeleton_succ (n : β) (f : C(K,Skeleton C (n+1))) | |
| (hdim : dimH (Set.univ : Set K) < n) : | |
| β (g : C(K,Skeleton C n)) | |
| (H : f.Homotopy ((skeletonBase n).comp g)), | |
| β t x, (f x).1 β Skeleton C n β H (t,x) = f x := by | |
| let e := skeletonHomeomorph (C := C) n | |
| let : T2Space (Attachment.Space (skeletonBoundary (C := C) n)) := e.symm.t2Space | |
| let f' : C(K,Attachment.Space (skeletonBoundary (C := C) n)) := (β¨e.symm,e.symm.continuousβ© : C(_, _)).comp f | |
| obtain β¨g,H,hHβ© := Attachment.exists_deformation_into_base (skeletonBoundary (C := C) n) f' hdim | |
| have h0 : (β¨e,e.continuousβ© : C(_, _)).comp f' = f := by apply ContinuousMap.ext; intro x; exact e.apply_symm_apply (f x) | |
| have h1 : (β¨e,e.continuousβ© : C(_, _)).comp | |
| ((β¨Attachment.base _,Attachment.continuous_base _β© : C(_, _)).comp g) = | |
| (skeletonBase n).comp g := by apply ContinuousMap.ext; intro x; exact skeletonAssembly_base n (g x) | |
| let J := (ContinuousMap.Homotopy.refl (β¨e,e.continuousβ© : C(_, _))).comp H | |
| refine β¨g,J.cast h0 h1,?_β© | |
| intro t x hx | |
| change e (H (t,x)) = f x | |
| have hr : f' x β Set.range (Attachment.base (skeletonBoundary (C := C) n)) := by | |
| refine β¨β¨(f x).1,hxβ©,?_β© | |
| apply e.injective | |
| change skeletonAssembly n (Attachment.base _ _) = e (e.symm (f x)) | |
| rw [skeletonAssembly_base,e.apply_symm_apply] | |
| rfl | |
| rw [hH t x hr] | |
| exact e.apply_symm_apply (f x) | |
| lemma deform_bounded_skeleton (d m : β) (f : C(K,Skeleton C m)) | |
| (hdim : dimH (Set.univ : Set K) < d) : | |
| β (g : C(K,Skeleton C d)) | |
| (H : ((skeletonInclusion m).comp f).Homotopy ((skeletonInclusion d).comp g)), | |
| β t x, (f x).1 β Skeleton C d β H (t,x) = (f x).1 := by | |
| induction m with | |
| | zero => | |
| let g : C(K,Skeleton C d) := β¨fun x => β¨(f x).1,skeleton_mono (Nat.zero_le d) (f x).2β©, | |
| f.continuous.subtype_val.subtype_mk _β© | |
| exact β¨g,.refl _,fun _ _ _ => rflβ© | |
| | succ m ih => | |
| by_cases hmd : m+1 β€ d | |
| Β· let g : C(K,Skeleton C d) := β¨fun x => β¨(f x).1,skeleton_mono hmd (f x).2β©, | |
| f.continuous.subtype_val.subtype_mk _β© | |
| exact β¨g,.refl _,fun _ _ _ => rflβ© | |
| Β· have hdm : d β€ m := by omega | |
| obtain β¨g,H,hHβ© := deform_skeleton_succ m f (hdim.trans_le (by exact_mod_cast hdm)) | |
| obtain β¨g',J,hJβ© := ih g | |
| let H' : ((skeletonInclusion (C := C) (m+1)).comp f).Homotopy | |
| ((skeletonInclusion m).comp g) := | |
| (ContinuousMap.Homotopy.refl (skeletonInclusion (C := C) (m+1))).comp H | |
| refine β¨g',H'.trans J,?_β© | |
| intro t x hx | |
| have hh (s : unitInterval) : H' (s,x) = (f x).1 := by | |
| exact congrArg Subtype.val (hH s x (skeleton_mono hdm hx)) | |
| have hg : (g x).1 = (f x).1 := by | |
| have he := hh 1 | |
| rw [ContinuousMap.Homotopy.apply_one] at he | |
| exact he | |
| have hj (s : unitInterval) : J (s,x) = (f x).1 := by | |
| rw [hJ s x (hg.symm βΈ hx),hg] | |
| rw [ContinuousMap.Homotopy.trans_apply] | |
| split_ifs | |
| Β· exact hh _ | |
| Β· exact hj _ | |
| theorem exists_cellular_approximation (d : β) (f : C(K,X)) (hf : β x,f x β C) | |
| (hdim : dimH (Set.univ : Set K) < d) : | |
| β (g : C(K,Skeleton C d)) (H : f.Homotopy ((skeletonInclusion d).comp g)), | |
| β t x, f x β Skeleton C d β H (t,x) = f x := by | |
| obtain β¨m,hmβ© := compactMap_bounded_skeleton f hf | |
| let f' : C(K,Skeleton C m) := β¨fun x => β¨f x,hm xβ©,f.continuous.subtype_mk _β© | |
| exact deform_bounded_skeleton d m f' hdim | |
| end UniversalFInfinity.Cellular | |
| namespace UniversalFInfinity.SphereTopology | |
| open Set Metric Topology | |
| universe u | |
| variable {Y : Type u} [TopologicalSpace Y] | |
| lemma fill_zero [Nonempty Y] (a : C(Cellular.Sphere 0,Y)) : | |
| β e : C(Cellular.Disk 0,Y), β x, e (Cellular.boundary 0 x) = a x := by | |
| refine β¨.const _ (Classical.choice βΉNonempty YβΊ),?_β© | |
| intro x | |
| have hx := x.2 | |
| have hz : x.1 = 0 := Subsingleton.elim _ _ | |
| simp only [hz,mem_sphere,dist_self] at hx | |
| exact False.elim (zero_ne_one hx) | |
| lemma fill_one [PathConnectedSpace Y] (a : C(Cellular.Sphere 1,Y)) : | |
| β e : C(Cellular.Disk 1,Y), β x, e (Cellular.boundary 1 x) = a x := by | |
| let p := (PathConnectedSpace.joined (a Cayley.minus) (a Cayley.plus)).somePath | |
| let e : C(Cellular.Disk 1,Y) := p.toContinuousMap.comp β¨Cayley.edgeTime,Cayley.continuous_edgeTimeβ© | |
| refine β¨e,?_β© | |
| intro x | |
| obtain rfl|rfl := Cayley.sphere_one_eq x | |
| Β· change p (Cayley.edgeTime (Attachment.boundary 1 Cayley.minus)) = _ | |
| rw [Cayley.edgeTime_minus,p.source] | |
| Β· change p (Cayley.edgeTime (Attachment.boundary 1 Cayley.plus)) = _ | |
| rw [Cayley.edgeTime_plus,p.target] | |
| end UniversalFInfinity.SphereTopology | |
| namespace UniversalFInfinity.Milnor | |
| section | |
| open Set Metric Topology Cellular | |
| universe u | |
| variable {G : Type u} [Group G] | |
| variable {X : Type u} [TopologicalSpace X] [T2Space X] | |
| [MulAction G X] [ContinuousConstSMul G X] [CWComplex (univ : Set X)] | |
| variable {ΞΉ : β β Type u} [β m,Finite (ΞΉ m)] | |
| variable (Ο : β n, (G Γ ΞΉ n) β RelCWComplex.cell (univ : Set X) n) | |
| variable (hΟ : β n (g h : G) (i : ΞΉ n) (x : Fin n β β), | |
| RelCWComplex.map n (Ο n (g*h,i)) x = g β’ RelCWComplex.map n (Ο n (h,i)) x) | |
| lemma controlled_skeleton_homotopy (d : β) (a b : C(Skeleton (univ : Set X) d,Space G)) | |
| (H : a.Homotopy b) | |
| (hH : β (g : G) t x, H (t,skeletonTranslate Ο hΟ d g x) = g β’ H (t,x)) : | |
| β S : Shapes G, Set.range H β Set.range (stageFull G S) := by | |
| obtain β¨K,hK,hcovβ© := skeleton_compact_representatives Ο hΟ d | |
| obtain β¨S,hSβ© := compact_orbit_controlled G ((isCompact_univ.prod hK).image H.continuous) | |
| refine β¨S,?_β© | |
| rintro _ β¨β¨t,xβ©,rflβ© | |
| obtain β¨g,y,hy,rflβ© := hcov x | |
| rw [hH] | |
| exact hS g β¨H (t,y),β¨(t,y),β¨Set.mem_univ _,hyβ©,rflβ©,rflβ© | |
| end | |
| open Set Metric Topology Cellular | |
| universe u | |
| variable {G : Type u} [Group G] [TopologicalSpace G] [DiscreteTopology G] | |
| variable {A : Type u} [Finite A] (s : A β G) | |
| variable (rels : Set (FreeGroup A)) (hrel : β r β rels, FreeGroup.lift s r = 1) | |
| include hrel in | |
| lemma uniform_low_connectivity (hrels : rels.Finite) | |
| (hs : Function.Surjective (FreeGroup.lift s)) | |
| (hker : (FreeGroup.lift s).ker = Subgroup.normalClosure rels) (S : Shapes G) : | |
| β (T : Shapes G) (hST : S β T), β n : β, n = 1 β¨ n = 2 β | |
| β a : C(Sphere n,Stage G S), β d : C(Disk n,Stage G T), | |
| β x, d (boundary n x) = stageIncl G S T hST (a x) := by | |
| classical | |
| let Z := Cayley.PresentationCover s rels hrel | |
| let : PathConnectedSpace Z := Cayley.presentationCover_pathConnected s rels hrel hs | |
| let : CWComplex (univ : Set (Stage G S)) := stageEquivariantCW G S | |
| let Ο : β n, (G Γ CellOrbits G S n) β RelCWComplex.cell (univ : Set (Stage G S)) n := | |
| fun _ => Equiv.refl _ | |
| have hΟ : β n (g h : G) (i : CellOrbits G S n) (x : Fin n β β), | |
| RelCWComplex.map n (Ο n (g*h,i)) x = g β’ RelCWComplex.map n (Ο n (h,i)) x := by | |
| intro n g h i x | |
| exact mul_smul g h _ | |
| have hfill : β n < 2, β a : C(Sphere n,Z), β e : C(Disk n,Z), | |
| β x, e (boundary n x) = a x := by | |
| intro n hn | |
| have hn' : n=0 β¨ n=1 := by omega | |
| rcases hn' with rfl|rfl | |
| Β· exact SphereTopology.fill_zero | |
| Β· exact SphereTopology.fill_one | |
| obtain β¨r,hrβ© := exists_equivariant_map_on_skeleton Ο hΟ 2 hfill | |
| obtain β¨q,hqβ© := presentation_equivariant_map s rels hrel | |
| obtain β¨P,hPβ© := equivariant_controlled G (presentation_compactFundamentalSet s rels hrel hrels) q hq | |
| let a := (stageFull G S).comp (skeletonInclusion (C := (univ : Set (Stage G S))) 2) | |
| let b := q.comp r | |
| have ha (g : G) x : a (skeletonTranslate Ο hΟ 2 g x) = g β’ a x := | |
| stageFull_smul G S g x.1 | |
| have hb (g : G) x : b (skeletonTranslate Ο hΟ 2 g x) = g β’ b x := by | |
| change q (r (skeletonTranslate Ο hΟ 2 g x)) = g β’ q (r x) | |
| rw [hr,hq] | |
| obtain β¨H,hHβ© := exists_equivariant_homotopy_on_skeleton Ο hΟ 2 (sphereFillable (1:G)) a b ha hb | |
| obtain β¨Q,hQβ© := controlled_skeleton_homotopy Ο hΟ 2 a b H hH | |
| let T := S βͺ P βͺ Q | |
| have hST : S β T := Finset.subset_union_left.trans Finset.subset_union_left | |
| have hPT : P β T := Finset.subset_union_right.trans Finset.subset_union_left | |
| have hQT : Q β T := Finset.subset_union_right | |
| have hpT : Set.range q β Set.range (stageFull G T) := by | |
| rintro _ β¨z,rflβ© | |
| obtain β¨y,hyβ© := hP (Set.mem_range_self z) | |
| exact β¨stageIncl G P T hPT y,hyβ© | |
| have hhT : Set.range H β Set.range (stageFull G T) := by | |
| rintro _ β¨z,rflβ© | |
| obtain β¨y,hyβ© := hQ (Set.mem_range_self z) | |
| exact β¨stageIncl G Q T hQT y,hyβ© | |
| let qT := factorStage G q T hpT | |
| let HTmap := factorStage G H.toContinuousMap T hhT | |
| let inc := stageIncl G S T hST | |
| let HT : (inc.comp (skeletonInclusion (C := (univ : Set (Stage G S))) 2)).Homotopy (qT.comp r) := | |
| { toContinuousMap := HTmap | |
| map_zero_left := fun x => by | |
| apply (stageFull_embedding G T).injective | |
| change stageFull G T (HTmap (0,x)) = stageFull G T (inc x.1) | |
| rw [factorStage_spec] | |
| exact H.apply_zero x | |
| map_one_left := fun x => by | |
| apply (stageFull_embedding G T).injective | |
| change stageFull G T (HTmap (1,x)) = stageFull G T (qT (r x)) | |
| rw [factorStage_spec,factorStage_spec] | |
| exact H.apply_one x } | |
| refine β¨T,hST,?_β© | |
| intro n hn k | |
| have hdim : dimH (univ : Set (Sphere n)) < 2 := by | |
| rcases hn with rfl|rfl | |
| Β· exact (GeneralPosition.dimH_cube_boundary_subtype_le 0).trans_lt (by norm_num) | |
| Β· exact (GeneralPosition.dimH_cube_boundary_subtype_le 1).trans_lt (by norm_num) | |
| let : Nonempty (Sphere n) := by | |
| rcases hn with rfl|rfl | |
| Β· exact SphereTopology.sphere_nonempty 0 | |
| Β· exact SphereTopology.sphere_nonempty 1 | |
| obtain β¨v,J,_β© := exists_cellular_approximation 2 k (fun _ => Set.mem_univ _) hdim | |
| have hz : SphereTopology.Extends (r.comp v) := by | |
| rcases hn with rfl|rfl | |
| Β· obtain β¨e,heβ© := SphereTopology.fill_one (r.comp v) | |
| exact β¨e,ContinuousMap.ext heβ© | |
| Β· exact Cayley.presentationCover_sphereFill s rels hrel hs hker (r.comp v) | |
| obtain β¨e,heβ© := hz | |
| have hzT : SphereTopology.Extends ((qT.comp r).comp v) := by | |
| refine β¨qT.comp e,?_β© | |
| apply ContinuousMap.ext; intro x | |
| exact congrArg qT (ContinuousMap.congr_fun he x) | |
| let J' := (ContinuousMap.Homotopy.refl inc).comp J | |
| obtain β¨d,hdβ© := SphereTopology.extends_of_homotopy (J'.trans (HT.compContinuousMap v)) hzT | |
| exact β¨d,fun x => ContinuousMap.congr_fun hd xβ© | |
| end UniversalFInfinity.Milnor | |
| open scoped TensorProduct | |
| end | |
| end OAI | |