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 __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)
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.category() Category of finitely generated finite enumerated groups 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 TESTS:: sage: groups.matrix.Heisenberg(n=2, R=ZZ).category() Category of finitely generated infinite enumerated groups """ 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() else: cat = cat.Infinite() FinitelyGeneratedMatrixGroup_gap.__init__(self, ZZ(dim), self._ring, gap_group, category=cat)