| import Mathlib |
| import OAI.Algebra.GroupRing.ConeCells |
|
|
| namespace OAI |
|
|
|
|
|
|
| section |
| namespace TorsionFreeZeroDivisors.DiskTracks |
| open Set Metric Topology GroupRingTopology GroupRingTopology.Attachment |
| open GroupRingTopology.Cellular hiding Disk Sphere boundary |
| open scoped unitInterval |
| noncomputable section |
| variable {Y : Type} [TopologicalSpace Y] {y : Y} {p : Path y y} |
| def square (c : Path p (Path.refl y)) : C(Disk 2,Y) := |
| ⟨fun d=>c (diskTime d) (Cayley.edgeTime (diskTail d)), |
| (Path.continuous_uncurry_iff.mpr c.continuous).comp |
| (continuous_diskTime.prodMk (Cayley.continuous_edgeTime.comp continuous_diskTail))⟩ |
| lemma square_boundary (c : Path p (Path.refl y)) (z : Sphere 2) : |
| square c (boundary 2 z)=LoopSphere.map p z := by |
| have hz : z∈⋃i,cylinderFace 1 i := by rw [cylinderFace_cover];trivial |
| obtain ⟨i,hi⟩ := Set.mem_iUnion.mp hz |
| change _=cylinderBoundaryMap _ _ _ z |
| rw [cylinderBoundaryMap_face _ _ _ i ⟨z,hi⟩] |
| cases i with |
| | none => |
| have he : diskTail (boundary 2 z)=boundary 1 (faceSphere ⟨z,hi⟩) := rfl |
| change c (diskTime (boundary 2 z)) (Cayley.edgeTime (diskTail (boundary 2 z)))=y |
| rw [he] |
| obtain hh|hh := Cayley.sphere_one_eq (faceSphere ⟨z,hi⟩) |
| · rw [hh,Cayley.edgeTime_minus,Path.source] |
| · rw [hh,Cayley.edgeTime_plus,Path.target] |
| | some b => |
| cases b |
| · have ht : diskTime (boundary 2 z)=0 := by |
| apply Subtype.ext |
| change (z.1 0+1)/2=0 |
| change z.1 0= -1 at hi |
| rw [hi];norm_num |
| change c (diskTime (boundary 2 z)) (Cayley.edgeTime (diskTail (boundary 2 z)))=p _ |
| rw [ht,c.source];rfl |
| · have ht : diskTime (boundary 2 z)=1 := by |
| apply Subtype.ext |
| change (z.1 0+1)/2=1 |
| change z.1 0=1 at hi |
| rw [hi];norm_num |
| change c (diskTime (boundary 2 z)) (Cayley.edgeTime (diskTail (boundary 2 z)))=y |
| rw [ht,c.target];rfl |
| variable (F : C(Disk 2,Y)) (hF : ∀z,F (boundary 2 z)=LoopSphere.map p z) |
| def physical : Path p (Path.refl y) where |
| toFun t := { |
| toFun s := F (diskCons (Cayley.edgeParam s) t) |
| continuous_toFun := F.continuous.comp (continuous_diskCons.comp |
| (Cayley.continuous_edgeParam.prodMk continuous_const)) |
| source' := by |
| rw [Cayley.edgeParam_zero] |
| erw [hF ⟨_,cons_mem_sphere_of_boundary Cayley.minus t⟩] |
| exact GraphConeCW.cylinder_side _ _ _ _ _ |
| target' := by |
| rw [Cayley.edgeParam_one] |
| erw [hF ⟨_,cons_mem_sphere_of_boundary Cayley.plus t⟩] |
| exact GraphConeCW.cylinder_side _ _ _ _ _ } |
| continuous_toFun := Path.continuous_uncurry_iff.mp (F.continuous.comp |
| (continuous_diskCons.comp ((Cayley.continuous_edgeParam.comp continuous_snd).prodMk continuous_fst))) |
| source' := by |
| ext s |
| change F (diskCons (Cayley.edgeParam s) 0)=p s |
| erw [hF ⟨_,cons_zero_mem_sphere (Cayley.edgeParam s)⟩] |
| unfold LoopSphere.map |
| erw [GraphConeCW.cylinder_bottom] |
| change p (Cayley.edgeTime (Cayley.edgeParam s))=p s |
| rw [Cayley.edgeTime_param] |
| target' := by |
| ext s |
| change F (diskCons (Cayley.edgeParam s) 1)=y |
| erw [hF ⟨_,cons_one_mem_sphere (Cayley.edgeParam s)⟩] |
| exact GraphConeCW.cylinder_top _ _ _ _ |
| lemma square_physical : square (physical F hF)=F := by |
| ext d |
| change F (diskCons (Cayley.edgeParam (Cayley.edgeTime (diskTail d))) (diskTime d))=F d |
| rw [Cayley.edgeParam_time,GraphConeCW.cons_tail_time] |
|
|
| def shift (t s : unitInterval) : unitInterval := |
| ⟨t+(1-t)*s,by constructor <;> nlinarith [t.2.1,t.2.2,s.2.1,s.2.2]⟩ |
| lemma continuous_shift : Continuous (fun q : unitInterval×unitInterval=>shift q.1 q.2) := by |
| apply Continuous.subtype_mk |
| fun_prop |
| @[simp] lemma shift_zero (s : unitInterval) : shift 0 s=s := by ext;simp [shift] |
| @[simp] lemma shift_one (s : unitInterval) : shift 1 s=1 := by ext;simp [shift] |
| @[simp] lemma shift_zero_right (t : unitInterval) : shift t 0=t := by ext;simp [shift] |
| @[simp] lemma shift_one_right (t : unitInterval) : shift t 1=1 := by ext;simp [shift] |
| def tail (c : Path p (Path.refl y)) (t : unitInterval) : Path (c t) (Path.refl y) where |
| toFun s:=c (shift t s) |
| continuous_toFun:=c.continuous.comp (continuous_shift.comp (continuous_const.prodMk continuous_id)) |
| source':=by rw [shift_zero_right] |
| target':=by rw [shift_one_right,c.target] |
| def contract (c : Path p (Path.refl y)) : (square c).Homotopy (.const _ y) where |
| toFun z:=square (tail c z.1) z.2 |
| continuous_toFun := (Path.continuous_uncurry_iff.mpr c.continuous).comp |
| ((continuous_shift.comp (continuous_fst.prodMk (continuous_diskTime.comp continuous_snd))).prodMk |
| (Cayley.continuous_edgeTime.comp (continuous_diskTail.comp continuous_snd))) |
| map_zero_left d := by change c (shift 0 (diskTime d)) _=c _ _;rw [shift_zero] |
| map_one_left d := by change c (shift 1 (diskTime d)) _=y;rw [shift_one,c.target];rfl |
| lemma contract_boundary (c : Path p (Path.refl y)) (t : unitInterval) (z : Sphere 2) : |
| contract c (t,boundary 2 z)=LoopSphere.map (c t) z := square_boundary (tail c t) z |
| end |
| end TorsionFreeZeroDivisors.DiskTracks |
|
|
| end |
|
|
|
|
|
|
| end OAI |
|
|
