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, 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, 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, generator_names, libgap_free_group=None):
"""
Python constructor.
INPUT:
- ``generator_names`` -- a tuple of strings. The names of the
generators.
- ``libgap_free_group`` -- a LibGAP free group or ``None``
(default). The LibGAP free group to wrap. If ``None``, a
suitable group will be constructed.
TESTS::
sage: G.<a,b> = FreeGroup() # indirect doctest
sage: G
Free Group on generators {a, b}
sage: G.variable_names()
('a', 'b')
"""
self._assign_names(generator_names)
if libgap_free_group is None:
libgap_free_group = libgap.FreeGroup(generator_names)
ParentLibGAP.__init__(self, libgap_free_group)
if not generator_names:
cat = Groups().Finite()
else:
cat = Groups().Infinite()
Group.__init__(self, category=cat)
def __init__(self, vector_field_module):
r"""
See :class:`AutomorphismfieldGroup` for documentation and examples.
TESTS::
sage: M = Manifold(2, 'M')
sage: U = M.open_subset('U') ; V = M.open_subset('V')
sage: M.declare_union(U,V) # M is the union of U and V
sage: c_xy.<x,y> = U.chart() ; c_uv.<u,v> = V.chart()
sage: transf = c_xy.transition_map(c_uv, (x+y, x-y),
....: intersection_name='W', restrictions1= x>0,
....: restrictions2= u+v>0)
sage: inv = transf.inverse()
sage: from sage.geometry.manifolds.automorphismfield_group import \
....: AutomorphismFieldGroup
sage: G = AutomorphismFieldGroup(M.vector_field_module()) ; G
General linear group of the module X(M) of vector fields on the
2-dimensional manifold 'M'
"""
if not isinstance(vector_field_module, VectorFieldModule):
raise TypeError("{} is not a module of vector fields".format(
vector_field_module))
Parent.__init__(self, category=Groups())
self._vmodule = vector_field_module
self._one = None # to be set by self.one()
def __init__(self, G, H):
r"""
Return the homset of two matrix groups.
INPUT:
- ``G`` -- a matrix group.
- ``H`` -- a matrix group.
OUTPUT:
The homset of two matrix groups.
EXAMPLES::
sage: F = GF(5)
sage: gens = [matrix(F,2,[1,2, -1, 1]), matrix(F,2, [1,1, 0,1])]
sage: G = MatrixGroup(gens)
sage: from sage.groups.matrix_gps.homset import MatrixGroupHomset
sage: MatrixGroupHomset(G, G)
Set of Homomorphisms from
Matrix group over Finite Field of size 5 with 2 generators (
[1 2] [1 1]
[4 1], [0 1]
) to Matrix group over Finite Field of size 5 with 2 generators (
[1 2] [1 1]
[4 1], [0 1]
)
"""
from sage.categories.groups import Groups
from sage.categories.homset import HomsetWithBase
HomsetWithBase.__init__(self, G, H, Groups(), G.base_ring())
def __init__(self, n, invfac, names="f"):
#invfac.sort()
n = Integer(n)
# if necessary, remove 1 from invfac first
if n != 1:
while True:
try:
i = invfac.index(1)
except ValueError:
break
else:
del invfac[i]
n = n - 1
if n < 0:
raise ValueError, "n (=%s) must be nonnegative." % n
self.__invariants = invfac
# *now* define ngens
self.__ngens = len(self.__invariants)
self._assign_names(names[:n])
from sage.categories.groups import Groups
group.Group.__init__(
self, category=Groups()) # should be CommutativeGroups()
def group_law(G):
r"""
Return a triple ``(identity, operation, inverse)`` that define the
operations on the group ``G``.
EXAMPLES::
sage: from sage.combinat.designs.difference_family import group_law
sage: group_law(Zmod(3))
(0, <built-in function add>, <built-in function neg>)
sage: group_law(SymmetricGroup(5))
((), <built-in function mul>, <built-in function inv>)
sage: group_law(VectorSpace(QQ,3))
((0, 0, 0), <built-in function add>, <built-in function neg>)
"""
import operator
from sage.categories.groups import Groups
from sage.categories.additive_groups import AdditiveGroups
if G in Groups(): # multiplicative groups
return (G.one(), operator.mul, operator.inv)
elif G in AdditiveGroups(): # additive groups
return (G.zero(), operator.add, operator.neg)
else:
raise ValueError("%s does not seem to be a group" % G)
def __init__(self, n):
"""
Initialize ``self``.
EXAMPLES::
sage: G = groups.matrix.BinaryDihedral(4)
sage: TestSuite(G).run()
"""
self._n = n
if n % 2 == 0:
R = CyclotomicField(2 * n)
zeta = R.gen()
i = R.gen()**(n // 2)
else:
R = CyclotomicField(4 * n)
zeta = R.gen()**2
i = R.gen()**n
MS = MatrixSpace(R, 2)
zero = R.zero()
gens = [MS([zeta, zero, zero, ~zeta]), MS([zero, i, i, zero])]
from sage.libs.gap.libgap import libgap
gap_gens = [libgap(matrix_gen) for matrix_gen in gens]
gap_group = libgap.Group(gap_gens)
FinitelyGeneratedMatrixGroup_gap.__init__(self,
ZZ(2),
R,
gap_group,
category=Groups().Finite())
def __init__(self, n, R, var='a', category=None):
"""
INPUT:
- ``n`` - the degree
- ``R`` - the base ring
- ``var`` - variable used to define field of
definition of actual matrices in this group.
"""
if not is_Ring(R):
raise TypeError, "R (=%s) must be a ring" % R
self._var = var
self.__n = integer.Integer(n)
if self.__n <= 0:
raise ValueError, "The degree must be at least 1"
self.__R = R
if self.base_ring().is_finite():
default_category = FiniteGroups()
else:
# Should we ask GAP whether the group is finite?
default_category = Groups()
if category is None:
category = default_category
else:
assert category.is_subcategory(default_category), \
"%s is not a subcategory of %s"%(category, default_category)
Parent.__init__(self, category=category)
def __init__(self, surface, base):
if not surface.is_finite():
raise ValueError("the method only work for finite surfaces")
self._s = surface
self._b = base
Group.__init__(self, category=Groups().Infinite())
def check_implemented_group(x):
if x in Groups():
return
error = "The semidirect product construction for groups is implemented only for multiplicative groups"
if x in CommutativeAdditiveGroups():
error = error + ". Please change the commutative additive group %s into a multiplicative group using the functor sage.groups.group_exp.GroupExp" % x
raise TypeError(error)
def __init__(self, vector_field_module):
r"""
See :class:`AutomorphismfieldGroup` for documentation and examples.
TESTS::
sage: M = Manifold(2, 'M')
sage: U = M.open_subset('U') ; V = M.open_subset('V')
sage: M.declare_union(U,V) # M is the union of U and V
sage: c_xy.<x,y> = U.chart() ; c_uv.<u,v> = V.chart()
sage: transf = c_xy.transition_map(c_uv, (x+y, x-y),
....: intersection_name='W', restrictions1= x>0,
....: restrictions2= u+v>0)
sage: inv = transf.inverse()
sage: from sage.manifolds.differentiable.automorphismfield_group \
....: import AutomorphismFieldGroup
sage: G = AutomorphismFieldGroup(M.vector_field_module()) ; G
General linear group of the Module X(M) of vector fields on the
2-dimensional differentiable manifold M
sage: TestSuite(G).run(skip='_test_elements')
``_test_elements`` does not pass due to the failure
of ``_test_pickling`` in
:class:`sage.manifolds.differentiable.tensorfield.TensorField`.
"""
if not isinstance(vector_field_module, VectorFieldModule):
raise TypeError("{} is not a module of vector fields".format(
vector_field_module))
Parent.__init__(self, category=Groups())
self._vmodule = vector_field_module
def cardinality(self):
"""
Returns the cardinality of ``self``, as per
:meth:`EnumeratedSets.ParentMethods.cardinality`.
This default implementation calls :meth:`.order` if
available, and otherwise resorts to
:meth:`._cardinality_from_iterator`. This is for backward
compatibility only. Finite groups should override this
method instead of :meth:`.order`.
EXAMPLES:
We need to use a finite group which uses this default
implementation of cardinality::
sage: G = groups.misc.SemimonomialTransformation(GF(5), 3); G
Semimonomial transformation group over Finite Field of size 5 of degree 3
sage: G.cardinality.__module__
'sage.categories.finite_groups'
sage: G.cardinality()
384
"""
try:
o = self.order
except AttributeError:
from sage.categories.groups import Groups
return super(Groups().Finite().parent_class, self).cardinality()
else:
return o()
def super_categories(self):
"""
EXAMPLES::
sage: CoxeterGroups().super_categories()
[Category of groups]
"""
return [Groups()]
def __init__(self, base_ring):
r"""
TESTS::
sage: from flatsurf.geometry.similarity import SimilarityGroup
sage: TestSuite(SimilarityGroup(QQ)).run()
sage: TestSuite(SimilarityGroup(AA)).run()
"""
self._ring = base_ring
Group.__init__(self, category=Groups().Infinite())
def super_categories(self):
"""
EXAMPLES::
sage: from sage.categories.lie_groups import LieGroups
sage: LieGroups(QQ).super_categories()
[Category of topological groups,
Category of smooth manifolds over Rational Field]
"""
return [Groups().Topological(), Manifolds(self.base()).Smooth()]
def super_categories(self):
"""
Return a list of the immediate super categories of ``self``.
EXAMPLES::
sage: PermutationGroups().super_categories()
[Category of groups]
"""
return [Groups()]
def super_categories(self):
r"""
Return the super categories of ``self``.
EXAMPLES::
sage: from sage.categories.complex_reflection_groups import ComplexReflectionGroups
sage: ComplexReflectionGroups().super_categories()
[Category of complex reflection or generalized coxeter groups]
"""
return [Groups().FinitelyGenerated()]
def super_categories(self):
r"""
Returns a list of the (immediate) super categories of ``self``.
EXAMPLES::
sage: FiniteGroups().super_categories()
[Category of groups, Category of finite monoids]
"""
return [Groups(), FiniteMonoids()]
def __init__(self, base_field):
r"""
TESTS::
sage: from flatsurf.geometry.similarity import SimilarityGroup
sage: TestSuite(SimilarityGroup(QQ)).run()
sage: TestSuite(SimilarityGroup(AA)).run()
"""
self._field = base_field
# The vector space of vectors
Group.__init__(self, category=Groups().Infinite())
def __init__(self):
r"""
Standard init routine.
EXAMPLES::
sage: G = Gamma1(7)
sage: G.category() # indirect doctest
Category of infinite groups
"""
Group.__init__(self, category=Groups().Infinite())
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, G):
r"""
EXAMPLES::
sage: EG = GroupExp()(QQ^2)
sage: TestSuite(EG).run(skip = "_test_elements")
"""
if G not in CommutativeAdditiveGroups():
raise TypeError("%s must be a commutative additive group" % G)
self._G = G
Parent.__init__(self, category=Groups())
def __init__(self, indices, prefix, category=None, **kwds):
"""
Initialize ``self``.
TESTS::
sage: G = Groups().Commutative().free(index_set=ZZ)
sage: TestSuite(G).run()
sage: G = Groups().Commutative().free(index_set='abc')
sage: TestSuite(G).run()
"""
category = Groups().or_subcategory(category)
IndexedGroup.__init__(self, indices, prefix, category, **kwds)
def __init__(self):
r"""
Initialize the :class:`GroupExp` functor.
EXAMPLES::
sage: F = GroupExp()
sage: F.domain()
Category of commutative additive groups
sage: F.codomain()
Category of groups
"""
Functor.__init__(self, CommutativeAdditiveGroups(), Groups())
def twisted_invariant_module(self, chi, G=None, **kwargs):
r"""
Create the isotypic component of the action of ``G`` on
``self`` with irreducible character given by ``chi``.
.. SEEALSO::
- :class:`~sage.modules.with_basis.invariant.FiniteDimensionalTwistedInvariantModule`
INPUT:
- ``chi`` -- a list/tuple of character values or an instance
of :class:`~sage.groups.class_function.ClassFunction_gap`
- ``G`` -- a finitely-generated semigroup (default: the semigroup
this is a representation of)
This also accepts the group to be the first argument to be the group.
OUTPUT:
- :class:`~sage.modules.with_basis.invariant.FiniteDimensionalTwistedInvariantModule`
EXAMPLES::
sage: G = SymmetricGroup(3)
sage: R = G.regular_representation(QQ)
sage: T = R.twisted_invariant_module([2,0,-1])
sage: T.basis()
Finite family {0: B[0], 1: B[1], 2: B[2], 3: B[3]}
sage: [T.lift(b) for b in T.basis()]
[() - (1,2,3), -(1,2,3) + (1,3,2), (2,3) - (1,2), -(1,2) + (1,3)]
We check the different inputs work
sage: R.twisted_invariant_module([2,0,-1], G) is T
True
sage: R.twisted_invariant_module(G, [2,0,-1]) is T
True
"""
from sage.categories.groups import Groups
if G is None:
G = self.semigroup()
elif chi in Groups():
G, chi = chi, G
side = kwargs.pop('side', self.side())
if side == "twosided":
side = "left"
return super().twisted_invariant_module(G, chi, side=side, **kwargs)
def _repr_(self):
"""
Return the string representation for ``self``.
EXAMPLES::
sage: from sage.monoids.automatic_semigroup import AutomaticSemigroup
sage: R = IntegerModRing(12)
sage: AutomaticSemigroup(Family({1: R(3), 2: R(5)}), one=R.one())
A submonoid of (Ring of integers modulo 12) with 2 generators
sage: AutomaticSemigroup(Family({1: R(3), 2: R(5)}))
A subsemigroup of (Ring of integers modulo 12) with 2 generators
sage: AutomaticSemigroup(Family({1: R(3), 2: R(5)}), mul=operator.add)
A semigroup with 2 generators
sage: AutomaticSemigroup(Family({1: R(3), 2: R(5)}), mul=operator.add, one=R.zero())
A semigroup with 2 generators
sage: S5 = SymmetricGroup(5); S5.rename("S5")
sage: AutomaticSemigroup(Family({1: S5((1,2))}), category=Groups().Finite().Subobjects())
A subgroup of (S5) with 1 generators
"""
categories = [Groups(), Monoids(), Semigroups()]
for category in categories:
if self in category:
typ = "A " + category._repr_object_names()[:-1]
for category in [Groups(), Monoids(), Semigroups()]:
if self.ambient() in category and self in category.Subobjects():
typ = "A sub" + category._repr_object_names()[:-1]
break
if self._mul is operator.mul:
of = " of (%s)" % self.ambient()
else:
of = ""
return "%s%s with %s generators" % (typ, of, len(self._generators))
