| import OAI.GroupTheory.UniversalGroup.TorusBundles |
|
|
| 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.PathFamilies |
| open scoped unitInterval |
| universe u v |
| variable {Y : Type u} [TopologicalSpace Y] {X : Type v} [TopologicalSpace X] |
| variable {x y z : Y} |
|
|
| def diagonalSquare (p : Path x y) (q : Path y z) : C(I × I,Y) := |
| ⟨fun s => (p.trans q).extend (((s.1:ℝ)+(s.2:ℝ))/2), |
| (p.trans q).continuous_extend.comp (by fun_prop)⟩ |
|
|
| lemma diagonalSquare_zero_left (p : Path x y) (q : Path y z) (s : I) : |
| diagonalSquare p q (0,s) = p s := by |
| change (p.trans q).extend (((0:ℝ)+(s:ℝ))/2) = p s |
| rw [Path.extend_trans_of_le_half p q (by have := s.2.2; linarith)] |
| rw [show 2*(((0:ℝ)+(s:ℝ))/2) = (s:ℝ) by ring] |
| exact p.extend_apply s.2 |
| lemma diagonalSquare_one_left (p : Path x y) (q : Path y z) (s : I) : |
| diagonalSquare p q (1,s) = q s := by |
| change (p.trans q).extend (((1:ℝ)+(s:ℝ))/2) = q s |
| rw [Path.extend_trans_of_half_le p q (by have := s.2.1; linarith)] |
| rw [show 2*(((1:ℝ)+(s:ℝ))/2)-1 = (s:ℝ) by ring] |
| exact q.extend_apply s.2 |
| lemma diagonalSquare_symm (p : Path x y) (q : Path y z) (t s : I) : |
| diagonalSquare p q (t,s) = diagonalSquare p q (s,t) := by |
| change (p.trans q).extend _ = (p.trans q).extend _ |
| rw [add_comm (t:ℝ) (s:ℝ)] |
| lemma diagonalSquare_zero_right (p : Path x y) (q : Path y z) (t : I) : |
| diagonalSquare p q (t,0) = p t := by |
| rw [diagonalSquare_symm,diagonalSquare_zero_left] |
| lemma diagonalSquare_one_right (p : Path x y) (q : Path y z) (t : I) : |
| diagonalSquare p q (t,1) = q t := by |
| rw [diagonalSquare_symm,diagonalSquare_one_left] |
|
|
| lemma diagonalSquare_continuous {a b c : X → Y} |
| (p : ∀ x,Path (a x) (b x)) (q : ∀ x,Path (b x) (c x)) |
| (hp : Continuous (fun z : X × I => p z.1 z.2)) |
| (hq : Continuous (fun z : X × I => q z.1 z.2)) : |
| Continuous (fun z : X × (I × I) => diagonalSquare (p z.1) (q z.1) z.2) := by |
| exact (Path.continuous_uncurry_extend_of_continuous_family |
| (fun x => (p x).trans (q x)) (Path.trans_continuous_family p hp q hq)).comp |
| (continuous_fst.prodMk (by fun_prop)) |
| lemma diagonalSquare_continuous_params {a b c : X → Y} |
| (p : ∀ x,Path (a x) (b x)) (q : ∀ x,Path (b x) (c x)) |
| (hp : Continuous (fun z : X × I => p z.1 z.2)) |
| (hq : Continuous (fun z : X × I => q z.1 z.2)) : |
| Continuous (fun z : I × (I × X) => diagonalSquare (p z.2.2) (q z.2.2) (z.1,z.2.1)) := by |
| have hc : Continuous (fun z : I × (I × X) => (z.2.2,(z.1,z.2.1))) := |
| continuous_snd.snd.prodMk (continuous_fst.prodMk continuous_snd.fst) |
| exact (diagonalSquare_continuous p q hp hq).comp hc |
| end UniversalFInfinity.PathFamilies |
|
|
| namespace UniversalFInfinity.GraphBundle |
|
|
| section |
| open Set Topology |
| open scoped unitInterval |
| universe u v |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] |
| variable {A : Type v} [TopologicalSpace A] |
| variable (τ : C → C) (F : C → C(A,A)) |
|
|
| abbrev Homogeneous := Space τ (fun _ => ContinuousMap.id A) F |
|
|
| def shift : C(Homogeneous τ F,Homogeneous τ F) := |
| lift τ (fun _ => .id A) F |
| (fun c => (vertexMap τ (fun _ => .id A) F (τ c)).comp (F c)) |
| (fun c => (edgeMap τ (fun _ => .id A) F (τ c)).comp |
| ⟨fun z => (z.1,F c z.2),continuous_fst.prodMk ((F c).continuous.comp continuous_snd)⟩) |
| (fun c x => edge_zero τ _ F (τ c) (F c x)) |
| (fun c x => edge_one τ _ F (τ c) (F c x)) |
| lemma shift_vertex (c : C) (x : A) : |
| shift τ F (vertex τ (fun _ => .id A) F c x) = vertex τ (fun _ => .id A) F (τ c) (F c x) := rfl |
| lemma shift_edge (c : C) (t : I) (x : A) : |
| shift τ F (edge τ (fun _ => .id A) F c t x) = edge τ (fun _ => .id A) F (τ c) t (F c x) := |
| lift_edge τ _ F _ _ _ _ c (t,x) |
|
|
| def shiftVertexHomotopy (c : C) : |
| ((ContinuousMap.id _).comp (vertexMap τ (fun _ => .id A) F c)).Homotopy |
| ((shift τ F).comp (vertexMap τ (fun _ => .id A) F c)) where |
| toFun z := edge τ (fun _ => .id A) F c z.1 z.2 |
| continuous_toFun := (edgeMap τ (fun _ => .id A) F c).continuous |
| map_zero_left x := edge_zero τ _ F c x |
| map_one_left x := edge_one τ _ F c x |
|
|
| omit [DiscreteTopology C] in |
| lemma shiftEdge_continuous (c : C) : |
| Continuous (fun z : I × (I × A) => |
| PathFamilies.diagonalSquare (edgePath τ (fun _ => .id A) F c z.2.2) |
| (edgePath τ (fun _ => .id A) F (τ c) (F c z.2.2)) (z.1,z.2.1)) := by |
| let p : ∀ x : A, Path (vertex τ (fun _ => .id A) F c x) |
| (vertex τ (fun _ => .id A) F (τ c) (F c x)) := edgePath τ (fun _ => .id A) F c |
| let q : ∀ x : A, Path (vertex τ (fun _ => .id A) F (τ c) (F c x)) |
| (vertex τ (fun _ => .id A) F (τ (τ c)) (F (τ c) (F c x))) := |
| fun x => edgePath τ (fun _ => .id A) F (τ c) (F c x) |
| have hp : Continuous (fun z : A × I => p z.1 z.2) := |
| (edgeMap τ (fun _ => .id A) F c).continuous.comp continuous_swap |
| have hq : Continuous (fun z : A × I => q z.1 z.2) := |
| (edgeMap τ (fun _ => .id A) F (τ c)).continuous.comp |
| (continuous_snd.prodMk ((F c).continuous.comp continuous_fst)) |
| exact PathFamilies.diagonalSquare_continuous_params p q hp hq |
|
|
| def shiftEdgeHomotopy (c : C) : |
| ((ContinuousMap.id _).comp (edgeMap τ (fun _ => .id A) F c)).Homotopy |
| ((shift τ F).comp (edgeMap τ (fun _ => .id A) F c)) where |
| toFun z := PathFamilies.diagonalSquare (edgePath τ (fun _ => .id A) F c z.2.2) |
| (edgePath τ (fun _ => .id A) F (τ c) (F c z.2.2)) (z.1,z.2.1) |
| continuous_toFun := shiftEdge_continuous τ F c |
| map_zero_left z := PathFamilies.diagonalSquare_zero_left _ _ z.1 |
| map_one_left z := (PathFamilies.diagonalSquare_one_left _ _ z.1).trans (shift_edge τ F c z.1 z.2).symm |
|
|
| def shiftHomotopy : (ContinuousMap.id (Homogeneous τ F)).Homotopy (shift τ F) := |
| homotopy τ (fun _ => .id A) F _ _ (shiftVertexHomotopy τ F) (shiftEdgeHomotopy τ F) |
| (fun _ t _ => PathFamilies.diagonalSquare_zero_right _ _ t) |
| (fun _ t _ => PathFamilies.diagonalSquare_one_right _ _ t) |
|
|
| def shiftIterate : ℕ → C(Homogeneous τ F,Homogeneous τ F) |
| | 0 => .id _ |
| | n+1 => (shift τ F).comp (shiftIterate n) |
| def shiftIterateHomotopy : ∀ n,(ContinuousMap.id _).Homotopy (shiftIterate τ F n) |
| | 0 => .refl _ |
| | n+1 => (shiftIterateHomotopy n).trans ((shiftHomotopy τ F).compContinuousMap (shiftIterate τ F n)) |
| end |
|
|
| open Set Topology |
| open scoped unitInterval |
| universe u v |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] |
| variable {A : Type v} [TopologicalSpace A] |
| variable (τ : C → C) (F : C → C(A,A)) |
|
|
| def forward : ℕ → C → C(A,A) |
| | 0,_ => .id _ |
| | n+1,c => (F (τ^[n] c)).comp (forward n c) |
| omit [TopologicalSpace C] [DiscreteTopology C] in |
| lemma forward_natural (n : ℕ) (c : C) (x : A) : |
| forward τ F n (τ c) (F c x) = F (τ^[n] c) (forward τ F n c x) := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| change F (τ^[n] (τ c)) (forward τ F n (τ c) (F c x)) = |
| F (τ^[n+1] c) (F (τ^[n] c) (forward τ F n c x)) |
| rw [ih,Function.iterate_succ_apply] |
| lemma shiftIterate_vertex (n : ℕ) (c : C) (x : A) : |
| shiftIterate τ F n (vertex τ (fun _ => .id A) F c x) = |
| vertex τ (fun _ => .id A) F (τ^[n] c) (forward τ F n c x) := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| change shift τ F (shiftIterate τ F n (vertex τ (fun _ => .id A) F c x)) = _ |
| rw [ih,shift_vertex,Function.iterate_succ_apply'] |
| rfl |
| lemma shiftIterate_edge (n : ℕ) (c : C) (t : I) (x : A) : |
| shiftIterate τ F n (edge τ (fun _ => .id A) F c t x) = |
| edge τ (fun _ => .id A) F (τ^[n] c) t (forward τ F n c x) := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| change shift τ F (shiftIterate τ F n (edge τ (fun _ => .id A) F c t x)) = _ |
| rw [ih,shift_edge,Function.iterate_succ_apply'] |
| rfl |
| end UniversalFInfinity.GraphBundle |
|
|
| namespace UniversalFInfinity.Milnor |
| variable {G : Type*} [Group G] |
|
|
| lemma iterateHom_comm (f : G →* G) (n : ℕ) (g : G) : iterateHom f n (f g) = f (iterateHom f n g) := by |
| induction n with |
| | zero => rfl |
| | succ n ih => exact congrArg f ih |
| end UniversalFInfinity.Milnor |
|
|
| namespace UniversalFInfinity.TorusGeometry |
| open Set Topology Milnor AscendingTorus |
| open scoped unitInterval |
| universe u |
| variable {U : Type u} [Group U] (f : Monoid.End U) |
|
|
| def forwardOffset : ℕ → Coset f → U |
| | 0,_ => 1 |
| | n+1,c => cosetOffset f ((next f)^[n] c) * f (forwardOffset n c) |
| lemma forward_eq (n : ℕ) (c : Coset f) (x : Milnor.Space U) : |
| GraphBundle.forward (next f) (transition f) n c x = |
| forwardOffset f n c • Milnor.map (iterateHom f n) id Function.injective_id x := by |
| induction n with |
| | zero => |
| change x = 1 • Milnor.map (id : U → U) id Function.injective_id x |
| rw [one_smul,Milnor.map_id] |
| | succ n ih => |
| change transition f ((next f)^[n] c) (GraphBundle.forward (next f) (transition f) n c x) = _ |
| rw [ih,transition_apply] |
| refine (congrArg (cosetOffset f ((next f)^[n] c) • ·) |
| (Milnor.map_smul f (forwardOffset f n c) _)).trans ?_ |
| rw [←mul_smul] |
| change (cosetOffset f ((next f)^[n] c) * f (forwardOffset f n c)) • |
| Milnor.map f id Function.injective_id (Milnor.map (iterateHom f n) id Function.injective_id x) = _ |
| rw [Milnor.map_comp] |
| rfl |
|
|
| lemma forward_naturality (n : ℕ) (c : Coset f) (x : Milnor.Space U) : |
| transition f ((next f)^[n] c) |
| (forwardOffset f n c • Milnor.map (iterateHom f n) id Function.injective_id x) = |
| forwardOffset f n (next f c) • Milnor.map (iterateHom f n) id Function.injective_id (transition f c x) := by |
| rw [←forward_eq,←forward_eq] |
| exact (GraphBundle.forward_natural (next f) (transition f) n c x).symm |
|
|
| lemma stage_shift_vertex (S : Shapes U) (n : ℕ) (c : Coset f) (x : Milnor.Stage U (vertexShapes f S)) : |
| GraphBundle.shiftIterate (next f) (transition f) n |
| (stageFull f S (GraphBundle.vertex _ _ _ c x)) = |
| vertex f ((next f)^[n] c) |
| (forwardOffset f n c • Milnor.map (iterateHom f n) id Function.injective_id (Milnor.stageFull U _ x)) := by |
| rw [stageFull_vertex] |
| exact (GraphBundle.shiftIterate_vertex _ _ n c _).trans (congrArg (vertex f _) (forward_eq f n c _)) |
| lemma stage_shift_edge (S : Shapes U) (n : ℕ) (c : Coset f) (t : I) (x : Milnor.Stage U S) : |
| GraphBundle.shiftIterate (next f) (transition f) n |
| (stageFull f S (GraphBundle.edge _ _ _ c t x)) = |
| GraphBundle.edge _ _ _ ((next f)^[n] c) t |
| (forwardOffset f n c • Milnor.map (iterateHom f n) id Function.injective_id (Milnor.stageFull U _ x)) := by |
| rw [stageFull_edge,GraphBundle.shiftIterate_edge,forward_eq] |
| end UniversalFInfinity.TorusGeometry |
|
|
| namespace UniversalFInfinity.DirectedGraph |
| open Set Metric Topology Attachment |
| open scoped unitInterval |
| universe u v |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] (τ : C → C) |
|
|
| def attaching (c : C) : C(Sphere 1,C) := |
| ⟨fun x => if x.1 0 = -1 then c else τ c,continuous_of_discreteTopology⟩ |
| abbrev Graph := Space (attaching τ) |
| def vertex (c : C) : Graph τ := base _ c |
|
|
| lemma discrete_dimension (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set C) m) : m < 1 := by |
| cases m with |
| | zero => omega |
| | succ m => exact i.elim |
| instance graphCW [Nonempty C] : CWComplex (Set.univ : Set (Graph τ)) := layerCW _ discrete_dimension |
| instance : T2Space (Graph τ) := t2Space _ (realSeparated_of_tychonoff (Y := C)) |
| lemma graph_dimension [Nonempty C] (m : ℕ) (i : RelCWComplex.cell (Set.univ : Set (Graph τ)) m) : m < 2 := |
| layerCW_dimensions _ discrete_dimension m i |
|
|
| omit [DiscreteTopology C] in |
| lemma cell_minus (c : C) : cell (attaching τ) c (boundary 1 Cayley.minus) = vertex τ c := by |
| rw [cell_boundary]; simp only [attaching,Cayley.minus,ContinuousMap.coe_mk,ite_true]; rfl |
| omit [DiscreteTopology C] in |
| lemma cell_plus (c : C) : cell (attaching τ) c (boundary 1 Cayley.plus) = vertex τ (τ c) := by |
| rw [cell_boundary]; norm_num [attaching,Cayley.plus,vertex] |
|
|
| def edge (c : C) : Path (vertex τ c) (vertex τ (τ c)) where |
| toFun t := cell (attaching τ) c (Cayley.edgeParam t) |
| continuous_toFun := (cell _ c).continuous.comp Cayley.continuous_edgeParam |
| source' := by rw [Cayley.edgeParam_zero,cell_minus] |
| target' := by rw [Cayley.edgeParam_one,cell_plus] |
|
|
| variable {Y : Type v} [TopologicalSpace Y] (f : C(Graph τ,Y)) (y : Y) |
| variable (p : ∀ c,Path y (f (vertex τ c))) |
| variable (hp : ∀ c,((p c).trans ((edge τ c).map f.continuous)).Homotopic (p (τ c))) |
|
|
| def edgeSquare (c : C) : ((edge τ c).map f.continuous).toContinuousMap.Homotopy (.const _ y) := |
| (PathSquares.edgeSquare (p c) (p (τ c)) ((edge τ c).map f.continuous) (hp c)).choose |
| omit [DiscreteTopology C] in |
| lemma edgeSquare_source (c : C) (t : I) : edgeSquare τ f y p hp c (t,0) = PathSquares.pauseReverse (p c) t := |
| (PathSquares.edgeSquare (p c) (p (τ c)) ((edge τ c).map f.continuous) (hp c)).choose_spec.1 t |
| omit [DiscreteTopology C] in |
| lemma edgeSquare_target (c : C) (t : I) : edgeSquare τ f y p hp c (t,1) = PathSquares.pauseReverse (p (τ c)) t := |
| (PathSquares.edgeSquare (p c) (p (τ c)) ((edge τ c).map f.continuous) (hp c)).choose_spec.2 t |
|
|
| def edgePaths (c : C) : C(Disk 1,C(I,Y)) := |
| ContinuousMap.curry ⟨fun z => edgeSquare τ f y p hp c (z.2,Cayley.edgeTime z.1), |
| (edgeSquare τ f y p hp c).continuous.comp |
| (continuous_snd.prodMk (Cayley.continuous_edgeTime.comp continuous_fst))⟩ |
| def vertexPaths : C(C,C(I,Y)) := ⟨fun c => PathSquares.pauseReverse (p c),continuous_of_discreteTopology⟩ |
| lemma edgePaths_boundary (c : C) (t : Sphere 1) : |
| edgePaths τ f y p hp c (boundary 1 t) = vertexPaths τ f y p (attaching τ c t) := by |
| obtain rfl|rfl := Cayley.sphere_one_eq t |
| · apply ContinuousMap.ext; intro z |
| change edgeSquare τ f y p hp c (z,Cayley.edgeTime (boundary 1 Cayley.minus)) = _ |
| rw [Cayley.edgeTime_minus,edgeSquare_source] |
| simp only [vertexPaths,attaching,ContinuousMap.coe_mk,Cayley.minus,ite_true] |
| · apply ContinuousMap.ext; intro z |
| change edgeSquare τ f y p hp c (z,Cayley.edgeTime (boundary 1 Cayley.plus)) = _ |
| rw [Cayley.edgeTime_plus,edgeSquare_target] |
| norm_num [vertexPaths,attaching,Cayley.plus] |
|
|
| def graphPaths : C(Graph τ,C(I,Y)) := |
| lift _ (vertexPaths τ f y p) (edgePaths τ f y p hp) (edgePaths_boundary τ f y p hp) |
| lemma graphPaths_zero (z : Graph τ) : graphPaths τ f y p hp z 0 = f z := by |
| cases z with |
| | inl c => exact Path.source _ |
| | inr z => |
| change edgeSquare τ f y p hp z.1 (0,Cayley.edgeTime (interior 1 z.2)) = _ |
| rw [ContinuousMap.Homotopy.apply_zero] |
| change f (cell _ z.1 (Cayley.edgeParam (Cayley.edgeTime (interior 1 z.2)))) = f _ |
| rw [Cayley.edgeParam_time,cell_interior] |
| lemma graphPaths_one (z : Graph τ) : graphPaths τ f y p hp z 1 = y := by |
| cases z with |
| | inl c => exact Path.target _ |
| | inr z => |
| change edgeSquare τ f y p hp z.1 (1,Cayley.edgeTime (interior 1 z.2)) = y |
| exact ContinuousMap.Homotopy.apply_one _ _ |
|
|
| def graphNullhomotopy : f.Homotopy (.const _ y) where |
| toFun z := graphPaths τ f y p hp z.2 z.1 |
| continuous_toFun := (graphPaths τ f y p hp).uncurry.continuous.comp continuous_swap |
| map_zero_left := graphPaths_zero τ f y p hp |
| map_one_left := graphPaths_one τ f y p hp |
|
|
| end UniversalFInfinity.DirectedGraph |
|
|
| namespace UniversalFInfinity.DirectedTree |
| universe u v |
| variable {C : Type u} {G : Type v} [Group G] |
| variable (τ : C → C) (h : C → ℤ) (hτ : ∀ c, h (τ c) = h c + 1) |
|
|
| include hτ in |
| lemma height_iterate (c : C) (n : ℕ) : h (τ^[n] c) = h c + n := by |
| induction n with |
| | zero => simp |
| | succ n ih => rw [Function.iterate_succ_apply',hτ,ih]; push_cast; omega |
| |
| variable (w : C → G) |
| def rayProduct (c : C) : ℕ → G |
| | 0 => 1 |
| | n+1 => rayProduct c n * w (τ^[n] c) |
| |
| lemma rayProduct_add (c : C) (n k : ℕ) : |
| rayProduct τ w c (n+k) = rayProduct τ w c n * rayProduct τ w (τ^[n] c) k := by |
| induction k with |
| | zero => simp [rayProduct] |
| | succ k ih => |
| rw [Nat.add_succ,rayProduct,ih,rayProduct,mul_assoc] |
| congr 2 |
| rw [Function.iterate_add_apply] |
| exact congrArg w ((Function.Commute.iterate_iterate (Function.Commute.refl τ) n k).eq c) |
| |
| lemma rayProduct_first (c : C) (n : ℕ) : |
| rayProduct τ w c (n+1) = w c * rayProduct τ w (τ c) n := by |
| simpa only [Nat.add_comm 1 n,rayProduct,Function.iterate_zero,Function.id_def,one_mul, |
| Function.iterate_one] using rayProduct_add τ w c 1 n |
| |
| include h hτ in |
| |
| lemma route_independent (c d : C) (p q p' q' : ℕ) |
| (he : τ^[p] c = τ^[q] d) (he' : τ^[p'] c = τ^[q'] d) : |
| rayProduct τ w c p * (rayProduct τ w d q)⁻¹ = |
| rayProduct τ w c p' * (rayProduct τ w d q')⁻¹ := by |
| have hlen : (p:ℤ) + q' = (p':ℤ) + q := by |
| have ha := congrArg h he |
| have hb := congrArg h he' |
| rw [height_iterate τ h hτ,height_iterate τ h hτ] at ha hb |
| omega |
| have hlen' : p + q' = p' + q := by omega |
| have enlarge (a b : C) (i j k : ℕ) (hab : τ^[i] a = τ^[j] b) : |
| rayProduct τ w a i * (rayProduct τ w b j)⁻¹ = |
| rayProduct τ w a (i+k) * (rayProduct τ w b (j+k))⁻¹ := by |
| rw [rayProduct_add,rayProduct_add,hab,mul_inv_rev] |
| group |
| rw [enlarge c d p q q' he,enlarge c d p' q' q he',hlen',Nat.add_comm q' q] |
|
|
| variable (hc : ∀ c d, ∃ p q : ℕ, τ^[p] c = τ^[q] d) (root : C) |
| def potential (c : C) : G := |
| let p := (hc root c).choose |
| let q := (hc root c).choose_spec.choose |
| rayProduct τ w root p * (rayProduct τ w c q)⁻¹ |
|
|
| include h hτ in |
| lemma potential_route (c : C) (p q : ℕ) (he : τ^[p] root = τ^[q] c) : |
| potential τ w hc root c = rayProduct τ w root p * (rayProduct τ w c q)⁻¹ := by |
| exact route_independent τ h hτ w root c _ _ p q (hc root c).choose_spec.choose_spec he |
|
|
| include h hτ in |
|
|
| lemma potential_edge (c : C) : potential τ w hc root c * w c = potential τ w hc root (τ c) := by |
| obtain ⟨p,q,he⟩ := hc root (τ c) |
| have he' : τ^[p] root = τ^[q+1] c := by simpa only [Function.iterate_succ_apply] using he |
| rw [potential_route τ h hτ w hc root c p (q+1) he', |
| potential_route τ h hτ w hc root (τ c) p q he,rayProduct_first] |
| group |
|
|
| end UniversalFInfinity.DirectedTree |
|
|
| namespace UniversalFInfinity.DirectedGraph |
| open Set Topology Attachment |
| open scoped unitInterval |
| universe u |
| variable {C : Type u} [TopologicalSpace C] [DiscreteTopology C] (τ : C → C) |
| variable (h : C → ℤ) (hτ : ∀ c, h (τ c) = h c + 1) |
| variable (hc : ∀ c d, ∃ p q : ℕ, τ^[p] c = τ^[q] d) (root : C) |
|
|
| omit [DiscreteTopology C] in |
| lemma ray_joined (c : C) (n : ℕ) : Joined (vertex τ c) (vertex τ (τ^[n] c)) := by |
| induction n with |
| | zero => exact Joined.refl _ |
| | succ n ih => |
| rw [Function.iterate_succ_apply'] |
| exact ih.trans ⟨edge τ (τ^[n] c)⟩ |
| |
| include hc in |
| omit [DiscreteTopology C] in |
| lemma vertex_joined (c : C) : Joined (vertex τ root) (vertex τ c) := by |
| obtain ⟨p,q,he⟩ := hc root c |
| have hd : Joined (vertex τ c) (vertex τ (τ^[p] root)) := by |
| rw [he]; exact ray_joined τ c q |
| exact (ray_joined τ root p).trans hd.symm |
| |
| def initialPath (c : C) : Path (vertex τ root) (vertex τ c) := |
| (vertex_joined τ hc root c).somePath |
| |
| def initialClass (c : C) : Path.Homotopic.Quotient (vertex τ root) (vertex τ c) := |
| Path.Homotopic.Quotient.mk (initialPath τ hc root c) |
| |
| def edgeClass (c : C) : Path.Homotopic.Quotient (vertex τ c) (vertex τ (τ c)) := |
| Path.Homotopic.Quotient.mk (edge τ c) |
| |
| def edgeWeight (c : C) : (FundamentalGroup (Graph τ) (vertex τ root))ᵐᵒᵖ := |
| MulOpposite.op (((initialClass τ hc root c).trans (edgeClass τ c)).trans |
| (initialClass τ hc root (τ c)).symm) |
| |
| def treeClass (c : C) : Path.Homotopic.Quotient (vertex τ root) (vertex τ c) := |
| (MulOpposite.unop (DirectedTree.potential τ (edgeWeight τ hc root) hc root c)).trans |
| (initialClass τ hc root c) |
| |
| include h hτ in |
| omit [DiscreteTopology C] in |
| lemma treeClass_edge (c : C) : (treeClass τ hc root c).trans (edgeClass τ c) = |
| treeClass τ hc root (τ c) := by |
| have he := DirectedTree.potential_edge τ h hτ (edgeWeight τ hc root) hc root c |
| have he' := congrArg MulOpposite.unop he |
| simp only [MulOpposite.unop_mul,FundamentalGroup.mul_def,edgeWeight,MulOpposite.unop_op] at he' |
| have hh := congrArg (fun (k : FundamentalGroup (Graph τ) (vertex τ root)) => |
| k.trans (initialClass τ hc root (τ c))) he' |
| simpa only [treeClass,Path.Homotopic.Quotient.trans_assoc, |
| Path.Homotopic.Quotient.symm_trans,Path.Homotopic.Quotient.trans_refl] using hh |
|
|
| def treePath (c : C) : Path (vertex τ root) (vertex τ c) := |
| (Path.Homotopic.Quotient.mk_surjective (treeClass τ hc root c)).choose |
|
|
| include h hτ in |
| omit [DiscreteTopology C] in |
| lemma treePath_edge (c : C) : ((treePath τ hc root c).trans (edge τ c)).Homotopic |
| (treePath τ hc root (τ c)) := by |
| apply Path.Homotopic.Quotient.exact |
| change (Path.Homotopic.Quotient.mk (treePath τ hc root c)).trans (edgeClass τ c) = _ |
| unfold treePath |
| rw [(Path.Homotopic.Quotient.mk_surjective (treeClass τ hc root c)).choose_spec, |
| (Path.Homotopic.Quotient.mk_surjective (treeClass τ hc root (τ c))).choose_spec] |
| exact treeClass_edge τ h hτ hc root c |
|
|
| include hτ hc root in |
|
|
| lemma tree_contractible : ContractibleSpace (Graph τ) := by |
| apply (contractible_iff_id_nullhomotopic _).mpr |
| refine ⟨vertex τ root,⟨graphNullhomotopy τ (.id _) (vertex τ root) |
| (treePath τ hc root) ?_⟩⟩ |
| intro c |
| simpa only [ContinuousMap.coe_id,Path.map_id] using treePath_edge τ h hτ hc root c |
| end UniversalFInfinity.DirectedGraph |
|
|
| namespace UniversalFInfinity.GraphBundle |
|
|
| section |
| 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] |
|
|
| def treeProjection : C(Space τ L R,DirectedGraph.Graph τ) := |
| lift τ L R (fun c => .const _ (DirectedGraph.vertex τ c)) |
| (fun c => (DirectedGraph.edge τ c).toContinuousMap.comp (.fst)) |
| (fun c _ => (DirectedGraph.edge τ c).source) |
| (fun c _ => (DirectedGraph.edge τ c).target) |
| lemma treeProjection_vertex (c : C) (x : A) : |
| treeProjection τ L R (vertex τ L R c x) = DirectedGraph.vertex τ c := rfl |
| lemma treeProjection_edge (c : C) (t : I) (x : B) : |
| treeProjection τ L R (edge τ L R c t x) = DirectedGraph.edge τ c t := |
| lift_edge τ L R _ _ _ _ c (t,x) |
|
|
| omit [DiscreteTopology C] in |
| lemma pathMap_boundary (y : C → Y) (p : ∀ c,Path (y c) (y (τ c))) (c : C) |
| (x : Attachment.Sphere 1) : |
| p c (Cayley.edgeTime (Attachment.boundary 1 x)) = y (DirectedGraph.attaching τ c x) := by |
| obtain rfl|rfl := Cayley.sphere_one_eq x |
| · rw [Cayley.edgeTime_minus,Path.source] |
| simp only [DirectedGraph.attaching,Cayley.minus,ContinuousMap.coe_mk,ite_true] |
| · rw [Cayley.edgeTime_plus,Path.target] |
| norm_num [DirectedGraph.attaching,Cayley.plus] |
|
|
| def treePathMap (y : C → Y) (p : ∀ c,Path (y c) (y (τ c))) : C(DirectedGraph.Graph τ,Y) := |
| Attachment.lift _ ⟨y,continuous_of_discreteTopology⟩ |
| (fun c => (p c).toContinuousMap.comp ⟨Cayley.edgeTime,Cayley.continuous_edgeTime⟩) |
| (pathMap_boundary τ y p) |
| lemma treePathMap_vertex (y : C → Y) (p : ∀ c,Path (y c) (y (τ c))) (c : C) : |
| treePathMap τ y p (DirectedGraph.vertex τ c) = y c := rfl |
| lemma treePathMap_edge (y : C → Y) (p : ∀ c,Path (y c) (y (τ c))) (c : C) (t : I) : |
| treePathMap τ y p (DirectedGraph.edge τ c t) = p c t := by |
| change Attachment.lift _ _ _ _ (Attachment.cell _ c (Cayley.edgeParam t)) = _ |
| rw [Attachment.lift_cell] |
| change p c (Cayley.edgeTime (Cayley.edgeParam t)) = p c t |
| rw [Cayley.edgeTime_param] |
|
|
| lemma nullhomotopic_of_fiber_constant (h : C → ℤ) (hτ : ∀ c,h (τ c) = h c+1) |
| (hc : ∀ c d,∃ m n : ℕ,τ^[m] c = τ^[n] d) (root : C) |
| (f : C(Space τ L R,Y)) (y : C → Y) (p : ∀ c,Path (y c) (y (τ c))) |
| (hv : ∀ c x,f (vertex τ L R c x) = y c) |
| (he : ∀ c t x,f (edge τ L R c t x) = p c t) : f.Nullhomotopic := by |
| have := DirectedGraph.tree_contractible τ h hτ hc root |
| have hf : f = (treePathMap τ y p).comp (treeProjection τ L R) := by |
| apply hom_ext τ L R |
| · intro c x |
| simpa only [ContinuousMap.comp_apply,treeProjection_vertex,treePathMap_vertex] using hv c x |
| · intro c z |
| simpa only [ContinuousMap.comp_apply,treeProjection_edge,treePathMap_edge] using he c z.1 z.2 |
| rw [hf] |
| have hn := (id_nullhomotopic (DirectedGraph.Graph τ)).comp_right (treePathMap τ y p) |
| exact hn.comp_left (treeProjection τ L R) |
| end |
|
|
| open Set Topology |
| open scoped unitInterval |
| universe u v w z r |
| 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] {Z : Type r} [TopologicalSpace Z] |
| variable (f : C(Space τ L R,Y)) (y : C → Y) |
| variable (V : ∀ c,(f.comp (vertexMap τ L R c)).Homotopy (.const _ (y c))) |
| variable (a b : C → C(Z,Y)) (e : ∀ c z,Path (a c z) (b c z)) |
| variable (he : ∀ c,Continuous (fun p : Z × I => e c p.1 p.2)) |
| variable (H : C → C(I × B,Z)) |
| variable (Q : C → C(B,C(I,C(I,Y)))) |
| variable (hleft : ∀ c t x,a c (H c (t,x)) = V c (t,L c x)) |
| variable (qleft : ∀ c x t,Q c x t 0 = b c (H c (t,x))) |
| variable (qright : ∀ c x t,Q c x t 1 = V (τ c) (t,R c x)) |
|
|
| def connectorPath (c : C) (p : I × B) : |
| Path (b c (H c p)) (V (τ c) (p.1,R c p.2)) where |
| toFun s := Q c p.2 p.1 s |
| continuous_toFun := (Q c p.2 p.1).continuous |
| source' := qleft c p.2 p.1 |
| target' := qright c p.2 p.1 |
|
|
| omit [DiscreteTopology C] in |
| lemma connectorPath_continuous (c : C) : Continuous (fun p : (I × B) × I => |
| connectorPath τ L R f y V b H Q qleft qright c p.1 p.2) := by |
| change Continuous (fun p : (I × B) × I => Q c p.1.2 p.1.1 p.2) |
| exact (Q c).uncurry.uncurry.continuous.comp |
| ((continuous_fst.snd.prodMk continuous_fst.fst).prodMk continuous_snd) |
|
|
| def gluedPath (c : C) (p : I × B) : Path (a c (H c p)) (V (τ c) (p.1,R c p.2)) := |
| (e c (H c p)).trans (connectorPath τ L R f y V b H Q qleft qright c p) |
|
|
| include he in |
| omit [DiscreteTopology C] in |
| lemma gluedPath_continuous (c : C) : Continuous (fun p : (I × B) × I => |
| gluedPath τ L R f y V a b e H Q qleft qright c p.1 p.2) := by |
| exact Path.trans_continuous_family (fun z : I × B => e c (H c z)) |
| ((he c).comp (((H c).continuous.comp continuous_fst).prodMk continuous_snd)) |
| (connectorPath τ L R f y V b H Q qleft qright c) |
| (connectorPath_continuous τ L R f y V b H Q qleft qright c) |
|
|
| variable (e0 : ∀ c x s,e c (H c (0,x)) s = f (edge τ L R c s x)) |
| variable (q0 : ∀ c x s,Q c x 0 s = f (vertex τ L R (τ c) (R c x))) |
| variable (p : ∀ c,Path (y c) (y (τ c))) |
| variable (e1 : ∀ c x s,gluedPath τ L R f y V a b e H Q qleft qright c (1,x) s = p c s) |
|
|
| include e0 q0 in |
| lemma gluedPath_zero (c : C) (x : B) (s : I) : |
| gluedPath τ L R f y V a b e H Q qleft qright c (0,x) s = |
| f (pause τ L R (edge τ L R c s x)) := by |
| rw [pause_edge τ L R c (s,x)] |
| change ((e c (H c (0,x))).trans (connectorPath τ L R f y V b H Q qleft qright c (0,x))) s = |
| f ((edgePath τ L R c x).trans (Path.refl _) s) |
| rw [Path.trans_apply,Path.trans_apply] |
| split_ifs with hs |
| · exact e0 c x _ |
| · exact q0 c x _ |
|
|
| def collapsed : C(Space τ L R,Y) := |
| lift τ L R (fun c => .const _ (y c)) |
| (fun c => (p c).toContinuousMap.comp .fst) |
| (fun c _ => (p c).source) (fun c _ => (p c).target) |
|
|
| lemma collapsed_edge (c : C) (s : I) (x : B) : |
| collapsed τ L R y p (edge τ L R c s x) = p c s := |
| lift_edge τ L R _ _ _ _ c (s,x) |
|
|
| def gluedEdgeHomotopy (c : C) : |
| ((f.comp (pause τ L R)).comp (edgeMap τ L R c)).Homotopy |
| ((collapsed τ L R y p).comp (edgeMap τ L R c)) where |
| toFun z := gluedPath τ L R f y V a b e H Q qleft qright c (z.1,z.2.2) z.2.1 |
| continuous_toFun := (gluedPath_continuous τ L R f y V a b e he H Q qleft qright c).comp |
| ((continuous_fst.prodMk continuous_snd.snd).prodMk continuous_snd.fst) |
| map_zero_left z := gluedPath_zero τ L R f y V a b e H Q qleft qright e0 q0 c z.2 z.1 |
| map_one_left z := (e1 c z.2 z.1).trans (collapsed_edge τ L R y p c z.1 z.2).symm |
|
|
| def gluedVertexHomotopy (c : C) : |
| ((f.comp (pause τ L R)).comp (vertexMap τ L R c)).Homotopy |
| ((collapsed τ L R y p).comp (vertexMap τ L R c)) := V c |
|
|
| def coherentHomotopy : (f.comp (pause τ L R)).Homotopy (collapsed τ L R y p) := |
| homotopy τ L R _ _ (gluedVertexHomotopy τ L R f y V p) |
| (gluedEdgeHomotopy τ L R f y V a b e he H Q qleft qright e0 q0 p e1) |
| (fun c t x => ((gluedPath τ L R f y V a b e H Q qleft qright c (t,x)).source).trans (hleft c t x)) |
| (fun c t x => (gluedPath τ L R f y V a b e H Q qleft qright c (t,x)).target) |
|
|
| include he hleft e0 q0 e1 in |
|
|
| theorem nullhomotopic_of_coherent_contraction |
| (height : C → ℤ) (hτ : ∀ c,height (τ c) = height c+1) |
| (hc : ∀ c d,∃ m n : ℕ,τ^[m] c = τ^[n] d) (root : C) : f.Nullhomotopic := by |
| have hn := nullhomotopic_of_fiber_constant τ L R height hτ hc root |
| (collapsed τ L R y p) y p (fun _ _ => rfl) (collapsed_edge τ L R y p) |
| obtain ⟨z,⟨K⟩⟩ := hn |
| refine ⟨z,⟨?_⟩⟩ |
| have J := coherentHomotopy τ L R f y V a b e he H Q hleft qleft qright e0 q0 p e1 |
| have P := (ContinuousMap.Homotopy.refl f).comp (pauseHomotopy τ L R) |
| exact P.symm.trans (J.trans K) |
| end UniversalFInfinity.GraphBundle |
|
|
| end |
|
|
| end OAI |
|
|
