Named Finitely Presented Groups - Groups

Skip to content
Back to top
View this page
Edit this page

# Named Finitely Presented Groups

Construct groups of small order and “named” groups as quotients of free groups. These groups are available through tab completion by typing `groups.presentation.<tab>` or by importing the required methods. Tab completion is made available through Sage’s group catalog. Some examples are engineered from entries in [TW1980].

Groups available as finite presentations:

- Alternating group, \(A_n\) of order \(n!/2\) – `groups.presentation.Alternating`

- the \(n\)-fruit Cactus group, a standard notation for which is \(J_n\) – `groups.presentation.Cactus`

- Cyclic group, \(C_n\) of order \(n\) – `groups.presentation.Cyclic`

- Dicyclic group, nonabelian groups of order \(4n\) with a unique element of order 2 – `groups.presentation.DiCyclic`

- Dihedral group, \(D_n\) of order \(2n\) – `groups.presentation.Dihedral`

- Finitely generated abelian group, \(\ZZ_{n_1} \times \ZZ_{n_2} \times \cdots \times \ZZ_{n_k}\) – `groups.presentation.FGAbelian`

- Finitely generated Heisenberg group – `groups.presentation.Heisenberg`

- Klein four group, \(C_2 \times C_2\) – `groups.presentation.KleinFour`

- Quaternion group of order 8 – `groups.presentation.Quaternion`

- Symmetric group, \(S_n\) of order \(n!\) – `groups.presentation.Symmetric`

AUTHORS:

- Davis Shurbert (2013-06-21): initial version

EXAMPLES:

Sage

    sage: groups.presentation.Cyclic(4)
    Finitely presented group < a | a^4 >

Python

    >>> from sage.all import *
    >>> groups.presentation.Cyclic(Integer(4))
    Finitely presented group < a | a^4 >

You can also import the desired functions:

Sage

    sage: from sage.groups.finitely_presented_named import CyclicPresentation
    sage: CyclicPresentation(4)
    Finitely presented group < a | a^4 >

[Python]

    >>> from sage.all import *
    >>> from sage.groups.finitely_presented_named import CyclicPresentation
    >>> CyclicPresentation(Integer(4))
    Finitely presented group < a | a^4 >

sage.groups.finitely_presented_named.AlternatingPresentation(n)

  Build the Alternating group of order \(n!/2\) as a finitely presented group.

  INPUT:

  - `n` – the size of the underlying set of arbitrary symbols being acted on by the Alternating group of order \(n!/2\)

  OUTPUT:

  Alternating group as a finite presentation, implementation uses GAP to find an isomorphism from a permutation representation to a finitely presented group representation. Due to this fact, the exact output presentation may not be the same for every method call on a constant `n`.

  EXAMPLES:

  Sage

      sage: A6 = groups.presentation.Alternating(6)
      sage: A6.as_permutation_group().is_isomorphic(AlternatingGroup(6)), A6.order()
      (True, 360)

  Python

      >>> from sage.all import *
      >>> A6 = groups.presentation.Alternating(Integer(6))
      >>> A6.as_permutation_group().is_isomorphic(AlternatingGroup(Integer(6))), A6.order()
      (True, 360)

sage.groups.finitely_presented_named.BinaryDihedralPresentation(n)

  Build a binary dihedral group of order \(4n\) as a finitely presented group.

  The binary dihedral group \(BD_n\) has the following presentation (note that there is a typo in [Sun2010]):

  \[BD_n = \langle x, y, z | x^2 = y^2 = z^n = x y z \rangle.\]

  INPUT:

  - `n` – the value \(n\)

  OUTPUT: the binary dihedral group of order \(4n\) as finite presentation

  EXAMPLES:

  Sage

      sage: groups.presentation.BinaryDihedral(9)
      Finitely presented group < x, y, z | x^-2*y^2, x^-2*z^9, x^-1*y*z >

  Python

      >>> from sage.all import *
      >>> groups.presentation.BinaryDihedral(Integer(9))
      Finitely presented group < x, y, z | x^-2*y^2, x^-2*z^9, x^-1*y*z >

sage.groups.finitely_presented_named.CactusPresentation(n)

  Build the \(n\)-fruit cactus group as a finitely presented group.

  OUTPUT: Cactus group \(J_n\) as a finitely presented group

  EXAMPLES:

  Sage

      sage: J3 = groups.presentation.Cactus(3); J3                                    # needs sage.graphs
      Finitely presented group < s12, s13, s23 |
       s12^2, s13^2, s23^2, s13*s12*s13^-1*s23^-1, s13*s23*s13^-1*s12^-1 >

  Python

      >>> from sage.all import *
      >>> J3 = groups.presentation.Cactus(Integer(3)); J3                                    # needs sage.graphs
      Finitely presented group < s12, s13, s23 |
       s12^2, s13^2, s23^2, s13*s12*s13^-1*s23^-1, s13*s23*s13^-1*s12^-1 >

sage.groups.finitely_presented_named.CyclicPresentation(n)

  Build cyclic group of order \(n\) as a finitely presented group.

  INPUT:

  - `n` – the order of the cyclic presentation to be returned

  OUTPUT: the cyclic group of order \(n\) as finite presentation

  EXAMPLES:

  Sage

      sage: groups.presentation.Cyclic(10)
      Finitely presented group < a | a^10 >
      sage: n = 8; C = groups.presentation.Cyclic(n)
      sage: C.as_permutation_group().is_isomorphic(CyclicPermutationGroup(n))
      True

  Python

      >>> from sage.all import *
      >>> groups.presentation.Cyclic(Integer(10))
      Finitely presented group < a | a^10 >
      >>> n = Integer(8); C = groups.presentation.Cyclic(n)
      >>> C.as_permutation_group().is_isomorphic(CyclicPermutationGroup(n))
      True

sage.groups.finitely_presented_named.DiCyclicPresentation(n)

  Build the dicyclic group of order \(4n\), for \(n \geq 2\), as a finitely presented group.

  INPUT:

  - `n` – positive integer, 2 or greater, determining the order of the group (\(4n\))

  OUTPUT: the dicyclic group of order \(4n\) is defined by the presentation

  \[\langle a, x \mid a^{2n}=1, x^{2}=a^{n}, x^{-1}ax=a^{-1} \rangle\]

  Note

  This group is also available as a permutation group via `groups.permutation.DiCyclic`.

  EXAMPLES:

  Sage

      sage: D = groups.presentation.DiCyclic(9); D
      Finitely presented group < a, b | a^18, b^2*a^-9, b^-1*a*b*a >
      sage: D.as_permutation_group().is_isomorphic(groups.permutation.DiCyclic(9))
      True

  Python

      >>> from sage.all import *
      >>> D = groups.presentation.DiCyclic(Integer(9)); D
      Finitely presented group < a, b | a^18, b^2*a^-9, b^-1*a*b*a >
      >>> D.as_permutation_group().is_isomorphic(groups.permutation.DiCyclic(Integer(9)))
      True

sage.groups.finitely_presented_named.DihedralPresentation(n)

  Build the Dihedral group of order \(2n\) as a finitely presented group.

  INPUT:

  - `n` – the size of the set that \(D_n\) is acting on

  OUTPUT: Dihedral group of order \(2n\)

  EXAMPLES:

  Sage

      sage: D = groups.presentation.Dihedral(7); D
      Finitely presented group < a, b | a^7, b^2, (a*b)^2 >
      sage: D.as_permutation_group().is_isomorphic(DihedralGroup(7))
      True

  Python

      >>> from sage.all import *
      >>> D = groups.presentation.Dihedral(Integer(7)); D
      Finitely presented group < a, b | a^7, b^2, (a*b)^2 >
      >>> D.as_permutation_group().is_isomorphic(DihedralGroup(Integer(7)))
      True

sage.groups.finitely_presented_named.FinitelyGeneratedAbelianPresentation(int_list)

  Return canonical presentation of finitely generated abelian group.

  INPUT:

  - `int_list` – list of integers defining the group to be returned, the defining list is reduced to the invariants of the input list before generating the corresponding group

  OUTPUT:

  Finitely generated abelian group, \(\ZZ_{n_1} \times \ZZ_{n_2} \times \cdots \times \ZZ_{n_k}\) as a finite presentation, where \(n_i\) forms the invariants of the input list.

  EXAMPLES:

  Sage

      sage: groups.presentation.FGAbelian([2,2])
      Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >
      sage: groups.presentation.FGAbelian([2,3])
      Finitely presented group < a | a^6 >
      sage: groups.presentation.FGAbelian([2,4])
      Finitely presented group < a, b | a^2, b^4, a^-1*b^-1*a*b >

  Python

      >>> from sage.all import *
      >>> groups.presentation.FGAbelian([Integer(2),Integer(2)])
      Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >
      >>> groups.presentation.FGAbelian([Integer(2),Integer(3)])
      Finitely presented group < a | a^6 >
      >>> groups.presentation.FGAbelian([Integer(2),Integer(4)])
      Finitely presented group < a, b | a^2, b^4, a^-1*b^-1*a*b >

  You can create free abelian groups:

  Sage

      sage: groups.presentation.FGAbelian([0])
      Finitely presented group < a |  >
      sage: groups.presentation.FGAbelian([0,0])
      Finitely presented group < a, b | a^-1*b^-1*a*b >
      sage: groups.presentation.FGAbelian([0,0,0])
      Finitely presented group < a, b, c | a^-1*b^-1*a*b, a^-1*c^-1*a*c, b^-1*c^-1*b*c >

  [Python]

      >>> from sage.all import *
      >>> groups.presentation.FGAbelian([Integer(0)])
      Finitely presented group < a |  >
      >>> groups.presentation.FGAbelian([Integer(0),Integer(0)])
      Finitely presented group < a, b | a^-1*b^-1*a*b >
      >>> groups.presentation.FGAbelian([Integer(0),Integer(0),Integer(0)])
      Finitely presented group < a, b, c | a^-1*b^-1*a*b, a^-1*c^-1*a*c, b^-1*c^-1*b*c >

  And various infinite abelian groups:

  Sage

      sage: groups.presentation.FGAbelian([0,2])
      Finitely presented group < a, b | a^2, a^-1*b^-1*a*b >
      sage: groups.presentation.FGAbelian([0,2,2])
      Finitely presented group < a, b, c | a^2, b^2, a^-1*b^-1*a*b, a^-1*c^-1*a*c, b^-1*c^-1*b*c >

  Python

      >>> from sage.all import *
      >>> groups.presentation.FGAbelian([Integer(0),Integer(2)])
      Finitely presented group < a, b | a^2, a^-1*b^-1*a*b >
      >>> groups.presentation.FGAbelian([Integer(0),Integer(2),Integer(2)])
      Finitely presented group < a, b, c | a^2, b^2, a^-1*b^-1*a*b, a^-1*c^-1*a*c, b^-1*c^-1*b*c >

  Outputs are reduced to minimal generators and relations:

  Sage

      sage: groups.presentation.FGAbelian([3,5,2,7,3])
      Finitely presented group < a, b | a^3, b^210, a^-1*b^-1*a*b >
      sage: groups.presentation.FGAbelian([3,210])
      Finitely presented group < a, b | a^3, b^210, a^-1*b^-1*a*b >

  [Python]

      >>> from sage.all import *
      >>> groups.presentation.FGAbelian([Integer(3),Integer(5),Integer(2),Integer(7),Integer(3)])
      Finitely presented group < a, b | a^3, b^210, a^-1*b^-1*a*b >
      >>> groups.presentation.FGAbelian([Integer(3),Integer(210)])
      Finitely presented group < a, b | a^3, b^210, a^-1*b^-1*a*b >

  The trivial group is an acceptable output:

  Sage

      sage: groups.presentation.FGAbelian([])
      Finitely presented group <  |  >
      sage: groups.presentation.FGAbelian([1])
      Finitely presented group <  |  >
      sage: groups.presentation.FGAbelian([1,1,1,1,1,1,1,1,1,1])
      Finitely presented group <  |  >

  Python

      >>> from sage.all import *
      >>> groups.presentation.FGAbelian([])
      Finitely presented group <  |  >
      >>> groups.presentation.FGAbelian([Integer(1)])
      Finitely presented group <  |  >
      >>> groups.presentation.FGAbelian([Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1),Integer(1)])
      Finitely presented group <  |  >

  Input list must consist of positive integers:

  Sage

      sage: groups.presentation.FGAbelian([2,6,3,9,-4])
      Traceback (most recent call last):
      ...
      ValueError: input list must contain nonnegative entries
      sage: groups.presentation.FGAbelian([2,'a',4])
      Traceback (most recent call last):
      ...
      TypeError: unable to convert 'a' to an integer

  [Python]

      >>> from sage.all import *
      >>> groups.presentation.FGAbelian([Integer(2),Integer(6),Integer(3),Integer(9),-Integer(4)])
      Traceback (most recent call last):
      ...
      ValueError: input list must contain nonnegative entries
      >>> groups.presentation.FGAbelian([Integer(2),'a',Integer(4)])
      Traceback (most recent call last):
      ...
      TypeError: unable to convert 'a' to an integer

sage.groups.finitely_presented_named.FinitelyGeneratedHeisenbergPresentation(n=1, p=0)

  Return a finite presentation of the Heisenberg group.

  The Heisenberg group is the group of \((n+2) \times (n+2)\) matrices over a ring \(R\) with diagonal elements equal to 1, first row and last column possibly nonzero, and all the other entries equal to zero.

  INPUT:

  - `n` – the degree of the Heisenberg group

  - `p` – (optional) a prime number, where we construct the Heisenberg group over the finite field \(\ZZ/p\ZZ\)

  OUTPUT: finitely generated Heisenberg group over the finite field of order `p` or over the integers

  See also

  `HeisenbergGroup`

  EXAMPLES:

  Sage

      sage: H = groups.presentation.Heisenberg(); H
      Finitely presented group < x1, y1, z |
       x1*y1*x1^-1*y1^-1*z^-1, z*x1*z^-1*x1^-1, z*y1*z^-1*y1^-1 >
      sage: H.order()
      +Infinity
      sage: r1, r2, r3 = H.relations()
      sage: A = matrix([[1, 1, 0], [0, 1, 0], [0, 0, 1]])
      sage: B = matrix([[1, 0, 0], [0, 1, 1], [0, 0, 1]])
      sage: C = matrix([[1, 0, 1], [0, 1, 0], [0, 0, 1]])
      sage: r1(A, B, C)
      [1 0 0]
      [0 1 0]
      [0 0 1]
      sage: r2(A, B, C)
      [1 0 0]
      [0 1 0]
      [0 0 1]
      sage: r3(A, B, C)
      [1 0 0]
      [0 1 0]
      [0 0 1]
      sage: p = 3
      sage: Hp = groups.presentation.Heisenberg(p=3)
      sage: Hp.order() == p**3
      True
      sage: Hnp = groups.presentation.Heisenberg(n=2, p=3)
      sage: len(Hnp.relations())
      13

  Python

      >>> from sage.all import *
      >>> H = groups.presentation.Heisenberg(); H
      Finitely presented group < x1, y1, z |
       x1*y1*x1^-1*y1^-1*z^-1, z*x1*z^-1*x1^-1, z*y1*z^-1*y1^-1 >
      >>> H.order()
      +Infinity
      >>> r1, r2, r3 = H.relations()
      >>> A = matrix([[Integer(1), Integer(1), Integer(0)], [Integer(0), Integer(1), Integer(0)], [Integer(0), Integer(0), Integer(1)]])
      >>> B = matrix([[Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), Integer(1)], [Integer(0), Integer(0), Integer(1)]])
      >>> C = matrix([[Integer(1), Integer(0), Integer(1)], [Integer(0), Integer(1), Integer(0)], [Integer(0), Integer(0), Integer(1)]])
      >>> r1(A, B, C)
      [1 0 0]
      [0 1 0]
      [0 0 1]
      >>> r2(A, B, C)
      [1 0 0]
      [0 1 0]
      [0 0 1]
      >>> r3(A, B, C)
      [1 0 0]
      [0 1 0]
      [0 0 1]
      >>> p = Integer(3)
      >>> Hp = groups.presentation.Heisenberg(p=Integer(3))
      >>> Hp.order() == p**Integer(3)
      True
      >>> Hnp = groups.presentation.Heisenberg(n=Integer(2), p=Integer(3))
      >>> len(Hnp.relations())
      13

  REFERENCES:

  - Wikipedia article Heisenberg_group

sage.groups.finitely_presented_named.KleinFourPresentation()

  Build the Klein group of order \(4\) as a finitely presented group.

  OUTPUT: Klein four group (\(C_2 \times C_2\)) as a finitely presented group

  EXAMPLES:

  Sage

      sage: K = groups.presentation.KleinFour(); K
      Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >

  Python

      >>> from sage.all import *
      >>> K = groups.presentation.KleinFour(); K
      Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >

sage.groups.finitely_presented_named.QuaternionPresentation()

  Build the Quaternion group of order 8 as a finitely presented group.

  OUTPUT: Quaternion group as a finite presentation

  EXAMPLES:

  Sage

      sage: Q = groups.presentation.Quaternion(); Q
      Finitely presented group < a, b | a^4, b^2*a^-2, a*b*a*b^-1 >
      sage: Q.as_permutation_group().is_isomorphic(QuaternionGroup())
      True

  Python

      >>> from sage.all import *
      >>> Q = groups.presentation.Quaternion(); Q
      Finitely presented group < a, b | a^4, b^2*a^-2, a*b*a*b^-1 >
      >>> Q.as_permutation_group().is_isomorphic(QuaternionGroup())
      True

sage.groups.finitely_presented_named.SymmetricPresentation(n)

  Build the Symmetric group of order \(n!\) as a finitely presented group.

  INPUT:

  - `n` – the size of the underlying set of arbitrary symbols being acted on by the Symmetric group of order \(n!\)

  OUTPUT:

  Symmetric group as a finite presentation, implementation uses GAP to find an isomorphism from a permutation representation to a finitely presented group representation. Due to this fact, the exact output presentation may not be the same for every method call on a constant `n`.

  EXAMPLES:

  Sage

      sage: S4 = groups.presentation.Symmetric(4)
      sage: S4.as_permutation_group().is_isomorphic(SymmetricGroup(4))
      True

  Python

      >>> from sage.all import *
      >>> S4 = groups.presentation.Symmetric(Integer(4))
      >>> S4.as_permutation_group().is_isomorphic(SymmetricGroup(Integer(4)))
      True