def __classcall_private__(cls, crystals, facade=True, keepkey=False, category=None): """ Normalization of arguments; see :class:`UniqueRepresentation`. TESTS: We check that direct sum of crystals have unique representation:: sage: B = crystals.Tableaux(['A',2], shape=[2,1]) sage: C = crystals.Letters(['A',2]) sage: D1 = crystals.DirectSum([B, C]) sage: D2 = crystals.DirectSum((B, C)) sage: D1 is D2 True sage: D3 = crystals.DirectSum([B, C, C]) sage: D4 = crystals.DirectSum([D1, C]) sage: D3 is D4 True """ if not isinstance(facade, bool) or not isinstance(keepkey, bool): raise TypeError # Normalize the facade-keepkey by giving keepkey dominance facade = not keepkey # We expand out direct sums of crystals ret = [] for x in Family(crystals): if isinstance(x, DirectSumOfCrystals): ret += list(x.crystals) else: ret.append(x) category = Category.meet([Category.join(c.categories()) for c in ret]) return super(DirectSumOfCrystals, cls).__classcall__(cls, Family(ret), facade=facade, keepkey=keepkey, category=category)
def __init__(self, G): """ TESTS:: sage: S8 = SymmetricGroup(8) sage: TestSuite(GSets(S8)).run() """ Category.__init__(self) self.__G = G
def __init__(self, G): """ TESTS:: sage: S8 = SymmetricGroup(8) sage: TestSuite(GSets(S8)).run() """ Category.__init__(self, "G-sets") self.__G = G
def __init__(self): """ TESTS:: sage: C = Schemes() sage: C Category of Schemes sage: TestSuite(C).run() """ Category.__init__(self, "Schemes")
def __init__(self, left_base, right_base, name=None): """ EXAMPLES:: sage: C = Bimodules(QQ, ZZ) sage: TestSuite(C).run() """ Category.__init__(self, name) assert left_base in _Rings, "The left base must be a ring" assert right_base in _Rings, "The right base must be a ring" self._left_base_ring = left_base self._right_base_ring = right_base
def __init__(self, G = None): """ TESTS:: sage: S8 = SymmetricGroup(8) sage: C = Groupoid(S8) sage: TestSuite(C).run() """ Category.__init__(self) #, "Groupoid") if G is None: from sage.groups.perm_gps.permgroup_named import SymmetricGroup G = SymmetricGroup(8) self.__G = G
def __init__(self, G=None): """ TESTS:: sage: S8 = SymmetricGroup(8) sage: C = Groupoid(S8) sage: TestSuite(C).run() """ Category.__init__(self) #, "Groupoid") if G is None: from sage.groups.perm_gps.permgroup_named import SymmetricGroup G = SymmetricGroup(8) self.__G = G
def __init__(self, left_base, right_base, name=None): """ EXAMPLES:: sage: C = Bimodules(QQ, ZZ) sage: TestSuite(C).run() """ if not (left_base in Rings or (isinstance(left_base, Category) and left_base.is_subcategory(Rings()))): raise ValueError("the left base must be a ring or a subcategory of Rings()") if not (right_base in Rings or (isinstance(right_base, Category) and right_base.is_subcategory(Rings()))): raise ValueError("the right base must be a ring or a subcategory of Rings()") self._left_base_ring = left_base self._right_base_ring = right_base Category.__init__(self, name)
def __init__(self, crystals, **options): """ TESTS:: sage: C = crystals.Letters(['A',2]) sage: B = crystals.DirectSum([C,C], keepkey=True) sage: B Direct sum of the crystals Family (The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2]) sage: B.cartan_type() ['A', 2] sage: from sage.combinat.crystals.direct_sum import DirectSumOfCrystals sage: isinstance(B, DirectSumOfCrystals) True """ if 'keepkey' in options: keepkey = options['keepkey'] else: keepkey = False # facade = options['facade'] if keepkey: facade = False else: facade = True category = Category.meet( [Category.join(crystal.categories()) for crystal in crystals]) Parent.__init__(self, category=category) DisjointUnionEnumeratedSets.__init__(self, crystals, keepkey=keepkey, facade=facade) self.rename("Direct sum of the crystals %s" % (crystals, )) self._keepkey = keepkey self.crystals = crystals if len(crystals) == 0: raise ValueError("The direct sum is empty") else: assert (crystal.cartan_type() == crystals[0].cartan_type() for crystal in crystals) self._cartan_type = crystals[0].cartan_type() if keepkey: self.module_generators = [ self(tuple([i, b])) for i in range(len(crystals)) for b in crystals[i].module_generators ] else: self.module_generators = sum( (list(B.module_generators) for B in crystals), [])
def __init__(self, cartan_type): """ Construct this Coxeter group as a Sage permutation group, by fetching the permutation representation of the generators from Chevie's database. TESTS:: sage: from sage.combinat.root_system.coxeter_group import CoxeterGroupAsPermutationGroup sage: W = CoxeterGroupAsPermutationGroup(CartanType(["H",3])) # optional - chevie sage: TestSuite(W).run() # optional - chevie """ assert cartan_type.is_finite() assert cartan_type.is_irreducible() self._semi_simple_rank = cartan_type.n from sage.interfaces.gap3 import gap3 gap3._start() gap3.load_package("chevie") self._gap_group = gap3('CoxeterGroup("%s",%s)' % (cartan_type.letter, cartan_type.n)) # Following #9032, x.N is an alias for x.numerical_approx in every Sage object ... N = self._gap_group.__getattr__("N").sage() generators = [str(x) for x in self._gap_group.generators] self._is_positive_root = [None] + [True] * N + [False] * N PermutationGroup_generic.__init__(self, gens=generators, category=Category.join([ FinitePermutationGroups(), FiniteCoxeterGroups() ]))
def default_super_categories(cls, category, *args): """ Returns the default super categories of ``...`` INPUT: - ``category`` -- a category OUTPUT: a join category This implements the property that an induced subcategory is a subcategory. EXAMPLES: A subquotient of a monoid is a monoid, and a subquotient of semigroup:: sage: Monoids().Subquotients().super_categories() [Category of monoids, Category of subquotients of semigroups] TESTS:: sage: C = Monoids().Subquotients() sage: C.__class__.default_super_categories(C.base_category(), *C._args) Join of Category of monoids and Category of subquotients of semigroups """ return Category.join([category, super(RegressiveCovariantConstructionCategory, cls).default_super_categories(category, *args)])
def __init__(self, crystals, **options): """ TESTS:: sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals sage: C = crystals.Letters(['A',2]) sage: T = crystals.TensorProduct(C,C) sage: isinstance(T, FullTensorProductOfCrystals) True sage: TestSuite(T).run() """ category = Category.meet([crystal.category() for crystal in crystals]) category = category.TensorProducts() if any(c in Sets().Infinite() for c in crystals): category = category.Infinite() Parent.__init__(self, category=category) self.crystals = crystals if 'cartan_type' in options: self._cartan_type = CartanType(options['cartan_type']) else: if not crystals: raise ValueError( "you need to specify the Cartan type if the tensor product list is empty" ) else: self._cartan_type = crystals[0].cartan_type() self.cartesian_product = cartesian_product(self.crystals) self.module_generators = self
def category_from_categories(self, categories): """ Return the category of `F(A,B,...)` for `A,B,...` parents in the given categories. INPUT: - ``self``: a functor `F` - ``categories``: a non empty tuple of categories EXAMPLES:: sage: Cat1 = Rings() sage: Cat2 = Groups() sage: cartesian_product.category_from_categories((Cat1, Cat1, Cat1)) Join of Category of rings and ... and Category of Cartesian products of semigroups and ... and Category of Cartesian products of commutative additive groups sage: cartesian_product.category_from_categories((Cat1, Cat2)) Join of Category of monoids and Category of Cartesian products of semigroups and Category of Cartesian products of unital magmas """ assert(len(categories) > 0) return self.category_from_category(Category.meet(categories))
def __init__(self, sets, category, order=None, **kwargs): r""" See :class:`CartesianProductPoset` for details. TESTS:: sage: P = Poset((srange(3), lambda left, right: left <= right)) sage: C = cartesian_product((P, P), order='notexisting') Traceback (most recent call last): ... ValueError: No order 'notexisting' known. sage: C = cartesian_product((P, P), category=(Groups(),)) sage: C.category() Join of Category of groups and Category of posets """ if order is None: self._le_ = self.le_product elif isinstance(order, str): try: self._le_ = getattr(self, 'le_' + order) except AttributeError: raise ValueError("No order '%s' known." % (order,)) else: self._le_ = order from sage.categories.category import Category from sage.categories.posets import Posets if not isinstance(category, tuple): category = (category,) category = Category.join(category + (Posets(),)) super(CartesianProductPoset, self).__init__( sets, category, **kwargs)
def __init__(self, crystals, **options): """ TESTS:: sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals sage: C = crystals.Letters(['A',2]) sage: T = crystals.TensorProduct(C,C) sage: isinstance(T, FullTensorProductOfCrystals) True sage: TestSuite(T).run() """ category = Category.meet([crystal.category() for crystal in crystals]) category = category.TensorProducts() if any(c in Sets().Infinite() for c in crystals): category = category.Infinite() Parent.__init__(self, category=category) self.crystals = crystals if 'cartan_type' in options: self._cartan_type = CartanType(options['cartan_type']) else: if not crystals: raise ValueError("you need to specify the Cartan type if the tensor product list is empty") else: self._cartan_type = crystals[0].cartan_type() self.cartesian_product = cartesian_product(self.crystals) self.module_generators = self
def __init__(self, sets, category, order=None, **kwargs): r""" See :class:`CartesianProductPoset` for details. TESTS:: sage: P = Poset((srange(3), lambda left, right: left <= right)) sage: C = cartesian_product((P, P), order='notexisting') Traceback (most recent call last): ... ValueError: No order 'notexisting' known. sage: C = cartesian_product((P, P), category=(Groups(),)) sage: C.category() Join of Category of groups and Category of posets """ if order is None: self._le_ = self.le_product elif isinstance(order, str): try: self._le_ = getattr(self, 'le_' + order) except AttributeError: raise ValueError("No order '%s' known." % (order, )) else: self._le_ = order from sage.categories.category import Category from sage.categories.posets import Posets if not isinstance(category, tuple): category = (category, ) category = Category.join(category + (Posets(), )) super(CartesianProductPoset, self).__init__(sets, category, **kwargs)
def default_super_categories(cls, category, *args): """ Return the default super categories of `F_{Cat}(A,B,...)` for `A,B,...` parents in `Cat`. INPUT: - ``cls`` -- the category class for the functor `F` - ``category`` -- a category `Cat` - ``*args`` -- further arguments for the functor OUTPUT: A join category. This implements the property that an induced subcategory is a subcategory. EXAMPLES: A subquotient of a monoid is a monoid, and a subquotient of semigroup:: sage: Monoids().Subquotients().super_categories() [Category of monoids, Category of subquotients of semigroups] TESTS:: sage: C = Monoids().Subquotients() sage: C.__class__.default_super_categories(C.base_category(), *C._args) Category of unital subquotients of semigroups """ return Category.join([category, super(RegressiveCovariantConstructionCategory, cls).default_super_categories(category, *args)])
def __init__(self, cartan_type): """ Construct this Coxeter group as a Sage permutation group, by fetching the permutation representation of the generators from Chevie's database. TESTS:: sage: from sage.combinat.root_system.coxeter_group import CoxeterGroupAsPermutationGroup sage: W = CoxeterGroupAsPermutationGroup(CartanType(["H",3])) # optional - chevie sage: TestSuite(W).run() # optional - chevie """ assert cartan_type.is_finite() assert cartan_type.is_irreducible() self._semi_simple_rank = cartan_type.n from sage.interfaces.gap3 import gap3 gap3._start() gap3.load_package("chevie") self._gap_group = gap3('CoxeterGroup("%s",%s)'%(cartan_type.letter,cartan_type.n)) # Following #9032, x.N is an alias for x.numerical_approx in every Sage object ... N = self._gap_group.__getattr__("N").sage() generators = [str(x) for x in self._gap_group.generators] self._is_positive_root = [None] + [ True ] * N + [False]*N PermutationGroup_generic.__init__(self, gens = generators, category = Category.join([FinitePermutationGroups(), FiniteCoxeterGroups()]))
def __init__(self, crystals, **options): """ TESTS:: sage: from sage.combinat.crystals.tensor_product import FullTensorProductOfCrystals sage: C = CrystalOfLetters(['A',2]) sage: T = TensorProductOfCrystals(C,C) sage: isinstance(T, FullTensorProductOfCrystals) True sage: TestSuite(T).run() """ crystals = list(crystals) category = Category.meet([crystal.category() for crystal in crystals]) Parent.__init__(self, category = category) self.rename("Full tensor product of the crystals %s"%(crystals,)) self.crystals = crystals if options.has_key('cartan_type'): self._cartan_type = CartanType(options['cartan_type']) else: if len(crystals) == 0: raise ValueError, "you need to specify the Cartan type if the tensor product list is empty" else: self._cartan_type = crystals[0].cartan_type() self.cartesian_product = CartesianProduct(*self.crystals) self.module_generators = self
def default_super_categories(cls, category, *args): """ Returns the default super categories of `F_{Cat}(A,B,C)` for `A,B,C` parents in `Cat`. INPUT: - ``cls`` -- the category class for the functor `F` - ``category`` -- a category `Cat` - ``*args`` -- further arguments for the functor OUTPUT: a (join) category The default implementation is to return the join of the categories of `F(A,B,C)` for `A,B,C` in turn in each of the super categories of ``category``. This is implemented as a class method, in order to be able to reconstruct the functorial category associated to each of the super categories of ``category``. EXAMPLES: Bialgebras are both algebras and coalgebras:: sage: Bialgebras(QQ).super_categories() [Category of algebras over Rational Field, Category of coalgebras over Rational Field] Hence tensor products of bialgebras are tensor products of algebras and tensor products of coalgebras:: sage: Bialgebras(QQ).TensorProducts().super_categories() [Category of tensor products of algebras over Rational Field, Category of tensor products of coalgebras over Rational Field] Here is how :meth:`default_super_categories` was called internally:: sage: sage.categories.tensor.TensorProductsCategory.default_super_categories(Bialgebras(QQ)) Join of Category of tensor products of algebras over Rational Field and Category of tensor products of coalgebras over Rational Field We now show a similar example, with the ``Algebra`` functor which takes a parameter `\QQ`:: sage: FiniteMonoids().super_categories() [Category of finite semigroups, Category of monoids] sage: FiniteMonoids().Algebras(QQ).super_categories() [Category of semigroup algebras over Rational Field] Note that neither the category of *finite* semigroup algebras nor that of monoid algebras appear in the result; this is because there is currently nothing specific implemented about them. Here is how :meth:`default_super_categories` was called internally:: sage: sage.categories.algebra_functor.AlgebrasCategory.default_super_categories(FiniteMonoids(), QQ) Category of monoid algebras over Rational Field """ return Category.join([ getattr(cat, cls._functor_category)(*args) for cat in category._super_categories ])
def _repr_object_names(self): """ EXAMPLES:: sage: Semigroups().Subquotients() # indirect doctest Category of subquotients of semigroups """ return "%s of %s"%(Category._repr_object_names(self), self.base_category()._repr_object_names())
def __init__(self, left_base, right_base, name=None): """ EXAMPLES:: sage: C = Bimodules(QQ, ZZ) sage: TestSuite(C).run() """ if not ( left_base in Rings() or (isinstance(left_base, Category) and left_base.is_subcategory(Rings())) ): raise ValueError("the left base must be a ring or a subcategory of Rings()") if not ( right_base in Rings() or (isinstance(right_base, Category) and right_base.is_subcategory(Rings())) ): raise ValueError("the right base must be a ring or a subcategory of Rings()") self._left_base_ring = left_base self._right_base_ring = right_base Category.__init__(self, name)
def _latex_(self): """ EXAMPLES:: sage: print Bimodules(QQ, ZZ)._latex_() {\mathbf{Bimodules}}_{\Bold{Q}}_{\Bold{Z}} """ from sage.misc.latex import latex return "{%s}_{%s}_{%s}"%(Category._latex_(self), latex(self._left_base_ring), latex(self._right_base_ring))
def default_super_categories(cls, category, *args): """ Returns the default super categories of `F_{Cat}(A,B,C)` for `A,B,C` parents in `Cat`. INPUT: - ``cls`` -- the category class for the functor `F` - ``category`` -- a category `Cat` - ``*args`` -- further arguments for the functor OUTPUT: a (join) category The default implementation is to return the join of the categories of `F(A,B,C)` for `A,B,C` in turn in each of the super categories of ``category``. This is implemented as a class method, in order to be able to reconstruct the functorial category associated to each of the super categories of ``category``. EXAMPLES: Bialgebras are both algebras and coalgebras:: sage: Bialgebras(QQ).super_categories() [Category of algebras over Rational Field, Category of coalgebras over Rational Field] Hence tensor products of bialgebras are tensor products of algebras and tensor products of coalgebras:: sage: Bialgebras(QQ).TensorProducts().super_categories() [Category of tensor products of algebras over Rational Field, Category of tensor products of coalgebras over Rational Field] Here is how :meth:`default_super_categories` was called internally:: sage: sage.categories.tensor.TensorProductsCategory.default_super_categories(Bialgebras(QQ)) Join of Category of tensor products of algebras over Rational Field and Category of tensor products of coalgebras over Rational Field We now show a similar example, with the ``Algebra`` functor which takes a parameter `\QQ`:: sage: FiniteMonoids().super_categories() [Category of finite semigroups, Category of monoids] sage: FiniteMonoids().Algebras(QQ).super_categories() [Category of semigroup algebras over Rational Field] Note that neither the category of *finite* semigroup algebras nor that of monoid algebras appear in the result; this is because there is currently nothing specific implemented about them. Here is how :meth:`default_super_categories` was called internally:: sage: sage.categories.algebra_functor.AlgebrasCategory.default_super_categories(FiniteMonoids(), QQ) Category of monoid algebras over Rational Field """ return Category.join([getattr(cat, cls._functor_category)(*args) for cat in category._super_categories])
def __classcall_private__(cls, crystals, facade=True, keepkey=False, category=None): """ Normalization of arguments; see :class:`UniqueRepresentation`. TESTS: We check that direct sum of crystals have unique representation:: sage: B = crystals.Tableaux(['A',2], shape=[2,1]) sage: C = crystals.Letters(['A',2]) sage: D1 = crystals.DirectSum([B, C]) sage: D2 = crystals.DirectSum((B, C)) sage: D1 is D2 True sage: D3 = crystals.DirectSum([B, C, C]) sage: D4 = crystals.DirectSum([D1, C]) sage: D3 is D4 True """ if not isinstance(facade, bool) or not isinstance(keepkey, bool): raise TypeError # Normalize the facade-keepkey by giving keepkey dominance if keepkey: facade = False else: facade = True # We expand out direct sums of crystals ret = [] for x in Family(crystals): if isinstance(x, DirectSumOfCrystals): ret += list(x.crystals) else: ret.append(x) category = Category.meet([Category.join(c.categories()) for c in ret]) return super(DirectSumOfCrystals, cls).__classcall__(cls, Family(ret), facade=facade, keepkey=keepkey, category=category)
def __init__(self, order, cache=None, category=None): """ Create with the command ``IntegerModRing(order)``. TESTS:: sage: FF = IntegerModRing(29) sage: TestSuite(FF).run() sage: F19 = IntegerModRing(19, category = Fields()) sage: TestSuite(F19).run() sage: F23 = IntegerModRing(23) sage: F23 in Fields() True sage: TestSuite(F23).run() sage: Z16 = IntegerModRing(16) sage: TestSuite(Z16).run() sage: R = Integers(100000) sage: TestSuite(R).run() # long time (17s on sage.math, 2011) """ order = ZZ(order) if order <= 0: raise ZeroDivisionError("order must be positive") self.__order = order self._pyx_order = integer_mod.NativeIntStruct(order) if category is None: from sage.categories.commutative_rings import CommutativeRings from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets from sage.categories.category import Category category = Category.join( [CommutativeRings(), FiniteEnumeratedSets()]) # category = default_category # If the category is given then we trust that is it right. # Give the generator a 'name' to make quotients work. The # name 'x' is used because it's also used for the ring of # integers: see the __init__ method for IntegerRing_class in # sage/rings/integer_ring.pyx. quotient_ring.QuotientRing_generic.__init__(self, ZZ, ZZ.ideal(order), names=('x', ), category=category) # Calling ParentWithGens is not needed, the job is done in # the quotient ring initialisation. #ParentWithGens.__init__(self, self, category = category) # We want that the ring is its own base ring. self._base = self if cache is None: cache = order < 500 if cache: self._precompute_table() self._zero_element = integer_mod.IntegerMod(self, 0) self._one_element = integer_mod.IntegerMod(self, 1)
def __init__(self, A, gens=None): """ A subring of the endomorphism ring. INPUT: - ``A`` - an abelian variety - ``gens`` - (default: None); optional; if given should be a tuple of the generators as matrices EXAMPLES:: sage: J0(23).endomorphism_ring() Endomorphism ring of Abelian variety J0(23) of dimension 2 sage: sage.modular.abvar.homspace.EndomorphismSubring(J0(25)) Endomorphism ring of Abelian variety J0(25) of dimension 0 sage: E = J0(11).endomorphism_ring() sage: type(E) <class 'sage.modular.abvar.homspace.EndomorphismSubring_with_category'> sage: E.category() Join of Category of hom sets in Category of sets and Category of rings sage: E.homset_category() Category of modular abelian varieties over Rational Field sage: TestSuite(E).run(skip=["_test_elements"]) TESTS: The following tests against a problem on 32 bit machines that occured while working on trac ticket #9944:: sage: sage.modular.abvar.homspace.EndomorphismSubring(J1(12345)) Endomorphism ring of Abelian variety J1(12345) of dimension 5405473 """ self._J = A.ambient_variety() self._A = A # Initialise self with the correct category. # TODO: a category should be able to specify the appropriate # category for its endomorphism sets # We need to initialise it as a ring first homset_cat = A.category() cat = Category.join([homset_cat.hom_category(),Rings()]) Ring.__init__(self, A.base_ring()) Homspace.__init__(self, A, A, cat=homset_cat) self._refine_category_(Rings()) if gens is None: self._gens = None else: self._gens = tuple([ self._get_matrix(g) for g in gens ]) self._is_full_ring = gens is None
def _latex_(self): """ EXAMPLES:: sage: print Bimodules(QQ, ZZ)._latex_() {\mathbf{Bimodules}}_{\Bold{Q}}_{\Bold{Z}} """ from sage.misc.latex import latex return "{%s}_{%s}_{%s}" % (Category._latex_(self), latex(self._left_base_ring), latex(self._right_base_ring))
def __init__(self, A, gens=None): """ A subring of the endomorphism ring. INPUT: - ``A`` - an abelian variety - ``gens`` - (default: None); optional; if given should be a tuple of the generators as matrices EXAMPLES:: sage: J0(23).endomorphism_ring() Endomorphism ring of Abelian variety J0(23) of dimension 2 sage: sage.modular.abvar.homspace.EndomorphismSubring(J0(25)) Endomorphism ring of Abelian variety J0(25) of dimension 0 sage: E = J0(11).endomorphism_ring() sage: type(E) <class 'sage.modular.abvar.homspace.EndomorphismSubring_with_category'> sage: E.category() Join of Category of hom sets in Category of sets and Category of rings sage: E.homset_category() Category of modular abelian varieties over Rational Field sage: TestSuite(E).run(skip=["_test_elements"]) TESTS: The following tests against a problem on 32 bit machines that occured while working on trac ticket #9944:: sage: sage.modular.abvar.homspace.EndomorphismSubring(J1(12345)) Endomorphism ring of Abelian variety J1(12345) of dimension 5405473 """ self._J = A.ambient_variety() self._A = A # Initialise self with the correct category. # TODO: a category should be able to specify the appropriate # category for its endomorphism sets # We need to initialise it as a ring first homset_cat = A.category() cat = Category.join([homset_cat.hom_category(), Rings()]) Ring.__init__(self, A.base_ring()) Homspace.__init__(self, A, A, cat=homset_cat) self._refine_category_(Rings()) if gens is None: self._gens = None else: self._gens = tuple([self._get_matrix(g) for g in gens]) self._is_full_ring = gens is None
def __init__(self, crystals, **options): """ TESTS:: sage: C = crystals.Letters(['A',2]) sage: B = crystals.DirectSum([C,C], keepkey=True) sage: B Direct sum of the crystals Family (The crystal of letters for type ['A', 2], The crystal of letters for type ['A', 2]) sage: B.cartan_type() ['A', 2] sage: from sage.combinat.crystals.direct_sum import DirectSumOfCrystals sage: isinstance(B, DirectSumOfCrystals) True """ if "keepkey" in options: keepkey = options["keepkey"] else: keepkey = False # facade = options['facade'] if keepkey: facade = False else: facade = True category = Category.meet([Category.join(crystal.categories()) for crystal in crystals]) Parent.__init__(self, category=category) DisjointUnionEnumeratedSets.__init__(self, crystals, keepkey=keepkey, facade=facade) self.rename("Direct sum of the crystals %s" % (crystals,)) self._keepkey = keepkey self.crystals = crystals if len(crystals) == 0: raise ValueError("The direct sum is empty") else: assert (crystal.cartan_type() == crystals[0].cartan_type() for crystal in crystals) self._cartan_type = crystals[0].cartan_type() if keepkey: self.module_generators = [ self(tuple([i, b])) for i in range(len(crystals)) for b in crystals[i].module_generators ] else: self.module_generators = sum((list(B.module_generators) for B in crystals), [])
def __init__(self, category, *args): """ TESTS:: sage: from sage.categories.covariant_functorial_construction import CovariantConstructionCategory sage: class FooBars(CovariantConstructionCategory): ... pass sage: C = FooBars(ModulesWithBasis(QQ)) sage: C Category of foo bars of modules with basis over Rational Field sage: C.base_category() Category of modules with basis over Rational Field sage: latex(C) \mathbf{FooBars}(\mathbf{ModulesWithBasis}_{\Bold{Q}}) sage: import __main__; __main__.FooBars = FooBars # Fake FooBars being defined in a python module sage: TestSuite(C).run() """ assert isinstance(category, Category) Category.__init__(self) self._base_category = category self._args = args
def default_super_categories(cls, category): """ Returns the default super categories of ``category.IsomorphicObjects()`` Mathematical meaning: if `A` is the image of `B` by an isomorphism in the category `C`, then `A` is both a subobject of `B` and a quotient of `B` in the category `C`. INPUT: - ``cls`` -- the class ``IsomorphicObjectsCategory`` - ``category`` -- a category `Cat` OUTPUT: a (join) category In practice, this returns ``category.Subobjects()`` and ``category.Quotients()``, joined together with the result of the method :meth:`RegressiveCovariantConstructionCategory.default_super_categories() <sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory.default_super_categories>` (that is the join of ``category`` and ``cat.IsomorphicObjects()`` for each ``cat`` in the super categories of ``category``). EXAMPLES: Consider ``category=Groups()``, which has ``cat=Monoids()`` as super category. Then, the image of a group `G'` by a group isomorphism is simultaneously a subgroup of `G`, a subquotient of `G`, a group by itself, and the image of `G` by a monoid isomorphism:: sage: Groups().IsomorphicObjects().super_categories() [Category of groups, Category of subquotients of monoids, Category of quotients of semigroups, Category of isomorphic objects of sets] Mind the last item above: there is indeed currently nothing implemented about isomorphic objects of monoids. This resulted from the following call:: sage: sage.categories.isomorphic_objects.IsomorphicObjectsCategory.default_super_categories(Groups()) Join of Category of groups and Category of subquotients of monoids and Category of quotients of semigroups and Category of isomorphic objects of sets """ return Category.join([ category.Subobjects(), category.Quotients(), super(IsomorphicObjectsCategory, cls).default_super_categories(category) ])
def _latex_(self): """ Return a latex representation of ``self``. EXAMPLES:: sage: print Bimodules(QQ, ZZ)._latex_() {\mathbf{Bimodules}}_{\Bold{Q}, \Bold{Z}} """ from sage.misc.latex import latex return "{{{0}}}_{{{1}, {2}}}".format(Category._latex_(self), latex(self._left_base_ring), latex(self._right_base_ring))
def _latex_(self): """ Return a latex representation of ``self``. EXAMPLES:: sage: print(Bimodules(QQ, ZZ)._latex_()) {\mathbf{Bimodules}}_{\Bold{Q}, \Bold{Z}} """ from sage.misc.latex import latex return "{{{0}}}_{{{1}, {2}}}".format(Category._latex_(self), latex(self._left_base_ring), latex(self._right_base_ring))
def super_categories(self): """ Returns the super categories of a construction category EXAMPLES:: sage: Sets().Subquotients().super_categories() [Category of sets] sage: Semigroups().Quotients().super_categories() [Category of subquotients of semigroups, Category of quotients of sets] """ return Category.join(self.extra_super_categories() + [self.__class__.default_super_categories(self.base_category(), *self._args)], as_list = True)
def __init__(self, order, cache=None, category=None): """ Create with the command ``IntegerModRing(order)``. TESTS:: sage: FF = IntegerModRing(29) sage: TestSuite(FF).run() sage: F19 = IntegerModRing(19, category = Fields()) sage: TestSuite(F19).run() sage: F23 = IntegerModRing(23) sage: F23 in Fields() True sage: TestSuite(F23).run() sage: Z16 = IntegerModRing(16) sage: TestSuite(Z16).run() sage: R = Integers(100000) sage: TestSuite(R).run() # long time (17s on sage.math, 2011) """ order = ZZ(order) if order <= 0: raise ZeroDivisionError("order must be positive") self.__order = order self._pyx_order = integer_mod.NativeIntStruct(order) if category is None: from sage.categories.commutative_rings import CommutativeRings from sage.categories.finite_enumerated_sets import FiniteEnumeratedSets from sage.categories.category import Category category = Category.join([CommutativeRings(), FiniteEnumeratedSets()]) # category = default_category # If the category is given then we trust that is it right. # Give the generator a 'name' to make quotients work. The # name 'x' is used because it's also used for the ring of # integers: see the __init__ method for IntegerRing_class in # sage/rings/integer_ring.pyx. quotient_ring.QuotientRing_generic.__init__(self, ZZ, ZZ.ideal(order), names=('x',), category=category) # Calling ParentWithGens is not needed, the job is done in # the quotient ring initialisation. #ParentWithGens.__init__(self, self, category = category) # We want that the ring is its own base ring. self._base = self if cache is None: cache = order < 500 if cache: self._precompute_table() self._zero_element = integer_mod.IntegerMod(self, 0) self._one_element = integer_mod.IntegerMod(self, 1)
def default_super_categories(cls, category): """ Returns the default super categories of ``category.IsomorphicObjects()`` Mathematical meaning: if `A` is the image of `B` by an isomorphism in the category `C`, then `A` is both a subobject of `B` and a quotient of `B` in the category `C`. INPUT: - ``cls`` -- the class ``IsomorphicObjectsCategory`` - ``category`` -- a category `Cat` OUTPUT: a (join) category In practice, this returns ``category.Subobjects()`` and ``category.Quotients()``, joined together with the result of the method :meth:`RegressiveCovariantConstructionCategory.default_super_categories() <sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory.default_super_categories>` (that is the join of ``category`` and ``cat.IsomorphicObjects()`` for each ``cat`` in the super categories of ``category``). EXAMPLES: Consider ``category=Groups()``, which has ``cat=Monoids()`` as super category. Then, the image of a group `G'` by a group isomorphism is simultaneously a subgroup of `G`, a subquotient of `G`, a group by itself, and the image of `G` by a monoid isomorphism:: sage: Groups().IsomorphicObjects().super_categories() [Category of groups, Category of subquotients of monoids, Category of quotients of semigroups, Category of isomorphic objects of sets] Mind the last item above: there is indeed currently nothing implemented about isomorphic objects of monoids. This resulted from the following call:: sage: sage.categories.isomorphic_objects.IsomorphicObjectsCategory.default_super_categories(Groups()) Join of Category of groups and Category of subquotients of monoids and Category of quotients of semigroups and Category of isomorphic objects of sets """ return Category.join([category.Subobjects(), category.Quotients(), super(IsomorphicObjectsCategory, cls).default_super_categories(category)])
def __init__(self, crystals, generators, cartan_type): """ EXAMPLES:: sage: C = crystals.Letters(['A',2]) sage: T = crystals.TensorProduct(C,C,C,generators=[[C(2),C(1),C(1)]]) sage: TestSuite(T).run() """ assert isinstance(crystals, tuple) assert isinstance(generators, tuple) category = Category.meet([crystal.category() for crystal in crystals]) Parent.__init__(self, category=category) self.crystals = crystals self._cartan_type = cartan_type self.module_generators = tuple([self(*x) for x in generators])
def __init__(self, crystals, generators, cartan_type): """ EXAMPLES:: sage: C = crystals.Letters(['A',2]) sage: T = crystals.TensorProduct(C,C,C,generators=[[C(2),C(1),C(1)]]) sage: TestSuite(T).run() """ assert isinstance(crystals, tuple) assert isinstance(generators, tuple) category = Category.meet([crystal.category() for crystal in crystals]) Parent.__init__(self, category = category) self.crystals = crystals self._cartan_type = cartan_type self.module_generators = tuple([self(*x) for x in generators])
def _test_homsets_category(self, **options): r""" Run generic tests on this homsets category .. SEEALSO:: :class:`TestSuite`. EXAMPLES:: sage: Sets().Homsets()._test_homsets_category() """ # TODO: remove if unneeded #from sage.categories.objects import Objects #from sage.categories.sets_cat import Sets tester = self._tester(**options) tester.assert_(self.is_subcategory(Category.join(self.base_category().structure()).Homsets()))
def default_super_categories_yacop(cls, category, *args): """ TESTS:: sage: import yacop sage: # an earlier version of this hack broke the MRO for quasi symmetric functions: sage: QuasiSymmetricFunctions(GF(3)) Quasisymmetric functions over the Finite Field of size 3 """ sageresult = Category.join([ category, super(RegressiveCovariantConstructionCategory, cls).default_super_categories(category, *args) ]) ans = sageresult if isinstance(ans, sage.categories.category.JoinCategory): j = [ cat for cat in sageresult.super_categories() if not hasattr(cat, "yacop_no_default_inheritance") ] ans = Category.join(j) return ans
def _test_homsets_category(self, **options): r""" Run generic tests on this homsets category .. SEEALSO:: :class:`TestSuite`. EXAMPLES:: sage: Sets().Homsets()._test_homsets_category() """ # TODO: remove if unneeded #from sage.categories.objects import Objects #from sage.categories.sets_cat import Sets tester = self._tester(**options) tester.assertTrue(self.is_subcategory(Category.join(self.base_category().structure()).Homsets())) tester.assertTrue(self.is_subcategory(Homsets()))
def default_super_categories(cls, category): """ Return the default super categories of ``category.Homsets()`` INPUT: - ``cls`` -- the category class for the functor `F` - ``category`` -- a category `Cat` OUTPUT: a category .. TODO:: adapt everything below The default implementation is to return the join of the categories of `F(A,B,...)` for `A,B,...` in turn in each of the super categories of ``category``. This is implemented as a class method, in order to be able to reconstruct the functorial category associated to each of the super categories of ``category``. EXAMPLES:: sage: AdditiveMagmas().Homsets().super_categories() [Category of additive magmas] sage: AdditiveMagmas().AdditiveUnital().Homsets().super_categories() [Category of additive unital additive magmas] For now nothing specific is implemented for homsets of additive groups compared to homsets of monoids:: sage: from sage.categories.additive_groups import AdditiveGroups sage: AdditiveGroups().Homsets() Category of homsets of additive monoids Similarly for rings; so a ring homset is a homset of unital magmas and additive magmas:: sage: Rings().Homsets() Category of homsets of unital magmas and additive unital additive magmas """ return Category.join([getattr(cat, cls._functor_category)() for cat in category.full_super_categories()])
def super_categories(self): """ EXAMPLES:: sage: from sage.categories.magmatic_algebras import MagmaticAlgebras sage: MagmaticAlgebras(ZZ).super_categories() [Category of additive commutative additive associative additive unital distributive magmas and additive magmas, Category of modules over Integer Ring] sage: from sage.categories.additive_semigroups import AdditiveSemigroups sage: MagmaticAlgebras(ZZ).is_subcategory((AdditiveSemigroups() & Magmas()).Distributive()) True """ R = self.base_ring() # Note: The specifications impose `self` to be a subcategory # of the join of its super categories. Here the join is non # trivial, since some of the axioms of Modules (like the # commutativity of '+') are added to the left hand side. We # might want the infrastructure to take this join for us. return Category.join([(Magmas() & AdditiveMagmas()).Distributive(), Modules(R)], as_list=True)
def default_super_categories(cls, category): """ Return the default super categories of ``category.Metric()``. Mathematical meaning: if `A` is a metric space in the category `C`, then `A` is also a topological space. INPUT: - ``cls`` -- the class ``MetricSpaces`` - ``category`` -- a category `Cat` OUTPUT: A (join) category In practice, this returns ``category.Metric()``, joined together with the result of the method :meth:`RegressiveCovariantConstructionCategory.default_super_categories() <sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory.default_super_categories>` (that is the join of ``category`` and ``cat.Metric()`` for each ``cat`` in the super categories of ``category``). EXAMPLES: Consider ``category=Groups()``. Then, a group `G` with a metric is simultaneously a topological group by itself, and a metric space:: sage: Groups().Metric().super_categories() [Category of topological groups, Category of metric spaces] This resulted from the following call:: sage: sage.categories.metric_spaces.MetricSpacesCategory.default_super_categories(Groups()) Join of Category of topological groups and Category of metric spaces """ return Category.join([ category.Topological(), super(MetricSpacesCategory, cls).default_super_categories(category) ])
def category_from_categories(self, categories): """ Returns the category of `F(A,B,C)` for `A,B,C` parents in the given categories INPUT: - ``self``: a functor `F` - ``categories``: a non empty tuple of categories EXAMPLES:: sage: Cat1 = Rings() sage: Cat2 = Groups() sage: cartesian_product.category_from_categories((Cat1, Cat1, Cat1)) Category of Cartesian products of monoids sage: cartesian_product.category_from_categories((Cat1, Cat2)) Category of Cartesian products of monoids """ assert(len(categories) > 0) return self.category_from_category(Category.meet(categories))
def default_super_categories(cls, category, *args): r""" Return the default super categories of ``category.Graded()``. Mathematical meaning: every graded object (module, algebra, etc.) is a filtered object with the (implicit) filtration defined by `F_i = \bigoplus_{j \leq i} G_j`. INPUT: - ``cls`` -- the class ``GradedModulesCategory`` - ``category`` -- a category OUTPUT: a (join) category In practice, this returns ``category.Filtered()``, joined together with the result of the method :meth:`RegressiveCovariantConstructionCategory.default_super_categories() <sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory.default_super_categories>` (that is the join of ``category.Filtered()`` and ``cat`` for each ``cat`` in the super categories of ``category``). EXAMPLES: Consider ``category=Algebras()``, which has ``cat=Modules()`` as super category. Then, a grading of an algebra `G` is also a filtration of `G`:: sage: Algebras(QQ).Graded().super_categories() [Category of filtered algebras over Rational Field, Category of graded modules over Rational Field] This resulted from the following call:: sage: sage.categories.graded_modules.GradedModulesCategory.default_super_categories(Algebras(QQ)) Join of Category of filtered algebras over Rational Field and Category of graded modules over Rational Field """ cat = super(GradedModulesCategory, cls).default_super_categories(category, *args) return Category.join([category.Filtered(), cat])
def default_super_categories(cls, category): """ Return the default super categories of ``category.Metric()``. Mathematical meaning: if `A` is a metric space in the category `C`, then `A` is also a topological space. INPUT: - ``cls`` -- the class ``MetricSpaces`` - ``category`` -- a category `Cat` OUTPUT: A (join) category In practice, this returns ``category.Metric()``, joined together with the result of the method :meth:`RegressiveCovariantConstructionCategory.default_super_categories() <sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory.default_super_categories>` (that is the join of ``category`` and ``cat.Metric()`` for each ``cat`` in the super categories of ``category``). EXAMPLES: Consider ``category=Groups()``. Then, a group `G` with a metric is simultaneously a topological group by itself, and a metric space:: sage: Groups().Metric().super_categories() [Category of topological groups, Category of metric spaces] This resulted from the following call:: sage: sage.categories.metric_spaces.MetricSpacesCategory.default_super_categories(Groups()) Join of Category of topological groups and Category of metric spaces """ return Category.join([category.Topological(), super(MetricSpacesCategory, cls).default_super_categories(category)])