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 _subgroup_constructor(self, libgap_subgroup):
"""
Return a finitely generated subgroup.
See
:meth:`sage.groups.libgap_wrapper.ParentLibGAP._subgroup_constructor`
for details.
TESTS::
sage: SL2Z = SL(2,ZZ)
sage: S, T = SL2Z.gens()
sage: G = SL2Z.subgroup([T^2]); G # indirect doctest
Subgroup with 1 generators (
[1 2]
[0 1]
) of Special Linear Group of degree 2 over Integer Ring
sage: G.ambient() is SL2Z
True
"""
cat = Groups()
if self in Groups().Finite():
cat = cat.Finite()
from sage.groups.matrix_gps.finitely_generated import FinitelyGeneratedMatrixGroup_gap
return FinitelyGeneratedMatrixGroup_gap(self.degree(),
self.base_ring(),
libgap_subgroup,
ambient=self,
category=cat)
def __init__(self, degree, base_ring, category=None):
"""
Base class for matrix groups over generic base rings
You should not use this class directly. Instead, use one of
the more specialized derived classes.
INPUT:
- ``degree`` -- integer. The degree (matrix size) of the
matrix group.
- ``base_ring`` -- ring. The base ring of the matrices.
TESTS::
sage: G = GL(2, QQ)
sage: from sage.groups.matrix_gps.matrix_group import MatrixGroup_generic
sage: isinstance(G, MatrixGroup_generic)
True
"""
assert base_ring in Rings
assert is_Integer(degree)
self._deg = degree
if self._deg <= 0:
raise ValueError('the degree must be at least 1')
cat = Groups() if category is None else category
if base_ring in Rings().Finite():
cat = cat.Finite()
super(MatrixGroup_generic, self).__init__(base=base_ring, category=cat)
def __init__(self, n=1, R=0):
"""
Initialize ``self``.
EXAMPLES::
sage: H = groups.matrix.Heisenberg(n=2, R=5)
sage: TestSuite(H).run() # long time
sage: H = groups.matrix.Heisenberg(n=2, R=4)
sage: TestSuite(H).run() # long time
sage: H = groups.matrix.Heisenberg(n=3)
sage: TestSuite(H).run(max_runs=30, skip="_test_elements") # long time
sage: H = groups.matrix.Heisenberg(n=2, R=GF(4))
sage: TestSuite(H).run() # long time
"""
def elementary_matrix(i, j, val, MS):
elm = copy(MS.one())
elm[i, j] = val
elm.set_immutable()
return elm
self._n = n
self._ring = R
# We need the generators of the ring as a commutative additive group
if self._ring is ZZ:
ring_gens = [self._ring.one()]
else:
if self._ring.cardinality() == self._ring.characteristic():
ring_gens = [self._ring.one()]
else:
# This is overkill, but is the only way to ensure
# we get all of the elements
ring_gens = list(self._ring)
dim = ZZ(n + 2)
MS = MatrixSpace(self._ring, dim)
gens_x = [
elementary_matrix(0, j, gen, MS) for j in range(1, dim - 1)
for gen in ring_gens
]
gens_y = [
elementary_matrix(i, dim - 1, gen, MS) for i in range(1, dim - 1)
for gen in ring_gens
]
gen_z = [elementary_matrix(0, dim - 1, gen, MS) for gen in ring_gens]
gens = gens_x + gens_y + gen_z
from sage.libs.gap.libgap import libgap
gap_gens = [libgap(single_gen) for single_gen in gens]
gap_group = libgap.Group(gap_gens)
cat = Groups().FinitelyGenerated()
if self._ring in Rings().Finite():
cat = cat.Finite()
FinitelyGeneratedMatrixGroup_gap.__init__(self,
ZZ(dim),
self._ring,
gap_group,
category=cat)
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 __init__(self, degree, ring):
"""
Initialize ``self``.
INPUT:
- ``degree`` -- integer. The degree of the affine group, that
is, the dimension of the affine space the group is acting on
naturally.
- ``ring`` -- a ring. The base ring of the affine space.
EXAMPLES::
sage: Aff6 = AffineGroup(6, QQ)
sage: Aff6 == Aff6
True
sage: Aff6 != Aff6
False
TESTS::
sage: G = AffineGroup(2, GF(5)); G
Affine Group of degree 2 over Finite Field of size 5
sage: TestSuite(G).run()
sage: G.category()
Category of finite groups
sage: Aff6 = AffineGroup(6, QQ)
sage: Aff6.category()
Category of infinite groups
"""
self._degree = degree
cat = Groups()
if degree == 0 or ring in Rings().Finite():
cat = cat.Finite()
elif ring in Rings().Infinite():
cat = cat.Infinite()
self._GL = GL(degree, ring)
Group.__init__(self, base=ring, category=cat)
