def BinaryDihedralPresentation(n):
r"""
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 [Sun]_):
.. MATH::
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: groups.presentation.BinaryDihedral(9)
Finitely presented group < x, y, z | x^-2*y^2, x^-2*z^9, x^-1*y*z >
TESTS::
sage: for n in range(3, 9):
....: P = groups.presentation.BinaryDihedral(n)
....: M = groups.matrix.BinaryDihedral(n)
....: assert P.is_isomorphic(M)
"""
F = FreeGroup('x,y,z')
x,y,z = F.gens()
rls = (x**-2 * y**2, x**-2 * z**n, x**-2 * x*y*z)
return FinitelyPresentedGroup(F, rls)
def __init__(self, names):
"""
Python constructor.
INPUT:
- ``names`` -- a tuple of strings. The names of the
generators.
TESTS::
sage: B1 = BraidGroup(5) # indirect doctest
sage: B1
Braid group on 5 strands
Check that :trac:`14081` is fixed::
sage: BraidGroup(2)
Braid group on 2 strands
sage: BraidGroup(('a',))
Braid group on 2 strands
"""
n = len(names)
if n < 1: #n is the number of generators, not the number of strands (see ticket 14081)
raise ValueError(
"the number of strands must be an integer bigger than one")
free_group = FreeGroup(names)
rels = []
for i in range(1, n):
if i < n - 1:
rels.append(free_group([i, i + 1, i, -i - 1, -i, -i - 1]))
for j in range(i + 2, n):
rels.append(free_group([i, j, -i, -j]))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
self._nstrands_ = n + 1
def CyclicPresentation(n):
r"""
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: 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
TESTS::
sage: groups.presentation.Cyclic(0)
Traceback (most recent call last):
...
ValueError: finitely presented group order must be positive
"""
n = Integer(n)
if n < 1:
raise ValueError('finitely presented group order must be positive')
F = FreeGroup( 'a' )
rls = F([1])**n,
return FinitelyPresentedGroup( F, rls )
def QuaternionPresentation():
r"""
Build the Quaternion group of order 8 as a finitely presented group.
OUTPUT:
Quaternion group as a finite presentation.
EXAMPLES::
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
TESTS::
sage: Q = groups.presentation.Quaternion()
sage: Q.order(), Q.is_abelian()
(8, False)
sage: Q.is_isomorphic(groups.presentation.DiCyclic(2))
True
"""
F = FreeGroup(['a','b'])
rls = F([1])**4, F([2,2,-1,-1]), F([1,2,1,-2])
return FinitelyPresentedGroup(F, rls)
def __init__(self, coxeter_matrix, names):
"""
Initialize ``self``.
TESTS::
sage: A = ArtinGroup(['D',4])
sage: TestSuite(A).run()
sage: A = ArtinGroup(['B',3], ['x','y','z'])
sage: TestSuite(A).run()
"""
self._coxeter_group = CoxeterGroup(coxeter_matrix)
free_group = FreeGroup(names)
rels = []
# Generate the relations based on the Coxeter graph
I = coxeter_matrix.index_set()
for ii, i in enumerate(I):
for j in I[ii + 1:]:
m = coxeter_matrix[i, j]
if m == Infinity: # no relation
continue
elt = [i, j] * m
for ind in range(m, 2 * m):
elt[ind] = -elt[ind]
rels.append(free_group(elt))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
def __init__(self, G, names):
"""
Initialize ``self``.
TESTS::
sage: G = RightAngledArtinGroup(graphs.CycleGraph(5))
sage: TestSuite(G).run()
"""
self._graph = G
F = FreeGroup(names=names)
CG = Graph(G).complement() # Make sure it's mutable
CG.relabel() # Standardize the labels
cm = [[-1] * CG.num_verts() for _ in range(CG.num_verts())]
for i in range(CG.num_verts()):
cm[i][i] = 1
for u, v in CG.edge_iterator(labels=False):
cm[u][v] = 2
cm[v][u] = 2
self._coxeter_group = CoxeterGroup(
CoxeterMatrix(cm, index_set=G.vertices()))
rels = tuple(
F([i + 1, j + 1, -i - 1, -j - 1])
for i, j in CG.edge_iterator(labels=False)) # +/- 1 for indexing
FinitelyPresentedGroup.__init__(self, F, rels)
def __init__(self, names):
"""
Python constructor.
INPUT:
- ``names`` -- a tuple of strings. The names of the
generators.
TESTS::
sage: B1 = BraidGroup(5) # indirect doctest
sage: B1
Braid group on 5 strands
sage: TestSuite(B1).run()
Check that :trac:`14081` is fixed::
sage: BraidGroup(2)
Braid group on 2 strands
sage: BraidGroup(('a',))
Braid group on 2 strands
Check that :trac:`15505` is fixed::
sage: B=BraidGroup(4)
sage: B.relations()
(s0*s1*s0*s1^-1*s0^-1*s1^-1, s0*s2*s0^-1*s2^-1, s1*s2*s1*s2^-1*s1^-1*s2^-1)
sage: B=BraidGroup('a,b,c,d,e,f')
sage: B.relations()
(a*b*a*b^-1*a^-1*b^-1,
a*c*a^-1*c^-1,
a*d*a^-1*d^-1,
a*e*a^-1*e^-1,
a*f*a^-1*f^-1,
b*c*b*c^-1*b^-1*c^-1,
b*d*b^-1*d^-1,
b*e*b^-1*e^-1,
b*f*b^-1*f^-1,
c*d*c*d^-1*c^-1*d^-1,
c*e*c^-1*e^-1,
c*f*c^-1*f^-1,
d*e*d*e^-1*d^-1*e^-1,
d*f*d^-1*f^-1,
e*f*e*f^-1*e^-1*f^-1)
"""
n = len(names)
if n < 1: #n is the number of generators, not the number of strands (see ticket 14081)
raise ValueError(
"the number of strands must be an integer bigger than one")
free_group = FreeGroup(names)
rels = []
for i in range(1, n):
rels.append(free_group([i, i + 1, i, -i - 1, -i, -i - 1]))
for j in range(i + 2, n + 1):
rels.append(free_group([i, j, -i, -j]))
FinitelyPresentedGroup.__init__(self, free_group, tuple(rels))
self._nstrands_ = n + 1
def BinaryDihedralPresentation(n):
r"""
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 [Sun]_):
.. MATH::
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: groups.presentation.BinaryDihedral(9)
Finitely presented group < x, y, z | x^-2*y^2, x^-2*z^9, x^-1*y*z >
TESTS::
sage: for n in range(3, 9):
....: P = groups.presentation.BinaryDihedral(n)
....: M = groups.matrix.BinaryDihedral(n)
....: assert P.is_isomorphic(M)
#I Forcing finiteness test
#I Forcing finiteness test
#I Forcing finiteness test
#I Forcing finiteness test
#I Forcing finiteness test
#I Forcing finiteness test
"""
F = FreeGroup('x,y,z')
x, y, z = F.gens()
rls = (x**-2 * y**2, x**-2 * z**n, x**-2 * x * y * z)
return FinitelyPresentedGroup(F, rls)
def DiCyclicPresentation(n):
r"""
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
.. MATH::
\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
:class:`groups.permutation.DiCyclic <sage.groups.perm_gps.permgroup_named.DiCyclicGroup>`.
EXAMPLES::
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
TESTS::
sage: Q = groups.presentation.DiCyclic(2)
sage: Q.as_permutation_group().is_isomorphic(QuaternionGroup())
True
sage: for i in [5, 8, 12, 32]:
....: A = groups.presentation.DiCyclic(i).as_permutation_group()
....: B = groups.permutation.DiCyclic(i)
....: assert A.is_isomorphic(B)
sage: groups.presentation.DiCyclic(1)
Traceback (most recent call last):
...
ValueError: input integer must be greater than 1
"""
n = Integer(n)
if n < 2:
raise ValueError('input integer must be greater than 1')
F = FreeGroup(['a', 'b'])
rls = F([1])**(2 * n), F([2, 2]) * F([-1])**n, F([-2, 1, 2, 1])
return FinitelyPresentedGroup(F, rls)
def knot_group(self):
"""
Computes the knot group using the Wirtinger presentation.
Returns a finitely presented group::
sage: K = Link('3_1')
sage: G = K.knot_group()
sage: type(G)
<class 'sage.groups.finitely_presented.FinitelyPresentedGroup_with_category'>
"""
n = len(self.crossings)
F = FreeGroup(n)
g = list(F.gens())
rels = []
pieces = self._pieces()
for z in self.crossings:
for m, p in enumerate(pieces):
for t, q in enumerate(p):
if q[0] == z:
if t == 0:
j = m
elif t == len(p) - 1:
i = m
else:
k = m
i += 1
j += 1
k += 1
if z.sign > 0:
r = F([-k, i, k, -j])
if z.sign < 0:
r = F([k, i, -k, -j])
rels.append(r)
G = F / rels
return G
def free(index_set=None, names=None, **kwds):
r"""
Return the free group.
INPUT:
- ``index_set`` -- (optional) an index set for the generators; if
an integer, then this represents `\{0, 1, \ldots, n-1\}`
- ``names`` -- a string or list/tuple/iterable of strings
(default: ``'x'``); the generator names or name prefix
When the index set is an integer or only variable names are given,
this returns :class:`~sage.groups.free_group.FreeGroup_class`, which
currently has more features due to the interface with GAP than
:class:`~sage.groups.indexed_free_group.IndexedFreeGroup`.
EXAMPLES::
sage: Groups.free(index_set=ZZ)
Free group indexed by Integer Ring
sage: Groups().free(ZZ)
Free group indexed by Integer Ring
sage: Groups().free(5)
Free Group on generators {x0, x1, x2, x3, x4}
sage: F.<x,y,z> = Groups().free(); F
Free Group on generators {x, y, z}
"""
from sage.rings.all import ZZ
if index_set in ZZ or (index_set is None and names is not None):
from sage.groups.free_group import FreeGroup
if names is None:
return FreeGroup(index_set, **kwds)
return FreeGroup(index_set, names, **kwds)
from sage.groups.indexed_free_group import IndexedFreeGroup
return IndexedFreeGroup(index_set, **kwds)
def SymmetricPresentation(n):
r"""
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: S4 = groups.presentation.Symmetric(4)
sage: S4.as_permutation_group().is_isomorphic(SymmetricGroup(4))
True
TESTS::
sage: S = [groups.presentation.Symmetric(i) for i in range(1,4)]; S[0].order()
1
sage: S[1].order(), S[2].as_permutation_group().is_isomorphic(DihedralGroup(3))
(2, True)
sage: S5 = groups.presentation.Symmetric(5)
sage: perm_S5 = S5.as_permutation_group(); perm_S5.is_isomorphic(SymmetricGroup(5))
True
sage: groups.presentation.Symmetric(8).order()
40320
"""
from sage.groups.perm_gps.permgroup_named import SymmetricGroup
from sage.groups.free_group import _lexi_gen
n = Integer(n)
perm_rep = SymmetricGroup(n)
GAP_fp_rep = libgap.Image(
libgap.IsomorphismFpGroupByGenerators(perm_rep, perm_rep.gens()))
image_gens = GAP_fp_rep.FreeGeneratorsOfFpGroup()
name_itr = _lexi_gen() # Python generator object for variable names
F = FreeGroup([next(name_itr) for x in perm_rep.gens()])
ret_rls = tuple([
F(rel_word.TietzeWordAbstractWord(image_gens).sage())
for rel_word in GAP_fp_rep.RelatorsOfFpGroup()
])
return FinitelyPresentedGroup(F, ret_rls)
def AlternatingPresentation(n):
r"""
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: A6 = groups.presentation.Alternating(6)
sage: A6.as_permutation_group().is_isomorphic(AlternatingGroup(6)), A6.order()
(True, 360)
TESTS::
sage: #even permutation test..
sage: A1 = groups.presentation.Alternating(1); A2 = groups.presentation.Alternating(2)
sage: A1.is_isomorphic(A2), A1.order()
(True, 1)
sage: A3 = groups.presentation.Alternating(3); A3.order(), A3.as_permutation_group().is_cyclic()
(3, True)
sage: A8 = groups.presentation.Alternating(8); A8.order()
20160
"""
from sage.groups.perm_gps.permgroup_named import AlternatingGroup
from sage.groups.free_group import _lexi_gen
n = Integer(n)
perm_rep = AlternatingGroup(n)
GAP_fp_rep = libgap.Image(
libgap.IsomorphismFpGroupByGenerators(perm_rep, perm_rep.gens()))
image_gens = GAP_fp_rep.FreeGeneratorsOfFpGroup()
name_itr = _lexi_gen() # Python generator object for variable names
F = FreeGroup([next(name_itr) for x in perm_rep.gens()])
ret_rls = tuple([
F(rel_word.TietzeWordAbstractWord(image_gens).sage())
for rel_word in GAP_fp_rep.RelatorsOfFpGroup()
])
return FinitelyPresentedGroup(F, ret_rls)
def KleinFourPresentation():
r"""
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: K = groups.presentation.KleinFour(); K
Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >
"""
F = FreeGroup(['a', 'b'])
rls = F([1])**2, F([2])**2, F([-1]) * F([-2]) * F([1]) * F([2])
return FinitelyPresentedGroup(F, rls)
def __init__(self, G):
"""
Initialize ``self``.
INPUT:
- ``G`` -- a graph
TESTS::
sage: G = RightAngledArtinGroup(graphs.CycleGraph(5))
sage: TestSuite(G).run()
"""
self._graph = G
F = FreeGroup(names=['v{}'.format(v) for v in self._graph.vertices()])
CG = Graph(G).complement() # Make sure it's mutable
CG.relabel() # Standardize the labels
rels = tuple(F([i+1, j+1, -i-1, -j-1]) for i,j in CG.edges(False)) #+/- 1 for indexing
FinitelyPresentedGroup.__init__(self, F, rels)
def DihedralPresentation(n):
r"""
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: 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
TESTS::
sage: n = 9
sage: D = groups.presentation.Dihedral(n)
sage: D.ngens() == 2
True
sage: groups.presentation.Dihedral(0)
Traceback (most recent call last):
...
ValueError: finitely presented group order must be positive
"""
n = Integer(n)
if n < 1:
raise ValueError('finitely presented group order must be positive')
F = FreeGroup(['a', 'b'])
rls = F([1])**n, F([2])**2, (F([1]) * F([2]))**2
return FinitelyPresentedGroup(F, rls)
def FinitelyGeneratedHeisenbergPresentation(n=1, p=0):
r"""
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.
.. SEEALSO::
:class:`~sage.groups.matrix_gps.heisenberg.HeisenbergGroup`
EXAMPLES::
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
REFERENCES:
- :wikipedia:`Heisenberg_group`
"""
n = Integer(n)
if n < 1:
raise ValueError('n must be a positive integer')
# generators' names are x1, .., xn, y1, .., yn, z
vx = ['x' + str(i) for i in range(1, n + 1)]
vy = ['y' + str(i) for i in range(1, n + 1)]
str_generators = ', '.join(vx + vy + ['z'])
F = FreeGroup(str_generators)
x = F.gens()[0:n] # list of generators x1, x2, ..., xn
y = F.gens()[n:2 * n] # list of generators x1, x2, ..., xn
z = F.gen(n * 2)
def commutator(a, b):
return a * b * a**-1 * b**-1
# First set of relations: [xi, yi] = z
r1 = [commutator(x[i], y[i]) * z**-1 for i in range(n)]
# Second set of relations: [z, xi] = 1
r2 = [commutator(z, x[i]) for i in range(n)]
# Third set of relations: [z, yi] = 1
r3 = [commutator(z, y[i]) for i in range(n)]
# Fourth set of relations: [xi, yi] = 1 for i != j
r4 = [commutator(x[i], y[j]) for i in range(n) for j in range(n) if i != j]
rls = r1 + r2 + r3 + r4
from sage.sets.primes import Primes
if p not in Primes() and p != 0:
raise ValueError("p must be 0 or a prime number")
if p > 0:
rls += [w**p for w in F.gens()]
return FinitelyPresentedGroup(F, tuple(rls))
def FinitelyGeneratedAbelianPresentation(int_list):
r"""
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: 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 >
You can create free abelian groups::
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 >
And various infinite abelian groups::
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 >
Outputs are reduced to minimal generators and relations::
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 >
The trivial group is an acceptable output::
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 < | >
Input list must consist of positive integers::
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
TESTS::
sage: ag = groups.presentation.FGAbelian([2,2])
sage: ag.as_permutation_group().is_isomorphic(groups.permutation.KleinFour())
True
sage: G = groups.presentation.FGAbelian([2,4,8])
sage: C2 = CyclicPermutationGroup(2)
sage: C4 = CyclicPermutationGroup(4)
sage: C8 = CyclicPermutationGroup(8)
sage: gg = (C2.direct_product(C4)[0]).direct_product(C8)[0]
sage: gg.is_isomorphic(G.as_permutation_group())
True
sage: all(groups.presentation.FGAbelian([i]).as_permutation_group().is_isomorphic(groups.presentation.Cyclic(i).as_permutation_group()) for i in [2..35])
True
"""
from sage.groups.free_group import _lexi_gen
check_ls = [Integer(x) for x in int_list if Integer(x) >= 0]
if len(check_ls) != len(int_list):
raise ValueError('input list must contain nonnegative entries')
col_sp = diagonal_matrix(int_list).column_space()
invariants = FGP_Module(ZZ**(len(int_list)), col_sp).invariants()
name_gen = _lexi_gen()
F = FreeGroup([next(name_gen) for i in invariants])
ret_rls = [
F([i + 1])**invariants[i] for i in range(len(invariants))
if invariants[i] != 0
]
# Build commutator relations
gen_pairs = [[F.gen(i), F.gen(j)] for i in range(F.ngens() - 1)
for j in range(i + 1, F.ngens())]
ret_rls = ret_rls + [
x[0]**(-1) * x[1]**(-1) * x[0] * x[1] for x in gen_pairs
]
return FinitelyPresentedGroup(F, tuple(ret_rls))
def fundamental_group(self, simplify=True):
r"""
Return the fundamental group of this pointed simplicial set.
INPUT:
- ``simplify`` (bool, optional ``True``) -- if
``False``, then return a presentation of the group
in terms of generators and relations. If ``True``,
the default, simplify as much as GAP is able to.
Algorithm: we compute the edge-path group -- see
Section 19 of [Kan1958]_ and
:wikipedia:`Fundamental_group`. Choose a spanning tree
for the connected component of the 1-skeleton
containing the base point, and then the group's
generators are given by the non-degenerate
edges. There are two types of relations: `e=1` if `e`
is in the spanning tree, and for every 2-simplex, if
its faces are `e_0`, `e_1`, and `e_2`, then we impose
the relation `e_0 e_1^{-1} e_2 = 1`, where we first
set `e_i=1` if `e_i` is degenerate.
EXAMPLES::
sage: S1 = simplicial_sets.Sphere(1)
sage: eight = S1.wedge(S1)
sage: eight.fundamental_group() # free group on 2 generators
Finitely presented group < e0, e1 | >
The fundamental group of a disjoint union of course depends on
the choice of base point::
sage: T = simplicial_sets.Torus()
sage: K = simplicial_sets.KleinBottle()
sage: X = T.disjoint_union(K)
sage: X_0 = X.set_base_point(X.n_cells(0)[0])
sage: X_0.fundamental_group().is_abelian()
True
sage: X_1 = X.set_base_point(X.n_cells(0)[1])
sage: X_1.fundamental_group().is_abelian()
False
sage: RP3 = simplicial_sets.RealProjectiveSpace(3)
sage: RP3.fundamental_group()
Finitely presented group < e | e^2 >
Compute the fundamental group of some classifying spaces::
sage: C5 = groups.misc.MultiplicativeAbelian([5])
sage: BC5 = C5.nerve()
sage: BC5.fundamental_group()
Finitely presented group < e0 | e0^5 >
sage: Sigma3 = groups.permutation.Symmetric(3)
sage: BSigma3 = Sigma3.nerve()
sage: pi = BSigma3.fundamental_group(); pi
Finitely presented group < e0, e1 | e0^2, e1^3, (e0*e1^-1)^2 >
sage: pi.order()
6
sage: pi.is_abelian()
False
The sphere has a trivial fundamental group::
sage: S2 = simplicial_sets.Sphere(2)
sage: S2.fundamental_group()
Finitely presented group < | >
"""
# Import this here to prevent importing libgap upon startup.
from sage.groups.free_group import FreeGroup
skel = self.n_skeleton(2)
graph = skel.graph()
if not skel.is_connected():
graph = graph.subgraph(skel.base_point())
edges = [e[2] for e in graph.edges()]
spanning_tree = [e[2] for e in graph.min_spanning_tree()]
gens = [e for e in edges if e not in spanning_tree]
if not gens:
return FreeGroup([]).quotient([])
gens_dict = dict(zip(gens, range(len(gens))))
FG = FreeGroup(len(gens), 'e')
rels = []
for f in skel.n_cells(2):
z = dict()
for i, sigma in enumerate(skel.faces(f)):
if sigma in spanning_tree:
z[i] = FG.one()
elif sigma.is_degenerate():
z[i] = FG.one()
elif sigma in edges:
z[i] = FG.gen(gens_dict[sigma])
else:
# sigma is not in the correct connected component.
z[i] = FG.one()
rels.append(z[0] * z[1].inverse() * z[2])
if simplify:
return FG.quotient(rels).simplified()
else:
return FG.quotient(rels)
def FinitelyGeneratedHeisenbergPresentation(n=1, p=0):
r"""
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.
.. SEEALSO::
:class:`~sage.groups.matrix_gps.heisenberg.HeisenbergGroup`
EXAMPLES::
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
REFERENCES:
- :wikipedia:`Heisenberg_group`
"""
n = Integer(n)
if n < 1:
raise ValueError('n must be a positive integer')
# generators' names are x1, .., xn, y1, .., yn, z
vx = ['x' + str(i) for i in range(1,n+1)]
vy = ['y' + str(i) for i in range(1,n+1)]
str_generators = ', '.join(vx + vy + ['z'])
F = FreeGroup(str_generators)
x = F.gens()[0:n] # list of generators x1, x2, ..., xn
y = F.gens()[n:2*n] # list of generators x1, x2, ..., xn
z = F.gen(n*2)
def commutator(a, b): return a * b * a**-1 * b**-1
# First set of relations: [xi, yi] = z
r1 = [commutator(x[i], y[i]) * z**-1 for i in range(n)]
# Second set of relations: [z, xi] = 1
r2 = [commutator(z, x[i]) for i in range(n)]
# Third set of relations: [z, yi] = 1
r3 = [commutator(z, y[i]) for i in range(n)]
# Fourth set of relations: [xi, yi] = 1 for i != j
r4 = [commutator(x[i], y[j]) for i in range(n) for j in range(n) if i!=j]
rls = r1 + r2 + r3 + r4
from sage.sets.primes import Primes
if p not in Primes() and p != 0:
raise ValueError("p must be 0 or a prime number")
if p > 0:
rls += [w**p for w in F.gens()]
return FinitelyPresentedGroup(F, tuple(rls))
def fundamental_group(f, simplified=True, projective=False):
r"""
Return a presentation of the fundamental group of the complement of
the algebraic set defined by the polynomial ``f``.
INPUT:
- ``f`` -- a polynomial in two variables, with coefficients in either
the rationals or a number field with a fixed embedding in `\QQbar`
- ``simplified`` -- boolean (default: ``True``); if set to ``True`` the
presentation will be simplified (see below)
- ``projective`` -- boolean (default: ``False``); if set to ``True``,
the fundamental group of the complement of the projective completion
of the curve will be computed, otherwise, the fundamental group of
the complement in the affine plane will be computed
If ``simplified`` is ``False``, a Zariski-VanKampen presentation is returned.
OUTPUT:
A presentation of the fundamental group of the complement of the
curve defined by ``f``.
EXAMPLES::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: R.<x,y> = QQ[]
sage: f = x^2 + y^3
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < ... >
sage: fundamental_group(f, simplified=False) # optional - sirocco
Finitely presented group < ... >
::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: R.<x,y> = QQ[]
sage: f = y^3 + x^3
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < ... >
It is also possible to have coefficients in a number field with a
fixed embedding in `\QQbar`::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: zeta = QQbar['x']('x^2+x+1').roots(multiplicities=False)[0]
sage: zeta
-0.50000000000000000? - 0.866025403784439?*I
sage: F = NumberField(zeta.minpoly(), 'zeta', embedding=zeta)
sage: F.inject_variables()
Defining zeta
sage: R.<x,y> = F[]
sage: f = y^3 + x^3 +zeta *x + 1
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < x0 | >
"""
bm = braid_monodromy(f)
n = bm[0].parent().strands()
F = FreeGroup(n)
R = [x * b / x for x in F.gens() for b in bm]
if projective:
R.append(prod(F.gens()))
G = F / R
if simplified:
return G.simplified()
return G
def direct_product(self, H, reduced=False, new_names=True):
r"""
Return the direct product of ``self`` with finitely presented
group ``H``.
Calls GAP function ``DirectProduct``, which returns the direct
product of a list of groups of any representation.
From [JohnsonPG90]_ (pg 45, proposition 4): If `G`, `H` are groups
presented by `\langle X \mid R \rangle` and `\langle Y \mid S \rangle`
respectively, then their direct product has the presentation
`\langle X, Y \mid R, S, [X, Y] \rangle` where `[X, Y]` denotes the
set of commutators `\{ x^{-1} y^{-1} x y \mid x \in X, y \in Y \}`.
INPUT:
- ``H`` -- a finitely presented group
- ``reduced`` -- (default: ``False``) boolean; if ``True``, then
attempt to reduce the presentation of the product group
- ``new_names`` -- (default: ``True``) boolean; If ``True``, then
lexicographical variable names are assigned to the generators of
the group to be returned. If ``False``, the group to be returned
keeps the generator names of the two groups forming the direct
product. Note that one cannot ask to reduce the output and ask
to keep the old variable names, as they they may change meaning
in the output group if its presentation is reduced.
OUTPUT:
The direct product of ``self`` with ``H`` as a finitely
presented group.
EXAMPLES::
sage: G = FreeGroup()
sage: C12 = ( G / [G([1,1,1,1])] ).direct_product( G / [G([1,1,1])]); C12
Finitely presented group < a, b | a^4, b^3, a^-1*b^-1*a*b >
sage: C12.order(), C12.as_permutation_group().is_cyclic()
(12, True)
sage: klein = ( G / [G([1,1])] ).direct_product( G / [G([1,1])]); klein
Finitely presented group < a, b | a^2, b^2, a^-1*b^-1*a*b >
sage: klein.order(), klein.as_permutation_group().is_cyclic()
(4, False)
We can keep the variable names from ``self`` and ``H`` to examine how
new relations are formed::
sage: F = FreeGroup("a"); G = FreeGroup("g")
sage: X = G / [G.0^12]; A = F / [F.0^6]
sage: X.direct_product(A, new_names=False)
Finitely presented group < g, a | g^12, a^6, g^-1*a^-1*g*a >
sage: A.direct_product(X, new_names=False)
Finitely presented group < a, g | a^6, g^12, a^-1*g^-1*a*g >
Or we can attempt to reduce the output group presentation::
sage: F = FreeGroup("a"); G = FreeGroup("g")
sage: X = G / [G.0]; A = F / [F.0]
sage: X.direct_product(A, new_names=True)
Finitely presented group < a, b | a, b, a^-1*b^-1*a*b >
sage: X.direct_product(A, reduced=True, new_names=True)
Finitely presented group < | >
But we cannot do both::
sage: K = FreeGroup(['a','b'])
sage: D = K / [K.0^5, K.1^8]
sage: D.direct_product(D, reduced=True, new_names=False)
Traceback (most recent call last):
...
ValueError: cannot reduce output and keep old variable names
TESTS::
sage: G = FreeGroup()
sage: Dp = (G / [G([1,1])]).direct_product( G / [G([1,1,1,1,1,1])] )
sage: Dp.as_permutation_group().is_isomorphic(PermutationGroup(['(1,2)','(3,4,5,6,7,8)']))
True
sage: C7 = G / [G.0**7]; C6 = G / [G.0**6]
sage: C14 = G / [G.0**14]; C3 = G / [G.0**3]
sage: C7.direct_product(C6).is_isomorphic(C14.direct_product(C3))
True
sage: F = FreeGroup(2); D = F / [F([1,1,1,1,1]),F([2,2]),F([1,2])**2]
sage: D.direct_product(D).as_permutation_group().is_isomorphic(
....: direct_product_permgroups([DihedralGroup(5),DihedralGroup(5)]))
True
AUTHORS:
- Davis Shurbert (2013-07-20): initial version
REFERENCES:
.. [JohnsonPG90] D.L. Johnson. *Presentations of Groups*.
Cambridge University Press. (1990).
"""
from sage.groups.free_group import FreeGroup, _lexi_gen
if not isinstance(H, FinitelyPresentedGroup):
raise TypeError("input must be a finitely presented group")
if reduced and not new_names:
raise ValueError(
"cannot reduce output and keep old variable names")
fp_product = libgap.DirectProduct([self.gap(), H.gap()])
GAP_gens = fp_product.FreeGeneratorsOfFpGroup()
if new_names:
name_itr = _lexi_gen(
) # Python generator for lexicographical variable names
gen_names = [name_itr.next() for i in GAP_gens]
else:
gen_names = [str(g)
for g in self.gens()] + [str(g) for g in H.gens()]
# Build the direct product in Sage for better variable names
ret_F = FreeGroup(gen_names)
ret_rls = tuple([
ret_F(rel_word.TietzeWordAbstractWord(GAP_gens).sage())
for rel_word in fp_product.RelatorsOfFpGroup()
])
ret_fpg = FinitelyPresentedGroup(ret_F, ret_rls)
if reduced:
ret_fpg = ret_fpg.simplified()
return ret_fpg
def fundamental_group(f, simplified=True, projective=False):
r"""
Return a presentation of the fundamental group of the complement of
the algebraic set defined by the polynomial ``f``.
INPUT:
- ``f`` -- a polynomial in two variables, with coefficients in either
the rationals or a number field with a fixed embedding in `\QQbar`
- ``simplified`` -- boolean (default: ``True``); if set to ``True`` the
presentation will be simplified (see below)
- ``projective`` -- boolean (default: ``False``); if set to ``True``,
the fundamental group of the complement of the projective completion
of the curve will be computed, otherwise, the fundamental group of
the complement in the affine plane will be computed
If ``simplified`` is ``False``, the returned presentation has as
many generators as degree of the polynomial times the points in the
base used to create the segments that surround the discriminant. In
this case, the generators are granted to be meridians of the curve.
OUTPUT:
A presentation of the fundamental group of the complement of the
curve defined by ``f``.
EXAMPLES::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: R.<x,y> = QQ[]
sage: f = x^2 + y^3
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < ... >
sage: fundamental_group(f, simplified=False) # optional - sirocco
Finitely presented group < ... >
::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: R.<x,y> = QQ[]
sage: f = y^3 + x^3
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < ... >
It is also possible to have coefficients in a number field with a
fixed embedding in `\QQbar`::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: zeta = QQbar['x']('x^2+x+1').roots(multiplicities=False)[0]
sage: zeta
-0.50000000000000000? - 0.866025403784439?*I
sage: F = NumberField(zeta.minpoly(), 'zeta', embedding=zeta)
sage: F.inject_variables()
Defining zeta
sage: R.<x,y> = F[]
sage: f = y^3 + x^3 +zeta *x + 1
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < x0 | >
"""
(x, y) = f.variables()
F = f.base_ring()
g = f.factor().radical().prod()
d = g.degree(y)
while not g.coefficient(y**d) in F or (projective and g.total_degree() > d):
g = g.subs({x: x + y})
d = g.degree(y)
disc = discrim(g)
segs = segments(disc)
vertices = list(set(flatten(segs)))
Faux = FreeGroup(d)
F = FreeGroup(d * len(vertices))
rels = []
if projective:
rels.append(prod(F.gen(i) for i in range(d)))
braidscomputed = braid_in_segment([(g, seg[0], seg[1]) for seg in segs])
for braidcomputed in braidscomputed:
seg = (braidcomputed[0][0][1], braidcomputed[0][0][2])
b = braidcomputed[1]
i = vertices.index(seg[0])
j = vertices.index(seg[1])
for k in range(d):
el1 = Faux([k + 1]) * b.inverse()
el2 = k + 1
w1 = F([sign(a)*d*i + a for a in el1.Tietze()])
w2 = F([d*j + el2])
rels.append(w1/w2)
G = F / rels
if simplified:
return G.simplified()
else:
return G
def fundamental_group(self, simplify=True):
r"""
Return the fundamental group of this pointed simplicial set.
INPUT:
- ``simplify`` (bool, optional ``True``) -- if
``False``, then return a presentation of the group
in terms of generators and relations. If ``True``,
the default, simplify as much as GAP is able to.
Algorithm: we compute the edge-path group -- see
Section 19 of [Kan1958]_ and
:wikipedia:`Fundamental_group`. Choose a spanning tree
for the connected component of the 1-skeleton
containing the base point, and then the group's
generators are given by the non-degenerate
edges. There are two types of relations: `e=1` if `e`
is in the spanning tree, and for every 2-simplex, if
its faces are `e_0`, `e_1`, and `e_2`, then we impose
the relation `e_0 e_1^{-1} e_2 = 1`, where we first
set `e_i=1` if `e_i` is degenerate.
EXAMPLES::
sage: S1 = simplicial_sets.Sphere(1)
sage: eight = S1.wedge(S1)
sage: eight.fundamental_group() # free group on 2 generators
Finitely presented group < e0, e1 | >
The fundamental group of a disjoint union of course depends on
the choice of base point::
sage: T = simplicial_sets.Torus()
sage: K = simplicial_sets.KleinBottle()
sage: X = T.disjoint_union(K)
sage: X_0 = X.set_base_point(X.n_cells(0)[0])
sage: X_0.fundamental_group().is_abelian()
True
sage: X_1 = X.set_base_point(X.n_cells(0)[1])
sage: X_1.fundamental_group().is_abelian()
False
sage: RP3 = simplicial_sets.RealProjectiveSpace(3)
sage: RP3.fundamental_group()
Finitely presented group < e | e^2 >
Compute the fundamental group of some classifying spaces::
sage: C5 = groups.misc.MultiplicativeAbelian([5])
sage: BC5 = C5.nerve()
sage: BC5.fundamental_group()
Finitely presented group < e0 | e0^5 >
sage: Sigma3 = groups.permutation.Symmetric(3)
sage: BSigma3 = Sigma3.nerve()
sage: pi = BSigma3.fundamental_group(); pi
Finitely presented group < e0, e1 | e0^2, e1^3, (e0*e1^-1)^2 >
sage: pi.order()
6
sage: pi.is_abelian()
False
"""
# Import this here to prevent importing libgap upon startup.
from sage.groups.free_group import FreeGroup
skel = self.n_skeleton(2)
graph = skel.graph()
if not skel.is_connected():
graph = graph.subgraph(skel.base_point())
edges = [e[2] for e in graph.edges()]
spanning_tree = [e[2] for e in graph.min_spanning_tree()]
gens = [e for e in edges if e not in spanning_tree]
if not gens:
return gap.TrivialGroup()
gens_dict = dict(zip(gens, range(len(gens))))
FG = FreeGroup(len(gens), 'e')
rels = []
for f in skel.n_cells(2):
z = dict()
for i, sigma in enumerate(skel.faces(f)):
if sigma in spanning_tree:
z[i] = FG.one()
elif sigma.is_degenerate():
z[i] = FG.one()
elif sigma in edges:
z[i] = FG.gen(gens_dict[sigma])
else:
# sigma is not in the correct connected component.
z[i] = FG.one()
rels.append(z[0]*z[1].inverse()*z[2])
if simplify:
return FG.quotient(rels).simplified()
else:
return FG.quotient(rels)
def fundamental_group(f, simplified=True, projective=False):
r"""
Return a presentation of the fundamental group of the complement of
the algebraic set defined by the polynomial ``f``.
INPUT:
- ``f`` -- a polynomial in two variables, with coefficients in either
the rationals or a number field with a fixed embedding in `\QQbar`
- ``simplified`` -- boolean (default: ``True``); if set to ``True`` the
presentation will be simplified (see below)
- ``projective`` -- boolean (default: ``False``); if set to ``True``,
the fundamental group of the complement of the projective completion
of the curve will be computed, otherwise, the fundamental group of
the complement in the affine plane will be computed
If ``simplified`` is ``False``, the returned presentation has as
many generators as degree of the polynomial times the points in the
base used to create the segments that surround the discriminant. In
this case, the generators are granted to be meridians of the curve.
OUTPUT:
A presentation of the fundamental group of the complement of the
curve defined by ``f``.
EXAMPLES::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: R.<x,y> = QQ[]
sage: f = x^2 + y^3
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < ... >
sage: fundamental_group(f, simplified=False) # optional - sirocco
Finitely presented group < ... >
::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: R.<x,y> = QQ[]
sage: f = y^3 + x^3
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < ... >
It is also possible to have coefficients in a number field with a
fixed embedding in `\QQbar`::
sage: from sage.schemes.curves.zariski_vankampen import fundamental_group # optional - sirocco
sage: zeta = QQbar['x']('x^2+x+1').roots(multiplicities=False)[0]
sage: zeta
-0.50000000000000000? - 0.866025403784439?*I
sage: F = NumberField(zeta.minpoly(), 'zeta', embedding=zeta)
sage: F.inject_variables()
Defining zeta
sage: R.<x,y> = F[]
sage: f = y^3 + x^3 +zeta *x + 1
sage: fundamental_group(f) # optional - sirocco
Finitely presented group < x0 | >
"""
(x, y) = f.variables()
F = f.base_ring()
g = f.factor().radical().prod()
d = g.degree(y)
while not g.coefficient(y**d) in F or (projective and g.total_degree() > d):
g = g.subs({x: x + y})
d = g.degree(y)
disc = discrim(g)
segs = segments(disc)
vertices = list(set(flatten(segs)))
Faux = FreeGroup(d)
F = FreeGroup(d * len(vertices))
rels = []
if projective:
rels.append(prod(F.gen(i) for i in range(d)))
braidscomputed = braid_in_segment([(g, seg[0], seg[1]) for seg in segs])
for braidcomputed in braidscomputed:
seg = (braidcomputed[0][0][1], braidcomputed[0][0][2])
b = braidcomputed[1]
i = vertices.index(seg[0])
j = vertices.index(seg[1])
for k in range(d):
el1 = Faux([k + 1]) * b.inverse()
el2 = k + 1
w1 = F([sign(a)*d*i + a for a in el1.Tietze()])
w2 = F([d*j + el2])
rels.append(w1/w2)
G = F / rels
if simplified:
return G.simplified()
else:
return G
def FinitelyGeneratedAbelianPresentation(int_list):
r"""
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: 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 >
You can create free abelian groups::
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 >
And various infinite abelian groups::
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 >
Outputs are reduced to minimal generators and relations::
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 >
The trivial group is an acceptable output::
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 < | >
Input list must consist of positive integers::
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
TESTS::
sage: ag = groups.presentation.FGAbelian([2,2])
sage: ag.as_permutation_group().is_isomorphic(groups.permutation.KleinFour())
True
sage: G = groups.presentation.FGAbelian([2,4,8])
sage: C2 = CyclicPermutationGroup(2)
sage: C4 = CyclicPermutationGroup(4)
sage: C8 = CyclicPermutationGroup(8)
sage: gg = (C2.direct_product(C4)[0]).direct_product(C8)[0]
sage: gg.is_isomorphic(G.as_permutation_group())
True
sage: all(groups.presentation.FGAbelian([i]).as_permutation_group().is_isomorphic(groups.presentation.Cyclic(i).as_permutation_group()) for i in [2..35])
True
"""
from sage.groups.free_group import _lexi_gen
check_ls = [Integer(x) for x in int_list if Integer(x) >= 0]
if len(check_ls) != len(int_list):
raise ValueError('input list must contain nonnegative entries')
col_sp = diagonal_matrix(int_list).column_space()
invariants = FGP_Module(ZZ**(len(int_list)), col_sp).invariants()
name_gen = _lexi_gen()
F = FreeGroup([next(name_gen) for i in invariants])
ret_rls = [F([i+1])**invariants[i] for i in range(len(invariants)) if invariants[i]!=0]
# Build commutator relations
gen_pairs = [[F.gen(i),F.gen(j)] for i in range(F.ngens()-1) for j in range(i+1,F.ngens())]
ret_rls = ret_rls + [x[0]**(-1)*x[1]**(-1)*x[0]*x[1] for x in gen_pairs]
return FinitelyPresentedGroup(F, tuple(ret_rls))