Documentation

TauCeti.AlgebraicTopology.Homotopy.Relative.BasepointChange

Base-point change for relative homotopy groups #

Let X = (X, A, a) be a based pair and let γ be a path in A from a to a point b, so that ⟨X.pair, b⟩ is the based pair (X, A, b). This file constructs the base-point-change map TauCeti.RelHomotopyGroup.transport γ : π_{n+1}(X, A, a) → π_{n+1}(X, A, b), proves that it is a bijection with inverse the transport along the reversed path, and, in degrees at least two, a group isomorphism TauCeti.RelHomotopyGroup.mulEquivOfPath γ. It is compatible with the maps of the long exact sequence of the pair: with the boundary map to π_n(A) and the absolute base-point change in A, and with the map from π_{n+1}(X) and the absolute base-point change in X. It is natural in morphisms of based pairs.

A homotopy along γ (TauCeti.RelGenLoop.HomotopyAlong) from a relative cube p at a to a relative cube q at b is a homotopy whose stage at time t sends the face {0} × I^N into A, and the face {1} × I^N and the sides I × ∂I^N to γ t. The transport is characterised by these homotopies: whenever there is one from p to q, the transport of the class of p is the class of q (TauCeti.RelGenLoop.HomotopyAlong.transport_mk). All the laws are read off from this characterisation, by composing, reversing or restricting homotopies along paths.

Construction #

Main declarations #

References #

Homotopies along a path in the subspace #

structure TauCeti.RelGenLoop.HomotopyAlong {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} (γ : Path X.basepoint b) (p : ↑(RelGenLoop N X)) (q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })) extends (↑p).Homotopy ↑q :
Type (max u v)

A homotopy from a relative cube p of the based pair X = (X, A, a) to a relative cube q of (X, A, b), along a path γ in A from a to b: at time t it sends the face {0} × I^N into A, and the face {1} × I^N and the sides I × ∂I^N to γ t.

Instances For
    @[instance_reducible]
    instance TauCeti.RelGenLoop.HomotopyAlong.instFunLike {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} :

    The constant homotopy is a homotopy along the constant path.

    Instances For
      def TauCeti.RelGenLoop.HomotopyAlong.symm {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} (h : HomotopyAlong γ p q) :

      Reversing a homotopy along γ in time gives a homotopy along the reversed path.

      Instances For
        noncomputable def TauCeti.RelGenLoop.HomotopyAlong.trans {N : Type v} {X : BasedTopPair} {b c : ↑TopPair.snd} {γ : Path X.basepoint b} {δ : Path b c} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} {r : ↑(RelGenLoop N { pair := X.pair, basepoint := c })} (h₁ : HomotopyAlong γ p q) (h₂ : HomotopyAlong δ q r) :
        HomotopyAlong (γ.trans δ) p r

        Concatenating two homotopies along paths, in the time direction, gives a homotopy along the concatenated path.

        Instances For
          def TauCeti.RelGenLoop.HomotopyAlong.map {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} {Y : BasedTopPair} (f : X ⟶ Y) {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} (h : HomotopyAlong γ p q) :
          HomotopyAlong ((γ.map ⋯).cast ⋯ ⋯) (RelGenLoop.map f p) (RelGenLoop.map { toTopPairHom := f.toTopPairHom, map_basepoint := ⋯ } q)

          A morphism of based pairs f : X ⟶ Y carries a homotopy along γ to a homotopy along the image of γ, which starts at the basepoint of Y.

          Instances For
            noncomputable def TauCeti.RelGenLoop.HomotopyAlong.boundary {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} (h : HomotopyAlong γ p q) :

            Restricting a homotopy along γ to the face {0} × I^N gives a homotopy along γ of generalized loops in the subspace.

            Instances For

              An absolute homotopy along the image of γ in X, of cubes I^(Option N), is a homotopy along γ of the corresponding relative cubes.

              Instances For

                The constant cube at γ t is a homotopy along γ between the constant relative cubes.

                Instances For
                  theorem TauCeti.RelGenLoop.HomotopyAlong.homotopicWith {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} (h : HomotopyAlong γ p q) :

                  A homotopy along a path in the subspace is a homotopy through maps of pairs (I × I^N, ∂(I × I^N)) → (X, A).

                  Existence: the doubled collar #

                  noncomputable def TauCeti.RelGenLoop.transport {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (p : ↑(RelGenLoop N X)) :
                  ↑(RelGenLoop N { pair := X.pair, basepoint := b })

                  A relative cube transported along a path in the subspace: the end of the collar homotopy of its doubling, restricted to the upper half of the cube.

                  Instances For
                    noncomputable def TauCeti.RelGenLoop.collarHomotopyAlong {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (p : ↑(RelGenLoop N X)) :

                    The collar homotopy of the doubling is a homotopy along γ from p to its transport.

                    Instances For
                      theorem TauCeti.RelGenLoop.homotopic_transport_of_path_homotopic {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] {γ γ' : Path X.basepoint b} (h : γ.Homotopic γ') (p : ↑(RelGenLoop N X)) :

                      Transport along homotopic paths gives homotopic relative cubes. Collaring the doubled cube along the paths of a homotopy between the two paths deforms one transported cube into the other through relative cubes.

                      Canonicity, through the path space #

                      noncomputable def TauCeti.RelHomotopyGroup.transport {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (x : RelHomotopyGroup N X) :
                      RelHomotopyGroup N { pair := X.pair, basepoint := b }

                      Base-point change for relative homotopy sets. The map π_{n+1}(X, A, a) → π_{n+1}(X, A, b) induced by a path γ in A from a to b. A homotopy along γ from a relative cube p to q carries the class of p to the class of q (TauCeti.RelGenLoop.HomotopyAlong.transport_mk).

                      Instances For
                        theorem TauCeti.RelGenLoop.HomotopyAlong.transport_mk {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} (h : HomotopyAlong γ p q) :

                        The characterisation of relative base-point change. If there is a homotopy along γ from p to q, then transport along γ sends the class of p to the class of q.

                        theorem TauCeti.RelGenLoop.HomotopyAlong.homotopic_transport {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] {γ : Path X.basepoint b} {p : ↑(RelGenLoop N X)} {q : ↑(RelGenLoop N { pair := X.pair, basepoint := b })} (h : HomotopyAlong γ p q) :

                        Canonicity of the transported relative cube. A homotopy along γ starting at p ends at a relative cube homotopic to transport γ p.

                        @[simp]
                        theorem TauCeti.RelHomotopyGroup.transport_mk {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (p : ↑(RelGenLoop N X)) :

                        Transport of the class of a relative cube is the class of its transport.

                        @[simp]

                        Transport along a constant path is the identity.

                        @[simp]
                        theorem TauCeti.RelHomotopyGroup.transport_trans {N : Type v} {X : BasedTopPair} {b c : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (δ : Path b c) :

                        Transport along a concatenation of paths is the composite of the transports.

                        theorem TauCeti.RelHomotopyGroup.transport_congr {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] {γ γ' : Path X.basepoint b} (h : γ.Homotopic γ') :

                        Homotopic paths induce the same transport.

                        @[simp]

                        Transport along the reversed path undoes transport.

                        @[simp]
                        theorem TauCeti.RelHomotopyGroup.transport_transport_symm {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (x : RelHomotopyGroup N { pair := X.pair, basepoint := b }) :

                        Transport along a path undoes transport along the reversed path.

                        @[simp]

                        Transport preserves the distinguished point.

                        noncomputable def TauCeti.RelHomotopyGroup.equivOfPath {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) :
                        RelHomotopyGroup N X ≃ RelHomotopyGroup N { pair := X.pair, basepoint := b }

                        Base-point change for relative homotopy sets. A path from a to b in the subspace induces a bijection π_{n+1}(X, A, a) ≃ π_{n+1}(X, A, b).

                        Instances For
                          @[simp]
                          theorem TauCeti.RelHomotopyGroup.equivOfPath_symm_apply {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] (γ : Path X.basepoint b) (x : RelHomotopyGroup N { pair := X.pair, basepoint := b }) :
                          @[simp]

                          The equivalence for a constant path is the identity.

                          @[simp]

                          The equivalence for a concatenated path is the composite equivalence.

                          Reversing the path gives the inverse equivalence.

                          theorem TauCeti.RelHomotopyGroup.equivOfPath_congr {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] {γ γ' : Path X.basepoint b} (h : γ.Homotopic γ') :

                          Homotopic paths induce the same equivalence.

                          The relative homotopy set at a is trivial if and only if it is trivial at any point b of the subspace joined to a by a path in the subspace.

                          @[simp]

                          Transport commutes with the boundary map: restricted to the face in A, it is base-point change of homotopy groups of A.

                          @[simp]

                          Transport commutes with the map π_{n+1}(X, a) → π_{n+1}(X, A, a): on absolute classes it is base-point change of homotopy groups of X along the image of γ.

                          @[simp]
                          theorem TauCeti.RelHomotopyGroup.map_transport {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] {Y : BasedTopPair} (f : X ⟶ Y) (γ : Path X.basepoint b) (x : RelHomotopyGroup N X) :
                          map { toTopPairHom := f.toTopPairHom, map_basepoint := ⋯ } (transport γ x) = transport ((γ.map ⋯).cast ⋯ ⋯) (map f x)

                          Transport is natural in morphisms of based pairs f : X ⟶ Y, along the image of the path, which starts at the basepoint of Y.

                          @[simp]
                          theorem TauCeti.RelHomotopyGroup.transport_mul {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] [Nonempty N] [DecidableEq N] (γ : Path X.basepoint b) (x y : RelHomotopyGroup N X) :
                          transport γ (x * y) = transport γ x * transport γ y

                          In degrees at least two, transport is a homomorphism.

                          noncomputable def TauCeti.RelHomotopyGroup.mulEquivOfPath {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] [Nonempty N] [DecidableEq N] (γ : Path X.basepoint b) :
                          RelHomotopyGroup N X ≃* RelHomotopyGroup N { pair := X.pair, basepoint := b }

                          Base-point change for relative homotopy groups. A path from a to b in the subspace induces a group isomorphism π_{n+1}(X, A, a) ≃* π_{n+1}(X, A, b) for n ≥ 1.

                          Instances For
                            @[simp]
                            theorem TauCeti.RelHomotopyGroup.mulEquivOfPath_symm_apply {N : Type v} {X : BasedTopPair} {b : ↑TopPair.snd} [Fintype N] [Nonempty N] [DecidableEq N] (γ : Path X.basepoint b) (x : RelHomotopyGroup N { pair := X.pair, basepoint := b }) :
                            @[simp]

                            The group isomorphism for a constant path is the identity.

                            @[simp]

                            The group isomorphism for a concatenated path is the composite isomorphism.

                            Reversing the path gives the inverse group isomorphism.

                            Homotopic paths induce the same group isomorphism.