openAI-math-dataset / lean /OAI /GroupTheory /SimpleAmenable /Configurations /PolygonTrajectoryStrata.lean
| import Mathlib | |
| import OAI.GroupTheory.SimpleAmenable.PolygonGeometry.PeriodicSlotStars | |
| import OAI.GroupTheory.SimpleAmenable.Configurations.PolygonStringGroupoid | |
| namespace OAI | |
| section | |
| section | |
| open scoped symmDiff | |
| namespace SimpleAmenable | |
| open scoped commutatorElement | |
| open scoped commutatorElement | |
| section PolygonTrajectoryStrata | |
| open Classical CategoryTheory Set | |
| namespace PolygonObject | |
| variable {a n : ℕ} | |
| theorem representative_add (u v : CutRing × CutRing) : | |
| orbitRepresentative (u+v)=orbitRepresentative u+orbitRepresentative v := by | |
| simp [orbitRepresentative,add_mul] | |
| @[simp] theorem representative_idem (u : CutRing × CutRing) : | |
| orbitRepresentative (orbitRepresentative u)=orbitRepresentative u := by | |
| simp [orbitRepresentative,cutTau] | |
| theorem arrow_displacement_exists {U V : PolygonObject a} (f : U ⟶ V) (x : U.Point) : | |
| ∃u,(f.toEquiv x).val.2=translate a u x.val.2 := by | |
| obtain ⟨s,hs,hcover⟩ := f.hasTable | |
| obtain ⟨c,hc,ht,hx⟩ := hcover x | |
| obtain ⟨hu,he⟩ := hs c hc x.val.2 hx | |
| have hpoint : (⟨(c.source,x.val.2),hu⟩ : U.Point)=x := | |
| Subtype.ext (Prod.ext ht.symm rfl) | |
| rw [hpoint] at he | |
| exact ⟨c.shift,congrArg Prod.snd he⟩ | |
| noncomputable def pointShift {U V : PolygonObject a} (f : U ⟶ V) (x : U.Point) : | |
| CutRing × CutRing := orbitRepresentative (arrow_displacement_exists f x).choose | |
| theorem pointShift_spec {U V : PolygonObject a} (f : U ⟶ V) (x : U.Point) : | |
| (f.toEquiv x).val.2=translate a (pointShift f x) x.val.2 := | |
| (arrow_displacement_exists f x).choose_spec.trans (translate_orbitRepresentative _ _ _) | |
| theorem pointShift_unique {U V : PolygonObject a} (f : U ⟶ V) (x : U.Point) | |
| (u : CutRing × CutRing) (he : (f.toEquiv x).val.2=translate a u x.val.2) : | |
| pointShift f x=orbitRepresentative u := | |
| orbitRepresentative_eq_of_translate_eq x.val.2 | |
| ((arrow_displacement_exists f x).choose_spec.symm.trans he) | |
| @[simp] theorem pointShift_reduced {U V : PolygonObject a} (f : U ⟶ V) (x : U.Point) : | |
| orbitRepresentative (pointShift f x)=pointShift f x := representative_idem _ | |
| @[simp] theorem pointShift_id (U : PolygonObject a) (x : U.Point) : pointShift (𝟙 U) x=0 := by | |
| change pointShift (𝟙 U) x=(0,0) | |
| simpa [orbitRepresentative] using pointShift_unique (𝟙 U) x 0 (by simp [arrow_id_apply]) | |
| theorem pointShift_comp {U V W : PolygonObject a} (f : U ⟶ V) (g : V ⟶ W) (x : U.Point) : | |
| pointShift (f≫g) x=pointShift g (f.toEquiv x)+pointShift f x := by | |
| have he := pointShift_unique (f≫g) x (pointShift g (f.toEquiv x)+pointShift f x) (by | |
| rw [arrow_comp_apply,pointShift_spec g,pointShift_spec f,translate_add]) | |
| simpa only [representative_add,pointShift_reduced] using he | |
| theorem chart_pointShift {U V : PolygonObject a} (f : U ⟶ V) | |
| (c : Chart (a:=a) U.tracks V.tracks) (hc : c.Holds f.toEquiv) (x : U.Point) | |
| (hx : c.Contains x) : pointShift f x=orbitRepresentative c.shift := by | |
| obtain ⟨hu,he⟩ := hc x.val.2 hx.2 | |
| have hpoint : (⟨(c.source,x.val.2),hu⟩ : U.Point)=x := | |
| Subtype.ext (Prod.ext hx.1.symm rfl) | |
| rw [hpoint] at he | |
| exact pointShift_unique f x _ (congrArg Prod.snd he) | |
| theorem pointShift_finite_range {U V : PolygonObject a} (f : U ⟶ V) : | |
| (Set.range (pointShift f)).Finite := by | |
| obtain ⟨s,hs,hcover⟩ := f.hasTable | |
| apply (s.finite_toSet.image (fun c => orbitRepresentative c.shift)).subset | |
| rintro _ ⟨x,rfl⟩ | |
| obtain ⟨c,hc,hx⟩ := hcover x | |
| exact ⟨c,hc,(chart_pointShift f c (hs c hc) x hx).symm⟩ | |
| theorem pointShift_fiber_polygon {U V : PolygonObject a} (f : U ⟶ V) | |
| (i : Fin U.tracks) (u : CutRing × CutRing) : | |
| {z | ∃hz : z∈(U.cell i).val, pointShift f ⟨(i,z),hz⟩=u}∈polygonAlgebra a := by | |
| obtain ⟨s,hs,hcover⟩ := f.hasTable | |
| have he : {z | ∃hz : z∈(U.cell i).val, pointShift f ⟨(i,z),hz⟩=u} = | |
| ⋃c∈s.filter (fun c => c.source=i ∧ orbitRepresentative c.shift=u),c.domain.val := by | |
| ext z | |
| constructor | |
| · rintro ⟨hz,hu⟩ | |
| obtain ⟨c,hc,hz'⟩ := hcover ⟨(i,z),hz⟩ | |
| exact Set.mem_iUnion₂.mpr ⟨c,Finset.mem_filter.mpr ⟨hc,hz'.1.symm, | |
| (chart_pointShift f c (hs c hc) ⟨(i,z),hz⟩ hz').symm.trans hu⟩,hz'.2⟩ | |
| · intro hz | |
| obtain ⟨c,hcf,hcz⟩ := Set.mem_iUnion₂.mp hz | |
| obtain ⟨hcs,hci,hcu⟩ := Finset.mem_filter.mp hcf | |
| obtain ⟨hz',hf⟩ := hs c hcs z hcz | |
| subst i | |
| refine ⟨hz',?_⟩ | |
| exact (chart_pointShift f c (hs c hcs) ⟨(c.source,z),hz'⟩ ⟨rfl,hcz⟩).trans hcu | |
| rw [he] | |
| apply BooleanSubalgebra.biSup_mem (Finset.finite_toSet _) | |
| intro c _ | |
| exact c.domain.property | |
| noncomputable def trajectoryShift (F : RawString a n) (x : (F.obj 0).Point) : | |
| Fin (n+1) → CutRing × CutRing := fun i => pointShift (baseArrow F i) x | |
| theorem trajectoryShift_fiber_polygon (F : RawString a n) (j : Fin (F.obj 0).tracks) | |
| (u : Fin (n+1) → CutRing × CutRing) : | |
| {z | ∃hz : z∈((F.obj 0).cell j).val, trajectoryShift F ⟨(j,z),hz⟩=u}∈polygonAlgebra a := by | |
| have he : {z | ∃hz : z∈((F.obj 0).cell j).val, trajectoryShift F ⟨(j,z),hz⟩=u} = | |
| ⋂i : Fin (n+1),{z | ∃hz : z∈((F.obj 0).cell j).val, | |
| pointShift (baseArrow F i) ⟨(j,z),hz⟩=u i} := by | |
| ext z | |
| constructor | |
| · rintro ⟨hz,hu⟩ | |
| exact Set.mem_iInter.mpr (fun i => ⟨hz,congrFun hu i⟩) | |
| · intro hz | |
| have h := Set.mem_iInter.mp hz | |
| obtain ⟨hz',_⟩ := h 0 | |
| refine ⟨hz',?_⟩ | |
| funext i | |
| exact (h i).choose_spec | |
| rw [he] | |
| exact BooleanSubalgebra.iInf_mem (fun i => pointShift_fiber_polygon (baseArrow F i) j (u i)) | |
| theorem trajectoryShift_finite_range (F : RawString a n) : | |
| (Set.range (trajectoryShift F)).Finite := by | |
| let S (i : Fin (n+1)) := Set.range (pointShift (baseArrow F i)) | |
| let : ∀ index, Finite (S index) := fun index => | |
| (pointShift_finite_range (baseArrow F index)).to_subtype | |
| let val : (∀i,S i) → (Fin (n+1) → CutRing × CutRing) := fun t i => (t i).val | |
| apply (Set.finite_range val).subset | |
| rintro _ ⟨x,rfl⟩ | |
| exact ⟨fun i => ⟨pointShift (baseArrow F i) x,⟨x,rfl⟩⟩,rfl⟩ | |
| theorem ladder_preserves_trajectoryShift {F G : StringGroupoid a n} (h : F ⟶ G) | |
| (x : (F.obj.obj 0).Point) : | |
| trajectoryShift G.obj ((h.hom.app 0).toEquiv x)=trajectoryShift F.obj x := by | |
| funext i | |
| have he : translate a (pointShift (baseArrow G.obj i) ((h.hom.app 0).toEquiv x)) x.val.2 = | |
| translate a (pointShift (baseArrow F.obj i) x) x.val.2 := by | |
| calc | |
| _ = translate a (pointShift (baseArrow G.obj i) ((h.hom.app 0).toEquiv x)) | |
| ((h.hom.app 0).toEquiv x).val.2 := congrArg _ (h.property 0 x).symm | |
| _ = trajectory G.obj ((h.hom.app 0).toEquiv x) i := (pointShift_spec _ _).symm | |
| _ = trajectory F.obj x i := congrFun (ladder_preserves_trajectory h x) i | |
| _ = _ := pointShift_spec _ _ | |
| exact (pointShift_reduced _ _).symm.trans | |
| ((orbitRepresentative_eq_of_translate_eq x.val.2 he).trans (pointShift_reduced _ _)) | |
| theorem trajectory_stratification (F : RawString a n) : | |
| ∃s : Finset (Fin (n+1) → CutRing × CutRing), | |
| (∀x,trajectoryShift F x∈s) ∧ | |
| (∀j u,{z | ∃hz : z∈((F.obj 0).cell j).val, | |
| trajectoryShift F ⟨(j,z),hz⟩=u}∈polygonAlgebra a) := by | |
| refine ⟨(trajectoryShift_finite_range F).toFinset,?_,trajectoryShift_fiber_polygon F⟩ | |
| intro x | |
| exact (Set.Finite.mem_toFinset _).mpr ⟨x,rfl⟩ | |
| end PolygonObject | |
| end PolygonTrajectoryStrata | |
| end SimpleAmenable | |
| end | |
| end | |
| end OAI | |