Documentation

LeanPool.Kurosh.KuroshCover

The universal cover of the quotient graph of groups.

The source group is the explicit free product of the vertex stabilizers and the quotient free part. A cover vertex is a quotient-graph vertex together with a right coset of its source vertex group. This is the standard Bass--Serre construction, with the edge group trivial.

Adapted for Lean Pool from Arthur742Ramos/KuroshSubgroupTheorem, commit 911707126c8b9bb0c764bf853008fe1053c0aad9: imports, API compatibility, and proof organization were revised.

@[instance_reducible]

Classical equality used locally in this part of the Kurosh construction.

Equations
Instances For
    @[reducible, inline]
    abbrev GraphCoveringTheory.Kurosh.CoverSource {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :
    Type (max (max u v) (u + 1) (v + 1))

    The tree Kurosh product acting on the auxiliary covering graph.

    Equations
    Instances For
      @[reducible, inline]
      abbrev GraphCoveringTheory.Kurosh.CoverVertexCoset {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (a : RawBassSerreOrbitVertex G H) :
      Type (max (max (u + 1) (v + 1)) u_1)

      Cosets of the image of a vertex stabilizer in the tree Kurosh product.

      Equations
      Instances For
        @[reducible, inline]
        abbrev GraphCoveringTheory.Kurosh.CoverVertex {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :
        Type (max (max u v) (max u_1 (v + 1)) (u + 1))

        Vertices of the auxiliary cover, given by a quotient vertex and a stabilizer coset.

        Equations
        Instances For
          @[reducible, inline]
          abbrev GraphCoveringTheory.Kurosh.CoverEdge {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :
          Type (max u v)

          An edge of the quotient graph, bundled with its endpoints.

          Equations
          Instances For
            noncomputable def GraphCoveringTheory.Kurosh.coverEdgeLetter {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (e : CoverEdge G H) :

            The based loop of a quotient edge included in the free factor of the covering group.

            Equations
            Instances For
              noncomputable def GraphCoveringTheory.Kurosh.coverEdgeSource {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (d : CoverSource G H × CoverEdge G H) :

              The source coset of an edge labeled by a covering-group element.

              Equations
              Instances For
                noncomputable def GraphCoveringTheory.Kurosh.coverEdgeTarget {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (d : CoverSource G H × CoverEdge G H) :

                The target coset after multiplication by the inverse edge letter.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  @[reducible]
                  def GraphCoveringTheory.Kurosh.coverQuiver {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :

                  The auxiliary quiver of stabilizer cosets and labeled quotient edges.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    @[instance_reducible]
                    instance GraphCoveringTheory.Kurosh.coverQuiverInst {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :
                    Equations
                    @[instance_reducible]
                    noncomputable instance GraphCoveringTheory.Kurosh.coverSourceMulAction {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :
                    Equations
                    • One or more equations did not get rendered due to their size.
                    @[simp]
                    noncomputable def GraphCoveringTheory.Kurosh.coverVertexMap {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :

                    Evaluate a covering coset on the chosen representative in the Bass-Serre graph.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      noncomputable def GraphCoveringTheory.Kurosh.coverEdgeMap {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {x y : CoverVertex G H} (d : x ⟶ y) :

                      Project an auxiliary covering edge to the Bass-Serre graph.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        noncomputable def GraphCoveringTheory.Kurosh.coverVertexMk {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (a : RawBassSerreOrbitVertex G H) (p : CoverSource G H) :

                        Construct an auxiliary covering vertex from a quotient vertex and a group element.

                        Equations
                        Instances For
                          def GraphCoveringTheory.Kurosh.coverBaseEdge {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (e : a ⟶ b) :

                          Bundle a quotient edge with its source and target.

                          Equations
                          Instances For
                            noncomputable def GraphCoveringTheory.Kurosh.coverPositiveLiftEdge {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (e : a ⟶ b) (p : CoverSource G H) :

                            Lift a positively oriented quotient edge from a specified group representative.

                            Equations
                            Instances For
                              noncomputable def GraphCoveringTheory.Kurosh.coverNegativeLiftEdge {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (e : a ⟶ b) (p : CoverSource G H) :

                              Lift a negatively oriented quotient edge from a specified group representative.

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For

                                Label quotient edges in the opposite covering group to respect path composition.

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For

                                  Interpret a raw symmetrified quotient path in its free groupoid.

                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For
                                    noncomputable def GraphCoveringTheory.Kurosh.coverPathValueOpp {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (p : Quiver.Path a b) :

                                    Evaluate a quotient path in the opposite covering group.

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      noncomputable def GraphCoveringTheory.Kurosh.coverPathValue {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (p : Quiver.Path a b) :

                                      The covering-group value obtained by evaluating a quotient path.

                                      Equations
                                      Instances For
                                        theorem GraphCoveringTheory.Kurosh.coverPathValue_pos {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (p : Quiver.Path (rawBassSerreOrbitRoot G H) a) (e : a ⟶ b) :
                                        theorem GraphCoveringTheory.Kurosh.coverPathValue_neg {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a b : RawBassSerreOrbitVertex G H} (p : Quiver.Path (rawBassSerreOrbitRoot G H) b) (e : a ⟶ b) :
                                        noncomputable def GraphCoveringTheory.Kurosh.coverPathFreeLoop {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) {a : RawBassSerreOrbitVertex G H} (p : Quiver.Path (rawBassSerreOrbitRoot G H) a) :

                                        The free-part loop determined by a path based at the quotient root.

                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          noncomputable def GraphCoveringTheory.Kurosh.coverPathLift {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (p : CoverSource G H) {a : RawBassSerreOrbitVertex G H} :

                                          Lift a quotient path starting from the coset of a given covering-group element.

                                          Equations
                                          Instances For
                                            theorem GraphCoveringTheory.Kurosh.coverPathLift_value {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) (p : CoverSource G H) {a : RawBassSerreOrbitVertex G H} (q : Quiver.Path (rawBassSerreOrbitRoot G H) a) :
                                            (coverPathLift G H p q).fst = p * coverPathValue G H q
                                            noncomputable def GraphCoveringTheory.Kurosh.coverPrefunctor {ι : Type v} (G : ι → Type u) [(i : ι) → Group (G i)] (H : Subgroup (FreeProduct G)) :

                                            The projection from the auxiliary covering quiver to the Bass-Serre quiver.

                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For