Documentation

Mathlib.GroupTheory.GroupAction.Quotient

Properties of group actions involving quotient groups #

This file proves properties of group actions which use the quotient group construction, notably

as well as their analogues for additive groups.

class MulAction.QuotientAction {G : Type u} (X : Type v) [Group G] [Monoid X] [MulAction X G] (H : Subgroup G) :

A typeclass for when a MulAction X G descends to the quotient G ⧸ H.

  • inv_mul_mem (b : X) {a a' : G} : a⁻¹ * a' H → (b a)⁻¹ * b a' H

    The action fulfils a normality condition on products that lie in H. This ensures that the action descends to an action on the quotient G ⧸ H.

Instances
    class AddAction.QuotientAction {G : Type u} (X : Type v) [AddGroup G] [AddMonoid X] [AddAction X G] (H : AddSubgroup G) :

    A typeclass for when an AddAction X G descends to the quotient G ⧸ H.

    • inv_mul_mem (x : X) {g g' : G} : -g + g' H-(x +ᵥ g) + (x +ᵥ g') H

      The action fulfils a normality condition on summands that lie in H. This ensures that the action descends to an action on the quotient G ⧸ H.

    Instances
      @[instance_reducible]
      instance MulAction.quotient {G : Type u} (X : Type v) [Group G] [Monoid X] [MulAction X G] (H : Subgroup G) [QuotientAction X H] :
      MulAction X (G H)
      @[instance_reducible]
      instance AddAction.quotient {G : Type u} (X : Type v) [AddGroup G] [AddMonoid X] [AddAction X G] (H : AddSubgroup G) [QuotientAction X H] :
      AddAction X (G H)
      @[simp]
      theorem MulAction.Quotient.smul_mk {G : Type u} {X : Type v} [Group G] [Monoid X] [MulAction X G] (H : Subgroup G) [QuotientAction X H] (b : X) (g : G) :
      b g = ↑(b g)
      @[simp]
      theorem AddAction.Quotient.vadd_mk {G : Type u} {X : Type v} [AddGroup G] [AddMonoid X] [AddAction X G] (H : AddSubgroup G) [QuotientAction X H] (b : X) (g : G) :
      b +ᵥ g = ↑(b +ᵥ g)
      @[simp]
      theorem MulAction.Quotient.smul_coe {G : Type u} {X : Type v} [Group G] [Monoid X] [MulAction X G] (H : Subgroup G) [QuotientAction X H] (b : X) (g : G) :
      b g = ↑(b g)
      @[simp]
      theorem AddAction.Quotient.vadd_coe {G : Type u} {X : Type v} [AddGroup G] [AddMonoid X] [AddAction X G] (H : AddSubgroup G) [QuotientAction X H] (b : X) (g : G) :
      b +ᵥ g = ↑(b +ᵥ g)
      @[simp]
      theorem MulAction.Quotient.mk_smul_out {G : Type u} {X : Type v} [Group G] [Monoid X] [MulAction X G] (H : Subgroup G) [QuotientAction X H] (b : X) (q : G H) :
      ↑(b Quotient.out q) = b q
      @[simp]
      theorem AddAction.Quotient.mk_vadd_out {G : Type u} {X : Type v} [AddGroup G] [AddMonoid X] [AddAction X G] (H : AddSubgroup G) [QuotientAction X H] (b : X) (q : G H) :
      ↑(b +ᵥ Quotient.out q) = b +ᵥ q
      theorem MulAction.Quotient.coe_smul_out {G : Type u} {X : Type v} [Group G] [Monoid X] [MulAction X G] (H : Subgroup G) [QuotientAction X H] (b : X) (q : G H) :
      ↑(b Quotient.out q) = b q
      theorem AddAction.Quotient.coe_vadd_out {G : Type u} {X : Type v} [AddGroup G] [AddMonoid X] [AddAction X G] (H : AddSubgroup G) [QuotientAction X H] (b : X) (q : G H) :
      ↑(b +ᵥ Quotient.out q) = b +ᵥ q
      theorem QuotientGroup.out_conj_pow_minimalPeriod_mem {G : Type u} [Group G] (H : Subgroup G) (g : G) (q : G H) :
      (Quotient.out q)⁻¹ * g ^ Function.minimalPeriod (fun (x : G H) => g x) q * Quotient.out q H
      def MulActionHom.toQuotient {G : Type u} [Group G] (H : Subgroup G) :

      The canonical map to the left cosets.

      Instances For
        @[simp]
        theorem MulActionHom.toQuotient_apply {G : Type u} [Group G] (H : Subgroup G) (g : G) :
        (toQuotient H) g = g
        @[simp]
        theorem MulAction.coe_quotient_smul {G : Type u} {X : Type v} [Group G] {H : Subgroup G} [H.Normal] [SMul G X] [MulAction (G H) X] [IsScalarTower G (G H) X] (g : G) (x : X) :
        g x = g x
        @[simp]
        theorem AddAction.coe_quotient_vadd {G : Type u} {X : Type v} [AddGroup G] {H : AddSubgroup G} [H.Normal] [VAdd G X] [AddAction (G H) X] [VAddAssocClass G (G H) X] (g : G) (x : X) :
        g +ᵥ x = g +ᵥ x
        def MulAction.ofQuotientStabilizer (G : Type u) {X : Type v} [Group G] [MulAction G X] (x : X) (g : G stabilizer G x) :
        X

        The canonical map from the quotient of the stabilizer to the set.

        Instances For
          def AddAction.ofQuotientStabilizer (G : Type u) {X : Type v} [AddGroup G] [AddAction G X] (x : X) (g : G stabilizer G x) :
          X

          The canonical map from the quotient of the stabilizer to the set.

          Instances For
            @[simp]
            theorem MulAction.ofQuotientStabilizer_mk (G : Type u) {X : Type v} [Group G] [MulAction G X] (x : X) (g : G) :
            @[simp]
            theorem AddAction.ofQuotientStabilizer_mk (G : Type u) {X : Type v} [AddGroup G] [AddAction G X] (x : X) (g : G) :
            theorem MulAction.ofQuotientStabilizer_mem_orbit (G : Type u) {X : Type v} [Group G] [MulAction G X] (x : X) (g : G stabilizer G x) :
            theorem MulAction.ofQuotientStabilizer_smul (G : Type u) {X : Type v} [Group G] [MulAction G X] (x : X) (g : G) (g' : G stabilizer G x) :
            theorem AddAction.ofQuotientStabilizer_vadd (G : Type u) {X : Type v} [AddGroup G] [AddAction G X] (x : X) (g : G) (g' : G stabilizer G x) :
            noncomputable def MulAction.orbitEquivQuotientStabilizer (G : Type u) {X : Type v} [Group G] [MulAction G X] (b : X) :
            (orbit G b) G stabilizer G b

            Orbit-stabilizer theorem.

            Instances For
              noncomputable def AddAction.orbitEquivQuotientStabilizer (G : Type u) {X : Type v} [AddGroup G] [AddAction G X] (b : X) :
              (orbit G b) G stabilizer G b

              Orbit-stabilizer theorem.

              Instances For
                noncomputable def MulAction.orbitProdStabilizerEquivGroup (G : Type u) {X : Type v} [Group G] [MulAction G X] (b : X) :
                (orbit G b) × (stabilizer G b) G

                Orbit-stabilizer theorem.

                Instances For
                  noncomputable def AddAction.orbitProdStabilizerEquivAddGroup (G : Type u) {X : Type v} [AddGroup G] [AddAction G X] (b : X) :
                  (orbit G b) × (stabilizer G b) G

                  Orbit-stabilizer theorem.

                  Instances For

                    Orbit-stabilizer theorem.

                    Orbit-stabilizer theorem.

                    @[simp]
                    theorem MulAction.orbitEquivQuotientStabilizer_symm_apply (G : Type u) {X : Type v} [Group G] [MulAction G X] (b : X) (g : G) :
                    @[simp]
                    theorem AddAction.orbitEquivQuotientStabilizer_symm_apply (G : Type u) {X : Type v} [AddGroup G] [AddAction G X] (b : X) (g : G) :
                    @[simp]
                    theorem MulAction.stabilizer_quotient {G : Type u_1} [Group G] (H : Subgroup G) :
                    stabilizer G 1 = H
                    @[simp]
                    theorem AddAction.stabilizer_quotient {G : Type u_1} [AddGroup G] (H : AddSubgroup G) :
                    stabilizer G 0 = H
                    noncomputable def MulAction.selfEquivSigmaOrbitsQuotientStabilizer' (G : Type u) (X : Type v) [Group G] [MulAction G X] {φ : Quotient (orbitRel G X)X} ( : Function.LeftInverse Quotient.mk'' φ) :
                    X (ω : Quotient (orbitRel G X)) × G stabilizer G (φ ω)

                    Class formula : let G be a group acting on X and let φ be a function mapping each orbit of X under this action (that is, each element of the quotient of G by the relation orbitRel G X) to an element in this orbit. We provide a (noncomputable) bijection between X and the disjoint union of G/Stab(φ(ω)) over all orbits ω : Ω. In most cases you'll want φ to be Quotient.out, so we provide MulAction.selfEquivSigmaOrbitsQuotientStabilizer' as a special case.

                    Instances For
                      noncomputable def AddAction.selfEquivSigmaOrbitsQuotientStabilizer' (G : Type u) (X : Type v) [AddGroup G] [AddAction G X] {φ : Quotient (orbitRel G X)X} ( : Function.LeftInverse Quotient.mk'' φ) :
                      X (ω : Quotient (orbitRel G X)) × G stabilizer G (φ ω)

                      Class formula : let G be an additive group acting on X and let φ be a function mapping each orbit of X under this action (that is, each element of the quotient of X by the relation orbitRel G X) to an element in this orbit. This definition is a (noncomputable) bijection between X and the disjoint union of G/Stab(φ(ω)) over all orbits ω : Ω. In most cases you'll want φ to be Quotient.out, so we provide AddAction.selfEquivSigmaOrbitsQuotientStabilizer' as a special case.

                      Instances For
                        noncomputable def MulAction.selfEquivSigmaOrbitsQuotientStabilizer (G : Type u) (X : Type v) [Group G] [MulAction G X] :
                        X (ω : Quotient (orbitRel G X)) × G stabilizer G ω.out

                        Class formula. This is a special case of MulAction.self_equiv_sigma_orbits_quotient_stabilizer' with φ = Quotient.out.

                        Instances For
                          noncomputable def AddAction.selfEquivSigmaOrbitsQuotientStabilizer (G : Type u) (X : Type v) [AddGroup G] [AddAction G X] :
                          X (ω : Quotient (orbitRel G X)) × G stabilizer G ω.out

                          Class formula. This is a special case of AddAction.self_equiv_sigma_orbits_quotient_stabilizer' with φ = Quotient.out.

                          Instances For
                            noncomputable def MulAction.sigmaFixedByEquivOrbitsProdGroup (G : Type u) (X : Type v) [Group G] [MulAction G X] :
                            (g : G) × (fixedBy X g) Quotient (orbitRel G X) × G

                            Burnside's lemma : a (noncomputable) bijection between the disjoint union of all {x ∈ X | g • x = x} for g ∈ G and the product G × Ω, where G is a group acting on X and Ω = X/G denotes the quotient of X by the relation orbitRel G X.

                            Instances For
                              noncomputable def AddAction.sigmaFixedByEquivOrbitsProdAddGroup (G : Type u) (X : Type v) [AddGroup G] [AddAction G X] :
                              (g : G) × (fixedBy X g) Quotient (orbitRel G X) × G

                              Burnside's lemma : a (noncomputable) bijection between the disjoint union of all {x ∈ X | g • x = x} for g ∈ G and the product G × Ω, where G is an additive group acting on X and Ω = X/G denotes the quotient of X by the relation orbitRel G X.

                              Instances For

                                Burnside's lemma : given a finite group G acting on a type X, the sum the orders of the stabilisers coincides with the number of orbits multiplied by the order of G.

                                Wikidata Q1330377

                                Burnside's lemma : given a finite additive group G acting on a type X, the sum the orders of the stabilisers coincides with the number of orbits multiplied by the order of G.

                                Wikidata Q1330377

                                A bijection between the quotient of the action of a subgroup H on an orbit, and a corresponding quotient expressed in terms of Setoid.comap Subtype.val.

                                Instances For

                                  A bijection between the quotient of the action of an additive subgroup H on an orbit, and a corresponding quotient expressed in terms of Setoid.comap Subtype.val.

                                  Instances For
                                    noncomputable def MulAction.equivSubgroupOrbits {G : Type u} (X : Type v) [Group G] [MulAction G X] (H : Subgroup G) :

                                    A bijection between the orbits under the action of a subgroup H on X, and the orbits under the action of H on each orbit under the action of G.

                                    Instances For
                                      noncomputable def AddAction.equivAddSubgroupOrbits {G : Type u} (X : Type v) [AddGroup G] [AddAction G X] (H : AddSubgroup G) :

                                      A bijection between the orbits under the action of an additive subgroup H on X, and the orbits under the action of H on each orbit under the action of G.

                                      Instances For
                                        noncomputable def MulAction.equivSubgroupOrbitsQuotientGroup {G : Type u} {X : Type v} [Group G] [MulAction G X] (x : X) [IsPretransitive G X] [IsCancelSMul G X] (H : Subgroup G) :

                                        Given a group acting freely and transitively, an equivalence between the orbits under the action of a subgroup and the quotient of the group by the subgroup.

                                        Instances For
                                          noncomputable def AddAction.equivAddSubgroupOrbitsQuotientAddGroup {G : Type u} {X : Type v} [AddGroup G] [AddAction G X] (x : X) [IsPretransitive G X] [IsCancelVAdd G X] (H : AddSubgroup G) :

                                          Given an additive group acting freely and transitively, an equivalence between the orbits under the action of an additive subgroup and the quotient of the group by the subgroup.

                                          Instances For
                                            noncomputable def MulAction.selfEquivOrbitsQuotientProd' {G : Type u} {X : Type v} [Group G] [MulAction G X] {φ : Quotient (orbitRel G X)X} ( : Function.LeftInverse Quotient.mk'' φ) (h : ∀ (b : X), stabilizer G b = ) :

                                            If G acts on X with trivial stabilizers, X is equivalent to the product of the quotient of X by G and G. See MulAction.selfEquivOrbitsQuotientProd with φ = Quotient.out.

                                            Instances For
                                              noncomputable def AddAction.selfEquivOrbitsQuotientProd' {G : Type u} {X : Type v} [AddGroup G] [AddAction G X] {φ : Quotient (orbitRel G X)X} ( : Function.LeftInverse Quotient.mk'' φ) (h : ∀ (b : X), stabilizer G b = ) :

                                              If G acts freely on X, X is equivalent to the product of the quotient of X by G and G. See AddAction.selfEquivOrbitsQuotientProd with φ = Quotient.out.

                                              Instances For
                                                noncomputable def MulAction.selfEquivOrbitsQuotientProd {G : Type u} {X : Type v} [Group G] [MulAction G X] (h : ∀ (b : X), stabilizer G b = ) :

                                                If G acts freely on X, X is equivalent to the product of the quotient of X by G and G.

                                                Instances For
                                                  noncomputable def AddAction.selfEquivOrbitsQuotientProd {G : Type u} {X : Type v} [AddGroup G] [AddAction G X] (h : ∀ (b : X), stabilizer G b = ) :

                                                  If G acts freely on X, X is equivalent to the product of the quotient of X by G and G.

                                                  Instances For
                                                    noncomputable def Subgroup.quotientCentralizerEmbedding {G : Type u_1} [Group G] (g : G) :

                                                    Cosets of the centralizer of an element embed into the set of commutators.

                                                    Instances For
                                                      noncomputable def Subgroup.quotientCenterEmbedding {G : Type u_1} [Group G] {S : Set G} (hS : closure S = ) :
                                                      G center G S(commutatorSet G)

                                                      If G is generated by S, then the quotient by the center embeds into S-indexed sequences of commutators.

                                                      Instances For
                                                        theorem Subgroup.quotientCenterEmbedding_apply {G : Type u_1} [Group G] {S : Set G} (hS : closure S = ) (g : G) (s : S) :
                                                        (quotientCenterEmbedding hS) (↑g) s = g, s,