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 _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, 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 __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, 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 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, 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, 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 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, 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 __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 __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 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 __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 super_categories(self): """ EXAMPLES:: sage: CoxeterGroups().super_categories() [Category of groups] """ return [Groups()]
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 __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): """ 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, 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, 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): 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))
def __init__(self, matrices, matrix_space=None, category=None): if matrix_space is None: from sage.matrix.matrix_space import MatrixSpace ring = Sequence(matrices).universe().base_ring() matrix_space = MatrixSpace(ring, 2) self._generators = list(map(matrix_space, matrices)) for m in self._generators: m.set_immutable() self._matrix_space = matrix_space if category is None: from sage.categories.groups import Groups category = Groups() Parent.__init__(self, category=category, facade=matrix_space)
def __init__(self, G, H, twist=None, act_to_right=True, prefix0=None, prefix1=None, print_tuple=False, category=Groups()): r""" EXAMPLES:: sage: def twist(x,y): ....: return y sage: import __main__ sage: __main__.twist = twist sage: G = GroupSemidirectProduct(WeylGroup(['A',2],prefix="s"), WeylGroup(['A',3],prefix="t"),twist) sage: TestSuite(G).run() The ``__main__`` business is a trick to pass the picking test. """ self._act_to_right = act_to_right 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) check_implemented_group(G) check_implemented_group(H) if twist is None: self._twist = lambda g, h: h # use the trivial twist else: self._twist = twist self._prefix0 = prefix0 self._prefix1 = prefix1 self._print_tuple = print_tuple self._category = category CartesianProduct.__init__(self, (G, H), category=category)