Coverage for local/lib/python2.7/site-packages/sage/groups/abelian_gps/abelian_group_gap.py : 93%

r""" 

Finitely generated abelian groups with GAP. 

This module provides a python wrapper for abelian groups in GAP. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: AbelianGroupGap([3,5]) 

Abelian group with gap, generator orders (3, 5) 

For infinite abelian groups we use the GAP package ``Polycyclic``:: 

sage: AbelianGroupGap([3,0]) # optional - gap_packages 

Abelian group with gap, generator orders (3, 0) 

AUTHORS: 

- Simon Brandhorst (2018-01-17): initial version 

""" 

# **************************************************************************** 

# Copyright (C) 2018 Simon Brandhorst <sbrandhorst@web.de> 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 2 of the License, or 

# (at your option) any later version. 

# http://www.gnu.org/licenses/ 

# **************************************************************************** 

from sage.groups.libgap_wrapper import ParentLibGAP, ElementLibGAP 

from sage.groups.libgap_mixin import GroupMixinLibGAP 

from sage.groups.group import AbelianGroup as AbelianGroupBase 

from sage.libs.gap.element import GapElement 

from sage.libs.gap.libgap import libgap 

from sage.misc.cachefunc import cached_method 

from sage.rings.integer_ring import ZZ 

from sage.structure.unique_representation import UniqueRepresentation 

from sage.categories.groups import Groups 

class AbelianGroupElement_gap(ElementLibGAP): 

r""" 

An element of an abelian group via libgap. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3,6]) 

sage: G.gens() 

(f1, f2) 

""" 

def __init__(self, parent, x, check=True): 

""" 

The Python constructor. 

See :class:`AbelianGroupElement_gap` for details. 

INPUT: 

- ``parent`` -- an instance of :class:`AbelianGroup_gap` 

- ``x`` -- an instance of :class:`sage.libs.gap.element.GapElement` 

- ``check`` -- boolean (default: ``True``); check 

if ``x`` is an element of the group 

TESTS:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3,6]) 

sage: g = G.an_element() 

sage: TestSuite(g).run() 

""" 

if check and x not in parent.gap(): 

raise ValueError("%s is not in the group %s" % (x, parent)) 

ElementLibGAP.__init__(self, parent, x) 

def __hash__(self): 

r""" 

Return the hash of this element. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3,2,4]) 

sage: g = G.an_element() 

sage: g.__hash__() # random 

1693277541873681615 

""" 

return hash(self.parent()) ^ hash(self.exponents()) 

def __reduce__(self): 

r""" 

Implement pickling. 

OUTPUT: 

- a tuple ``f`` such that this element is ``f[0](*f[1])`` 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3,2,4]) 

sage: g = G.an_element() 

sage: g == loads(dumps(g)) 

True 

sage: g.__reduce__() 

(Abelian group with gap, generator orders (3, 2, 4), ((1, 1, 1),)) 

""" 

return self.parent(), (self.exponents(),) 

def exponents(self): 

r""" 

Return the tuple of exponents of this element. 

OUTPUT: 

- a tuple of integers 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([4,7,9]) 

sage: gens = G.gens() 

sage: g = gens[0]^2 * gens[1]^4 * gens[2]^8 

sage: g.exponents() 

(2, 4, 8) 

sage: S = G.subgroup(G.gens()[:1]) 

sage: s = S.gens()[0] 

sage: s 

f1 

sage: s.exponents() 

(1,) 

It can handle quite large groups too:: 

sage: G = AbelianGroupGap([2^10, 5^10]) 

sage: f1, f2 = G.gens() 

sage: g = f1^123*f2^789 

sage: g.exponents() 

(123, 789) 

.. WARNING:: 

Crashes for very large groups. 

.. TODO:: 

Make exponents work for very large groups. 

This could be done by using Pcgs in gap. 

""" 

P = self.parent() 

# better than Factorization as this does not create the 

# whole group in memory. 

f = P.gap().EpimorphismFromFreeGroup() 

x = f.PreImagesRepresentative(self.gap()) 

L = x.ExtRepOfObj().sage() 

Lgens = L[::2] 

Lexpo = L[1::2] 

exp = [] 

orders = P.gens_orders() 

i = 0 

for k in range(len(P.gens())): 

if not k+1 in Lgens: 

exp.append(0) 

else: 

i = Lgens.index(k+1) 

exp.append(Lexpo[i] % orders[k]) 

return tuple(exp) 

def order(self): 

r""" 

Return the order of this element. 

OUTPUT: 

- an integer or infinity 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([4]) 

sage: g = G.gens()[0] 

sage: g.order() 

4 

sage: G = AbelianGroupGap([0]) # optional - gap_packages 

sage: g = G.gens()[0] # optional - gap_packages 

sage: g.order() # optional - gap_packages 

+Infinity 

""" 

return self.gap().Order().sage() 

class AbelianGroupElement_polycyclic(AbelianGroupElement_gap): 

r""" 

An element of an abelian group using the GAP package ``Polycyclic``. 

TESTS:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([4,7,0]) # optional - gap_packages 

sage: TestSuite(G.an_element()).run() # optional - gap_packages 

""" 

def exponents(self): 

r""" 

Return the tuple of exponents of ``self``. 

OUTPUT: 

- a tuple of integers 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([4,7,0]) # optional - gap_packages 

sage: gens = G.gens() # optional - gap_packages 

sage: g = gens[0]^2 * gens[1]^4 * gens[2]^8 # optional - gap_packages 

sage: g.exponents() # optional - gap_packages 

(2, 4, 8) 

Efficiently handles very large groups:: 

sage: G = AbelianGroupGap([2^30,5^30,0]) # optional - gap_packages 

sage: f1, f2, f3 = G.gens() # optional - gap_packages 

sage: (f1^12345*f2^123456789).exponents() # optional - gap_packages 

(12345, 123456789, 0) 

""" 

return tuple(self.gap().Exponents().sage()) 

class AbelianGroup_gap(UniqueRepresentation, GroupMixinLibGAP, ParentLibGAP, AbelianGroupBase): 

r""" 

Finitely generated abelian groups implemented in GAP. 

Needs the gap package ``Polycyclic`` in case the group is infinite. 

INPUT: 

- ``G`` -- a GAP group 

- ``category`` -- a category 

- ``ambient`` -- (optional) an :class:`AbelianGroupGap` 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3, 2, 5]) 

sage: G 

Abelian group with gap, generator orders (3, 2, 5) 

""" 

def __init__(self, G, category, ambient=None): 

r""" 

Create an instance of this class. 

See :class:`AbelianGroup_gap` for details 

TESTS:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3,2,5]) 

sage: TestSuite(G).run() 

""" 

AbelianGroupBase.__init__(self, category=category) 

ParentLibGAP.__init__(self, G, ambient=ambient) 

Element = AbelianGroupElement_gap 

def _coerce_map_from_(self, S): 

r""" 

Return whether ``S`` canonically coerces to ``self``. 

INPUT: 

- ``S`` -- anything 

OUTPUT: 

Boolean. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: gen = G.gens()[:2] 

sage: S = G.subgroup(gen) 

sage: G._coerce_map_from_(S) 

True 

sage: S._coerce_map_from_(G) 

False 

""" 

if isinstance(S, AbelianGroup_gap): 

return S.is_subgroup_of(self) 

return super(AbelianGroup_gap, self)._coerce_map_from_(S) 

def _element_constructor_(self, x, check=True): 

r""" 

Defines coercions and conversions. 

INPUT: 

- ``x`` -- an element of this group, a GAP element 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3]) 

sage: A = AbelianGroup([2,3]) 

sage: a = A.an_element() 

sage: a 

f0*f1 

sage: G(a) 

f1*f2 

sage: A = AdditiveAbelianGroup([2,3]) 

sage: a = A.an_element() 

sage: a 

(1, 0) 

sage: G(a) 

f1 

For general ``fgp_modules`` conversion is implemented if our 

group is in Smith form:: 

sage: G = AbelianGroupGap([6]) 

sage: A = ZZ^2 

sage: e0,e1 = A.gens() 

sage: A = A / A.submodule([2*e0, 3*e1]) 

sage: a = 2 * A.an_element() 

sage: a 

(2) 

sage: G(a) 

f2 

""" 

if isinstance(x, AbelianGroupElement_gap): 

x = x.gap() 

elif x == 1 or x == (): 

x = self.gap().Identity() 

elif not isinstance(x, GapElement): 

from sage.groups.abelian_gps.abelian_group_element import AbelianGroupElement 

from sage.groups.additive_abelian.additive_abelian_group import AdditiveAbelianGroupElement 

from sage.modules.fg_pid.fgp_element import FGP_Element 

if isinstance(x, AbelianGroupElement): 

exp = x.exponents() 

elif isinstance(x, AdditiveAbelianGroupElement): 

exp = x._hermite_lift() 

elif isinstance(x, FGP_Element): 

exp = x.vector() 

else: 

from sage.modules.free_module_element import vector 

exp = vector(ZZ, x) 

# turn the exponents into a gap element 

gens_gap = self.gens() 

if len(exp) != len(gens_gap): 

raise ValueError("input does not match the number of generators") 

x = gens_gap[0]**0 

for i in range(len(exp)): 

x *= gens_gap[i]**exp[i] 

x = x.gap() 

return self.element_class(self, x, check=check) 

def all_subgroups(self): 

r""" 

Return the list of all subgroups of this group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2, 3]) 

sage: G.all_subgroups() 

[Subgroup of Abelian group with gap, generator orders (2, 3) generated by (1,), 

Subgroup of Abelian group with gap, generator orders (2, 3) generated by (f1,), 

Subgroup of Abelian group with gap, generator orders (2, 3) generated by (f2,), 

Subgroup of Abelian group with gap, generator orders (2, 3) generated by (f1, f2)] 

""" 

subgroups_gap = self.gap().AllSubgroups() 

subgroups_sage = [] 

for G in subgroups_gap: 

S = self.subgroup(G.GeneratorsOfGroup()) 

subgroups_sage.append(S) 

return subgroups_sage 

def automorphism_group(self): 

r""" 

Return the group of automorphisms of ``self``. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2, 3]) 

sage: G.aut() 

Full group of automorphisms of Abelian group with gap, generator orders (2, 3) 

""" 

from sage.groups.abelian_gps.abelian_aut import AbelianGroupAutomorphismGroup 

return AbelianGroupAutomorphismGroup(self) 

aut = automorphism_group 

def is_trivial(self): 

r""" 

Return ``True`` if this group is the trivial group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([]) 

sage: G 

Abelian group with gap, generator orders () 

sage: G.is_trivial() 

True 

sage: AbelianGroupGap([1]).is_trivial() 

True 

sage: AbelianGroupGap([1,1,1]).is_trivial() 

True 

sage: AbelianGroupGap([2]).is_trivial() 

False 

sage: AbelianGroupGap([2,1]).is_trivial() 

False 

""" 

return 1 == self.order() 

def identity(self): 

r""" 

Return the identity element of this group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([4,10]) 

sage: G.identity() 

1 

""" 

return self.one() 

@cached_method 

def elementary_divisors(self): 

r""" 

Return the elementary divisors of this group. 

See :meth:`sage.groups.abelian_gps.abelian_group_gap.elementary_divisors`. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: G.elementary_divisors() 

(2, 60) 

""" 

ediv = self.gap().AbelianInvariants().sage() 

from sage.matrix.constructor import diagonal_matrix 

ed = diagonal_matrix(ZZ, ediv).elementary_divisors() 

return tuple(d for d in ed if d != 1) 

@cached_method 

def exponent(self): 

r""" 

Return the exponent of this abelian group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,7]) 

sage: G 

Abelian group with gap, generator orders (2, 3, 7) 

sage: G = AbelianGroupGap([2,4,6]) 

sage: G 

Abelian group with gap, generator orders (2, 4, 6) 

sage: G.exponent() 

12 

""" 

return self.gap().Exponent().sage() 

@cached_method 

def gens_orders(self): 

r""" 

Return the orders of the generators. 

Use :meth:`elementary_divisors` if you are looking for an 

invariant of the group. 

OUTPUT: 

- a tuple of integers 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: Z2xZ3 = AbelianGroupGap([2,3]) 

sage: Z2xZ3.gens_orders() 

(2, 3) 

sage: Z2xZ3.elementary_divisors() 

(6,) 

sage: Z6 = AbelianGroupGap([6]) 

sage: Z6.gens_orders() 

(6,) 

sage: Z6.elementary_divisors() 

(6,) 

sage: Z2xZ3.is_isomorphic(Z6) 

True 

sage: Z2xZ3 is Z6 

False 

""" 

from sage.rings.infinity import Infinity 

orders = [] 

for g in self.gens(): 

order = g.order() 

if order == Infinity: 

order = 0 

orders.append(order) 

return tuple(orders) 

def is_subgroup_of(self, G): 

r""" 

Return if ``self`` is a subgroup of ``G`` considered in 

the same ambient group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: gen = G.gens()[:2] 

sage: S1 = G.subgroup(gen) 

sage: S1.is_subgroup_of(G) 

True 

sage: S2 = G.subgroup(G.gens()[1:]) 

sage: S2.is_subgroup_of(S1) 

False 

""" 

if not isinstance(G, AbelianGroup_gap): 

raise ValueError("input must be an instance of AbelianGroup_gap") 

if not self.ambient() is G.ambient(): 

return False 

return G.gap().IsSubsemigroup(self).sage() 

def subgroup(self, gens): 

r""" 

Return the subgroup of this group generated by ``gens``. 

INPUT: 

- ``gens`` -- a list of elements coercible into this group 

OUTPUT: 

- a subgroup 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: gen = G.gens()[:2] 

sage: S = G.subgroup(gen) 

sage: S 

Subgroup of Abelian group with gap, generator orders (2, 3, 4, 5) 

generated by (f1, f2) 

sage: g = G.an_element() 

sage: s = S.an_element() 

sage: g * s 

f2^2*f3*f5 

sage: G = AbelianGroupGap([3,4,0,2]) # optional - gap_packages 

sage: gen = G.gens()[:2] # optional - gap_packages 

sage: S = G.subgroup(gen) # optional - gap_packages 

sage: g = G.an_element() # optional - gap_packages 

sage: s = S.an_element() # optional - gap_packages 

sage: g * s # optional - gap_packages 

g1^2*g2^2*g3*g4 

TESTS:: 

sage: h = G.gens()[3] 

sage: h in S 

False 

""" 

gens = tuple([self(g) for g in gens]) 

return AbelianGroupSubgroup_gap(self.ambient(), gens) 

class AbelianGroupGap(AbelianGroup_gap): 

r""" 

Abelian groups implemented using GAP. 

INPUT: 

- ``generator_orders`` -- a list of nonnegative integers where `0` 

gives a factor isomorphic to `\ZZ` 

OUTPUT: 

- an abelian group 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: AbelianGroupGap([3,6]) 

Abelian group with gap, generator orders (3, 6) 

sage: AbelianGroupGap([3,6,5]) 

Abelian group with gap, generator orders (3, 6, 5) 

sage: AbelianGroupGap([3,6,0]) # optional - gap_packages 

Abelian group with gap, generator orders (3, 6, 0) 

.. WARNING:: 

Needs the GAP package ``Polycyclic`` in case the group is infinite. 

""" 

@staticmethod 

def __classcall_private__(cls, generator_orders): 

r""" 

Normalize input to ensure a unique representation. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: A1 = AbelianGroupGap((2,3,4)) 

sage: A2 = AbelianGroupGap([4/2,3,4]) 

sage: A1 is A2 

True 

""" 

generator_orders = tuple([ZZ(e) for e in generator_orders]) 

if any(e < 0 for e in generator_orders): 

return ValueError("generator orders must be nonnegative") 

return super(AbelianGroupGap, cls).__classcall__(cls, generator_orders) 

def __init__(self, generator_orders): 

r""" 

Constructor. 

TESTS:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: A = AbelianGroup((2,3,4)) 

sage: TestSuite(A).run() 

""" 

category = Groups().Commutative() 

if 0 in generator_orders: 

if not libgap.LoadPackage("Polycyclic"): 

raise ImportError("unable to import polycyclic package") 

G = libgap.eval("AbelianPcpGroup(%s)" % list(generator_orders)) 

category = category.Infinite() 

self.Element = AbelianGroupElement_polycyclic 

else: 

G = libgap.AbelianGroup(generator_orders) 

category = category.Finite().Enumerated() 

AbelianGroup_gap.__init__(self, G, category=category) 

def _latex_(self): 

""" 

Return a latex representation of this group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,6]) 

sage: G._latex_() 

'Abelian group with gap, generator orders $(2, 6)$' 

""" 

return "Abelian group with gap, generator orders ${}$".format(self.gens_orders()) 

def _repr_(self): 

r""" 

Return a string representation of this group. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,6]) 

sage: G._repr_() 

'Abelian group with gap, generator orders (2, 6)' 

""" 

return "Abelian group with gap, generator orders " + str(self.gens_orders()) 

def __reduce__(self): 

r""" 

Implements pickling. 

We have to work around the fact that gap does not provide pickling. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([3,2,5]) 

sage: G == loads(dumps(G)) 

True 

sage: G is loads(dumps(G)) 

True 

""" 

return AbelianGroupGap, (self.gens_orders(),) 

class AbelianGroupSubgroup_gap(AbelianGroup_gap): 

r""" 

Subgroups of abelian groups with GAP. 

INPUT: 

- ``ambient`` -- the ambient group 

- ``gens`` -- generators of the subgroup 

.. NOTE:: 

Do not construct this class directly. Instead use 

:meth:`~sage.groups.abelian_groups.AbelianGroupGap.subgroup`. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: gen = G.gens()[:2] 

sage: S = G.subgroup(gen) 

""" 

def __init__(self, ambient, gens): 

r""" 

Initialize this subgroup. 

TESTS:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap, AbelianGroupSubgroup_gap 

sage: G = AbelianGroupGap([]) 

sage: gen = G.gens() 

sage: A = AbelianGroupSubgroup_gap(G, gen) 

sage: TestSuite(A).run() 

Check that we are in the correct category:: 

sage: G = AbelianGroupGap([2,3,0]) # optional - gap_packages 

sage: g = G.gens() # optional - gap_packages 

sage: H1 = G.subgroup([g[0],g[1]]) # optional - gap_packages 

sage: H1 in Groups().Finite() # optional - gap_packages 

True 

sage: H2 = G.subgroup([g[0],g[2]]) # optional - gap_packages 

sage: H2 in Groups().Infinite() # optional - gap_packages 

True 

""" 

gens_gap = tuple([g.gap() for g in gens]) 

G = ambient.gap().Subgroup(gens_gap) 

from sage.rings.infinity import Infinity 

category = Groups().Commutative() 

if G.Size().sage() < Infinity: 

category = category.Finite() 

else: 

category = category.Infinite() 

# FIXME: Tell the category that it is a Subobjects() category 

# category = category.Subobjects() 

AbelianGroup_gap.__init__(self, G, ambient=ambient, category=category) 

def _repr_(self): 

r""" 

Return a string representation of this subgroup. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: gen = G.gens()[:2] 

sage: S = G.subgroup(gen) 

sage: S 

Subgroup of Abelian group with gap, generator orders (2, 3, 4, 5) 

generated by (f1, f2) 

""" 

return "Subgroup of %s generated by %s"%(self.ambient(),self.gens()) 

def __reduce__(self): 

r""" 

Implements pickling. 

We have to work around the fact that gap does not provide pickling. 

EXAMPLES:: 

sage: from sage.groups.abelian_gps.abelian_group_gap import AbelianGroupGap 

sage: G = AbelianGroupGap([2,3,4,5]) 

sage: gen = G.gens()[:2] 

sage: S = G.subgroup(gen) 

sage: S == loads(dumps(S)) 

True 

sage: S is loads(dumps(S)) 

True 

""" 

amb = self.ambient() 

# avoid infinite loop 

gens = tuple([amb(g) for g in self.gens()]) 

return amb.subgroup, (gens,)