| import OAI.GroupTheory.UniversalGroup.GraphBundles |
|
|
| 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.GraphBundle |
|
|
| section |
| open Set Topology |
| open scoped unitInterval |
| universe u v w |
| variable {C : Type u} {A : Type v} [TopologicalSpace A] {B : Type w} [TopologicalSpace B] |
| variable (τ : C → C) (L R : C → C(B,A)) |
|
|
| lemma edgeImage_edge_slice [DecidableEq C] (c d : C) (S : Set (I × B)) : |
| (fun z : I × B => edge τ L R d z.1 z.2) ⁻¹' |
| ((fun z : I × B => edge τ L R c z.1 z.2) '' S) = |
| (if d = c then S else ∅) ∪ |
| ({0} ×ˢ ((L d) ⁻¹' ((vertex τ L R d) ⁻¹' |
| ((fun z : I × B => edge τ L R c z.1 z.2) '' S)))) ∪ |
| ({1} ×ˢ ((R d) ⁻¹' ((vertex τ L R (τ d)) ⁻¹' |
| ((fun z : I × B => edge τ L R c z.1 z.2) '' S)))) := by |
| classical |
| ext ⟨t,x⟩ |
| constructor |
| · intro hz |
| by_cases h0 : t = 0 |
| · subst t |
| change edge τ L R d 0 x ∈ ((fun z : I × B => edge τ L R c z.1 z.2) '' S) at hz |
| exact Or.inl (Or.inr ⟨rfl,by |
| change vertex τ L R d (L d x) ∈ ((fun z : I × B => edge τ L R c z.1 z.2) '' S) |
| rw [edge_zero] at hz; exact hz⟩) |
| · by_cases h1 : t = 1 |
| · subst t |
| change edge τ L R d 1 x ∈ ((fun z : I × B => edge τ L R c z.1 z.2) '' S) at hz |
| exact Or.inr ⟨rfl,by |
| change vertex τ L R (τ d) (R d x) ∈ ((fun z : I × B => edge τ L R c z.1 z.2) '' S) |
| rw [edge_one] at hz; exact hz⟩ |
| · let s : Inner := ⟨t.1,lt_of_le_of_ne t.2.1 (fun h => h0 (Subtype.ext h.symm)), |
| lt_of_le_of_ne t.2.2 (fun h => h1 (Subtype.ext h))⟩ |
| have he : edge τ L R d t x = interior τ L R d s x := edge_inner τ L R d s x |
| obtain ⟨z,hz,hze⟩ := hz |
| have hm : z ∈ (fun z : I × B => edge τ L R c z.1 z.2) ⁻¹' {interior τ L R d s x} := hze.trans he |
| rw [interior_preimage] at hm |
| split_ifs at hm with hcd |
| · change z = (t,x) at hm |
| exact Or.inl (Or.inl (by rw [ite_eq_left hcd.symm]; exact hm ▸ hz)) |
| · exact False.elim hm |
| · rintro ((hz|hz)|hz) |
| · split_ifs at hz with hdc |
| · subst d; exact ⟨(t,x),hz,rfl⟩ |
| · exact False.elim hz |
| · rcases hz with ⟨h0,hx⟩ |
| change t = 0 at h0 |
| subst t |
| change edge τ L R d 0 x ∈ ((fun z : I × B => edge τ L R c z.1 z.2) '' S) |
| rw [edge_zero] |
| exact hx |
| · rcases hz with ⟨h1,hx⟩ |
| change t = 1 at h1 |
| subst t |
| change edge τ L R d 1 x ∈ ((fun z : I × B => edge τ L R c z.1 z.2) '' S) |
| rw [edge_one] |
| exact hx |
|
|
| lemma edge_injective (c : C) (hτ : τ c ≠ c) (hL : Function.Injective (L c)) |
| (hR : Function.Injective (R c)) : Function.Injective (fun z : I × B => edge τ L R c z.1 z.2) := by |
| classical |
| rintro ⟨t,x⟩ ⟨s,y⟩ he |
| by_cases h0 : t = 0 |
| · subst t |
| have he' : edge τ L R c s y = vertex τ L R c (L c x) := he.symm.trans (edge_zero τ L R c x) |
| rcases (edge_eq_vertex τ L R c c s y (L c x)).mp he' with ⟨rfl,_,hy⟩|⟨_,ht,_⟩ |
| · exact Prod.ext rfl (hL hy).symm |
| · exact False.elim (hτ ht) |
| · by_cases h1 : t = 1 |
| · subst t |
| have he' : edge τ L R c s y = vertex τ L R (τ c) (R c x) := he.symm.trans (edge_one τ L R c x) |
| rcases (edge_eq_vertex τ L R c (τ c) s y (R c x)).mp he' with ⟨_,ht,_⟩|⟨rfl,_,hy⟩ |
| · exact False.elim (hτ ht.symm) |
| · exact Prod.ext rfl (hR hy).symm |
| · let r : Inner := ⟨t.1,lt_of_le_of_ne t.2.1 (fun h => h0 (Subtype.ext h.symm)), |
| lt_of_le_of_ne t.2.2 (fun h => h1 (Subtype.ext h))⟩ |
| have ht : edge τ L R c t x = interior τ L R c r x := edge_inner τ L R c r x |
| have hm : (s,y) ∈ (fun z : I × B => edge τ L R c z.1 z.2) ⁻¹' {interior τ L R c r x} := he.symm.trans ht |
| rw [interior_preimage,ite_eq_left rfl] at hm |
| exact (show (s,y) = (t,x) from hm).symm |
|
|
| variable [TopologicalSpace C] [DiscreteTopology C] |
| lemma edge_closedMap (c : C) (hL : IsClosedMap (L c)) (hR : IsClosedMap (R c)) : |
| IsClosedMap (fun z : I × B => edge τ L R c z.1 z.2) := by |
| classical |
| intro S hS |
| apply (isClosed_iff τ L R _).mpr |
| refine ⟨fun d => edgeImage_vertex_closed τ L R c d S hS hL hR,fun d => ?_⟩ |
| rw [edgeImage_edge_slice] |
| apply IsClosed.union |
| · apply IsClosed.union |
| · split_ifs; exact hS; exact isClosed_empty |
| · exact isClosed_singleton.prod ((edgeImage_vertex_closed τ L R c d S hS hL hR).preimage (L d).continuous) |
| · exact isClosed_singleton.prod ((edgeImage_vertex_closed τ L R c (τ d) S hS hL hR).preimage (R d).continuous) |
|
|
| lemma edge_closedEmbedding (c : C) (hτ : τ c ≠ c) (hL : IsClosedEmbedding (L c)) |
| (hR : IsClosedEmbedding (R c)) : IsClosedEmbedding (fun z : I × B => edge τ L R c z.1 z.2) := |
| IsClosedEmbedding.of_continuous_injective_isClosedMap (edgeMap τ L R c).continuous |
| (edge_injective τ L R c hτ hL.injective hR.injective) |
| (edge_closedMap τ L R c hL.isClosedMap hR.isClosedMap) |
| end |
|
|
| open Set Topology |
| open scoped unitInterval |
| universe u v w z |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] |
| variable {A : Type v} [TopologicalSpace A] {B : Type w} [TopologicalSpace B] |
| variable (τ : C → C) (L R : C → C(B,A)) |
| variable {Y : Type z} [TopologicalSpace Y] |
|
|
| omit [DiscreteTopology C] in |
| lemma hom_ext {f g : C(Space τ L R,Y)} |
| (hv : ∀ c x,f (vertex τ L R c x) = g (vertex τ L R c x)) |
| (he : ∀ c (z : I × B),f (edge τ L R c z.1 z.2) = g (edge τ L R c z.1 z.2)) : f = g := by |
| apply ContinuousMap.ext |
| intro z |
| change Core (C := C) (A := A) (B := B) at z |
| cases z with |
| | inl z => exact hv z.1 z.2 |
| | inr z => |
| have hh := he z.1 (⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩,z.2.2) |
| rw [edge_inner] at hh |
| exact hh |
|
|
| variable (f g : C(Space τ L R,Y)) |
| variable (V : ∀ c,(f.comp (vertexMap τ L R c)).Homotopy (g.comp (vertexMap τ L R c))) |
| variable (E : ∀ c,(f.comp (edgeMap τ L R c)).Homotopy (g.comp (edgeMap τ L R c))) |
| variable (hE0 : ∀ c t x,E c (t,(0,x)) = V c (t,L c x)) |
| variable (hE1 : ∀ c t x,E c (t,(1,x)) = V (τ c) (t,R c x)) |
|
|
| def homotopyPaths : C(Space τ L R,C(I,Y)) := |
| lift τ L R (fun c => ContinuousMap.curry ((V c).toContinuousMap.comp ⟨Prod.swap,continuous_swap⟩)) |
| (fun c => ContinuousMap.curry ((E c).toContinuousMap.comp ⟨Prod.swap,continuous_swap⟩)) (by |
| intro c x; apply ContinuousMap.ext; intro t; exact hE0 c t x) (by |
| intro c x; apply ContinuousMap.ext; intro t; exact hE1 c t x) |
|
|
| def homotopy : f.Homotopy g where |
| toFun z := homotopyPaths τ L R f g V E hE0 hE1 z.2 z.1 |
| continuous_toFun := (homotopyPaths τ L R f g V E hE0 hE1).uncurry.continuous.comp continuous_swap |
| map_zero_left z := by |
| change Core (C := C) (A := A) (B := B) at z |
| cases z with |
| | inl z => exact (V z.1).apply_zero z.2 |
| | inr z => |
| have he := (E z.1).apply_zero (⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩,z.2.2) |
| change E z.1 (0,(⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩,z.2.2)) = f (edge τ L R z.1 ⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩ z.2.2) at he |
| rw [edge_inner] at he |
| exact he |
| map_one_left z := by |
| change Core (C := C) (A := A) (B := B) at z |
| cases z with |
| | inl z => exact (V z.1).apply_one z.2 |
| | inr z => |
| have he := (E z.1).apply_one (⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩,z.2.2) |
| change E z.1 (1,(⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩,z.2.2)) = g (edge τ L R z.1 ⟨z.2.1.1,z.2.1.2.1.le,z.2.1.2.2.le⟩ z.2.2) at he |
| rw [edge_inner] at he |
| exact he |
| end UniversalFInfinity.GraphBundle |
|
|
| namespace UniversalFInfinity.PathFamilies |
| open scoped unitInterval |
| universe u v |
| variable {J : Type u} [TopologicalSpace J] {Y : Type v} [TopologicalSpace Y] |
| def intervalPath : Path (0:I) 1 where |
| toFun := id |
| continuous_toFun := continuous_id |
| source' := rfl |
| target' := rfl |
|
|
| def unpause : C(I × I,I) := (Path.Homotopy.transRefl intervalPath).toContinuousMap |
|
|
| lemma transRefl_natural {x y : Y} (p : Path x y) (z : I × I) : |
| Path.Homotopy.transRefl p z = p (unpause z) := rfl |
|
|
| lemma continuous_transRefl {a b : J → Y} (p : ∀ j,Path (a j) (b j)) |
| (hp : Continuous (fun z : J × I => p z.1 z.2)) : |
| Continuous (fun z : J × (I × I) => Path.Homotopy.transRefl (p z.1) z.2) := by |
| change Continuous (fun z : J × (I × I) => p z.1 (unpause z.2)) |
| exact hp.comp (continuous_fst.prodMk (unpause.continuous.comp continuous_snd)) |
| end UniversalFInfinity.PathFamilies |
|
|
| namespace UniversalFInfinity.GraphBundle |
|
|
| section |
| open Set Topology |
| open scoped unitInterval |
| universe u v w |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] |
| variable {A : Type v} [TopologicalSpace A] {B : Type w} [TopologicalSpace B] |
| variable (τ : C → C) (L R : C → C(B,A)) |
|
|
| def edgePath (c : C) (x : B) : Path (vertex τ L R c (L c x)) (vertex τ L R (τ c) (R c x)) where |
| toFun t := edge τ L R c t x |
| continuous_toFun := (edgeMap τ L R c).continuous.comp (continuous_id.prodMk continuous_const) |
| source' := edge_zero τ L R c x |
| target' := edge_one τ L R c x |
|
|
| omit [DiscreteTopology C] in |
| lemma edgePath_continuous (c : C) : Continuous (fun z : B × I => edgePath τ L R c z.1 z.2) := |
| (edgeMap τ L R c).continuous.comp continuous_swap |
|
|
| def pausedEdge (c : C) (x : B) := (edgePath τ L R c x).trans (Path.refl _) |
| omit [DiscreteTopology C] in |
| lemma pausedEdge_continuous (c : C) : Continuous (fun z : B × I => pausedEdge τ L R c z.1 z.2) := |
| Path.trans_continuous_family (edgePath τ L R c) (edgePath_continuous τ L R c) |
| (fun x => Path.refl (vertex τ L R (τ c) (R c x))) |
| ((vertexMap τ L R (τ c)).continuous.comp ((R c).continuous.comp continuous_fst)) |
|
|
| def pause : C(Space τ L R,Space τ L R) := |
| lift τ L R (vertexMap τ L R) |
| (fun c => ⟨fun z => pausedEdge τ L R c z.2 z.1,(pausedEdge_continuous τ L R c).comp continuous_swap⟩) |
| (fun c x => (pausedEdge τ L R c x).source) |
| (fun c x => (pausedEdge τ L R c x).target) |
| lemma pause_vertex (c : C) (x : A) : pause τ L R (vertex τ L R c x) = vertex τ L R c x := rfl |
| lemma pause_edge (c : C) (z : I × B) : pause τ L R (edge τ L R c z.1 z.2) = pausedEdge τ L R c z.2 z.1 := |
| lift_edge τ L R _ _ _ _ c z |
|
|
| def pauseVertexHomotopy (c : C) : |
| ((pause τ L R).comp (vertexMap τ L R c)).Homotopy ((ContinuousMap.id _).comp (vertexMap τ L R c)) := |
| ContinuousMap.Homotopy.refl (vertexMap τ L R c) |
|
|
| omit [DiscreteTopology C] in |
| lemma pauseEdgeHomotopy_continuous (c : C) : |
| Continuous (fun z : I × (I × B) => |
| Path.Homotopy.transRefl (edgePath τ L R c z.2.2) (z.1,z.2.1)) := by |
| change Continuous (fun z : I × (I × B) => |
| edge τ L R c (PathFamilies.unpause (z.1,z.2.1)) z.2.2) |
| exact (edgeMap τ L R c).continuous.comp |
| ((PathFamilies.unpause.continuous.comp (continuous_fst.prodMk continuous_snd.fst)).prodMk |
| continuous_snd.snd) |
|
|
| def pauseEdgeHomotopy (c : C) : |
| ((pause τ L R).comp (edgeMap τ L R c)).Homotopy ((ContinuousMap.id _).comp (edgeMap τ L R c)) where |
| toFun z := Path.Homotopy.transRefl (edgePath τ L R c z.2.2) (z.1,z.2.1) |
| continuous_toFun := pauseEdgeHomotopy_continuous τ L R c |
| map_zero_left z := by |
| change Path.Homotopy.transRefl (edgePath τ L R c z.2) (0,z.1) = pause τ L R (edge τ L R c z.1 z.2) |
| rw [pause_edge] |
| exact (Path.Homotopy.transRefl (edgePath τ L R c z.2)).apply_zero z.1 |
| map_one_left z := (Path.Homotopy.transRefl (edgePath τ L R c z.2)).apply_one z.1 |
|
|
| def pauseHomotopy : (pause τ L R).Homotopy (ContinuousMap.id _) := |
| homotopy τ L R (pause τ L R) (ContinuousMap.id _) (pauseVertexHomotopy τ L R) |
| (pauseEdgeHomotopy τ L R) (fun c t x => (Path.Homotopy.transRefl (edgePath τ L R c x)).source t) |
| (fun c t x => (Path.Homotopy.transRefl (edgePath τ L R c x)).target t) |
| end |
|
|
| section |
| open Set Topology |
| open scoped unitInterval |
| universe u v w z |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] |
| variable {D : Type v} [TopologicalSpace D] [DiscreteTopology D] |
| variable {A : Type w} [TopologicalSpace A] {B : Type z} [TopologicalSpace B] |
| variable (τ : C → C) (F : C → C(A,A)) (ν : D → D) (K : D → C(B,B)) |
| variable (sig : C → D) (hsig : ∀ c,sig (τ c) = ν (sig c)) (a : C → C(A,B)) |
| variable (ha : ∀ c x,a (τ c) (F c x) = K (sig c) (a c x)) |
|
|
| def homogeneousMap : C(Space τ (fun _ => .id A) F,Space ν (fun _ => .id B) K) := |
| lift τ (fun _ => .id A) F |
| (fun c => (vertexMap ν (fun _ => .id B) K (sig c)).comp (a c)) |
| (fun c => (edgeMap ν (fun _ => .id B) K (sig c)).comp |
| ⟨fun z => (z.1,a c z.2), continuous_fst.prodMk ((a c).continuous.comp continuous_snd)⟩) |
| (fun c x => edge_zero ν _ K (sig c) (a c x)) |
| (fun c x => by change edge ν _ K (sig c) 1 (a c x) = vertex ν _ K (sig (τ c)) (a (τ c) (F c x)); rw [edge_one,hsig,ha]) |
| omit [DiscreteTopology D] in |
| lemma homogeneousMap_vertex (c : C) (x : A) : |
| homogeneousMap τ F ν K sig hsig a ha (vertex τ (fun _ => .id A) F c x) = |
| vertex ν (fun _ => .id B) K (sig c) (a c x) := rfl |
| omit [DiscreteTopology D] in |
| lemma homogeneousMap_edge (c : C) (t : I) (x : A) : |
| homogeneousMap τ F ν K sig hsig a ha (edge τ (fun _ => .id A) F c t x) = |
| edge ν (fun _ => .id B) K (sig c) t (a c x) := lift_edge τ _ F _ _ _ _ c (t,x) |
| end |
|
|
| open Set Topology |
| open scoped unitInterval |
| universe u v w |
| variable {G : Type u} [Group G] |
| variable {C : Type v} [TopologicalSpace C] [DiscreteTopology C] [MulAction G C] |
| variable {A : Type w} [TopologicalSpace A] |
| variable (τ : C → C) (F : C → C(A,A)) (hτ : ∀ (g : G) c,τ (g • c) = g • τ c) |
| variable (a : G → C → C(A,A)) |
| variable (ha : ∀ (g : G) c x,a g (τ c) (F c x) = F (g • c) (a g c x)) |
| variable (a_one : ∀ c x,a 1 c x = x) |
| variable (a_mul : ∀ (g h : G) c x,a (g*h) c x = a g (h • c) (a h c x)) |
|
|
| def actionMap (g : G) : C(Space τ (fun _ => .id A) F,Space τ (fun _ => .id A) F) := |
| homogeneousMap τ F τ F (g • ·) (fun c => (hτ g c).symm) (a g) (ha g) |
| lemma actionMap_vertex (g : G) (c : C) (x : A) : |
| actionMap τ F hτ a ha g (vertex τ (fun _ => .id A) F c x) = |
| vertex τ (fun _ => .id A) F (g • c) (a g c x) := rfl |
| lemma actionMap_edge (g : G) (c : C) (t : I) (x : A) : |
| actionMap τ F hτ a ha g (edge τ (fun _ => .id A) F c t x) = |
| edge τ (fun _ => .id A) F (g • c) t (a g c x) := |
| homogeneousMap_edge τ F τ F _ _ _ _ c t x |
|
|
| @[instance_reducible] |
| def graphAction : MulAction G (Space τ (fun _ => .id A) F) where |
| smul g x := actionMap τ F hτ a ha g x |
| one_smul x := by |
| have he : actionMap τ F hτ a ha 1 = ContinuousMap.id _ := by |
| apply hom_ext τ (fun _ => .id A) F |
| · intro c y; rw [actionMap_vertex,one_smul,a_one]; rfl |
| · intro c z; rw [actionMap_edge,one_smul,a_one]; rfl |
| exact ContinuousMap.congr_fun he x |
| mul_smul g h x := by |
| have he : actionMap τ F hτ a ha (g*h) = (actionMap τ F hτ a ha g).comp (actionMap τ F hτ a ha h) := by |
| apply hom_ext τ (fun _ => .id A) F |
| · intro c y; simp only [ContinuousMap.comp_apply,actionMap_vertex,mul_smul,a_mul] |
| · intro c z; simp only [ContinuousMap.comp_apply,actionMap_edge,mul_smul,a_mul] |
| exact ContinuousMap.congr_fun he x |
|
|
| lemma graphAction_continuous : @ContinuousConstSMul G (Space τ (fun _ => .id A) F) _ |
| (graphAction τ F hτ a ha a_one a_mul).toSMul := |
| by |
| let := graphAction τ F hτ a ha a_one a_mul |
| exact ⟨fun g => (actionMap τ F hτ a ha g).continuous⟩ |
| end UniversalFInfinity.GraphBundle |
|
|
| end |
|
|
| end OAI |
|
|
