Covariant Functorial Constructions¶
A functorial construction is a collection of functors
\((F_{Cat})_{Cat}\) (indexed by a collection of categories) which associate
to a sequence of parents \((A, B, ...)\) in a category \(Cat\) a parent
\(F_{Cat}(A, B, ...)\). Typical examples of functorial
constructions are cartesian_product and tensor_product.
The category of \(F_{Cat}(A, B, ...)\), which only depends on \(Cat\), is called the (functorial) construction category.
A functorial construction is (category)-covariant if for every categories \(Cat\) and \(SuperCat\), the category of \(F_{Cat}(A, B, ...)\) is a subcategory of the category of \(F_{SuperCat}(A, B, ...)\) whenever \(Cat\) is a subcategory of \(SuperCat\). A functorial construction is (category)-regressive if the category of \(F_{Cat}(A, B, ...)\) is a subcategory of \(Cat\).
The goal of this module is to provide generic support for covariant functorial constructions. In particular, given some parents \(A\), \(B\), …, in respective categories \(Cat_A\), \(Cat_B\), …, it provides tools for calculating the best known category for the parent \(F(A,B,...)\). For examples, knowing that Cartesian products of semigroups (resp. monoids, groups) have a semigroup (resp. monoid, group) structure, and given a group \(B\) and two monoids \(A\) and \(C\) it can calculate that \(A \times B \times C\) is naturally endowed with a monoid structure.
See CovariantFunctorialConstruction,
CovariantConstructionCategory and
RegressiveCovariantConstructionCategory for more details.
AUTHORS:
Nicolas M. Thiery (2010): initial revision
- class sage.categories.covariant_functorial_construction.CovariantConstructionCategory(category, *args)[source]¶
- Bases: - FunctorialConstructionCategory- Abstract class for categories \(F_{Cat}\) obtained through a covariant functorial construction - additional_structure()[source]¶
- Return the additional structure defined by - self.- By default, a functorial construction category - A.F()defines additional structure if and only if \(A\) is the category defining \(F\). The rationale is that, for a subcategory \(B\) of \(A\), the fact that \(B.F()\) morphisms shall preserve the \(F\)-specific structure is already imposed by \(A.F()\).- EXAMPLES: - sage: Modules(ZZ).Graded().additional_structure() Category of graded modules over Integer Ring sage: Algebras(ZZ).Graded().additional_structure() - >>> from sage.all import * >>> Modules(ZZ).Graded().additional_structure() Category of graded modules over Integer Ring >>> Algebras(ZZ).Graded().additional_structure() 
 - classmethod default_super_categories(category, *args)[source]¶
- 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 - 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: - Bialgebras are both algebras and coalgebras: - sage: Bialgebras(QQ).super_categories() [Category of algebras over Rational Field, Category of coalgebras over Rational Field] - >>> from sage.all import * >>> 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] - >>> from sage.all import * >>> 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 - default_super_categories()was called internally:- sage: C = sage.categories.tensor.TensorProductsCategory sage: C.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 - >>> from sage.all import * >>> C = sage.categories.tensor.TensorProductsCategory >>> C.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 - Algebrafunctor which takes a parameter \(\QQ\):- sage: FiniteMonoids().super_categories() [Category of monoids, Category of finite semigroups] sage: sorted(FiniteMonoids().Algebras(QQ).super_categories(), key=str) [Category of finite dimensional algebras with basis over Rational Field, Category of finite set algebras over Rational Field, Category of monoid algebras over Rational Field] - >>> from sage.all import * >>> FiniteMonoids().super_categories() [Category of monoids, Category of finite semigroups] >>> sorted(FiniteMonoids().Algebras(QQ).super_categories(), key=str) [Category of finite dimensional algebras with basis over Rational Field, Category of finite set algebras over Rational Field, Category of monoid 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 - default_super_categories()was called internally:- sage: C = sage.categories.algebra_functor.AlgebrasCategory sage: C.default_super_categories(FiniteMonoids(), QQ) Join of Category of finite dimensional algebras with basis over Rational Field and Category of monoid algebras over Rational Field and Category of finite set algebras over Rational Field - >>> from sage.all import * >>> C = sage.categories.algebra_functor.AlgebrasCategory >>> C.default_super_categories(FiniteMonoids(), QQ) Join of Category of finite dimensional algebras with basis over Rational Field and Category of monoid algebras over Rational Field and Category of finite set algebras over Rational Field 
 - is_construction_defined_by_base()[source]¶
- Return whether the construction is defined by the base of - self.- EXAMPLES: - The graded functorial construction is defined by the modules category. Hence this method returns - Truefor graded modules and- Falsefor other graded xxx categories:- sage: Modules(ZZ).Graded().is_construction_defined_by_base() True sage: Algebras(QQ).Graded().is_construction_defined_by_base() False sage: Modules(ZZ).WithBasis().Graded().is_construction_defined_by_base() False - >>> from sage.all import * >>> Modules(ZZ).Graded().is_construction_defined_by_base() True >>> Algebras(QQ).Graded().is_construction_defined_by_base() False >>> Modules(ZZ).WithBasis().Graded().is_construction_defined_by_base() False - This is implemented as follows: given the base category \(A\) and the construction \(F\) of - self, that is- self=A.F(), check whether no super category of \(A\) has \(F\) defined.- Note - Recall that, when \(A\) does not implement the construction - F, a join category is returned. Therefore, in such cases, this method is not available:- sage: Bialgebras(QQ).Graded().is_construction_defined_by_base() Traceback (most recent call last): ... AttributeError: 'JoinCategory_with_category' object has no attribute 'is_construction_defined_by_base' - >>> from sage.all import * >>> Bialgebras(QQ).Graded().is_construction_defined_by_base() Traceback (most recent call last): ... AttributeError: 'JoinCategory_with_category' object has no attribute 'is_construction_defined_by_base' 
 
- class sage.categories.covariant_functorial_construction.CovariantFunctorialConstruction[source]¶
- Bases: - UniqueRepresentation,- SageObject- An abstract class for construction functors \(F\) (eg \(F\) = Cartesian product, tensor product, \(\QQ\)-algebra, …) such that: - Each category \(Cat\) (eg \(Cat=\) - Groups()) can provide a category \(F_{Cat}\) for parents constructed via this functor (e.g. \(F_{Cat} =\)- CartesianProductsOf(Groups())).
- For every category \(Cat\), \(F_{Cat}\) is a subcategory of \(F_{SuperCat}\) for every super category \(SuperCat\) of \(Cat\) (the functorial construction is (category)-covariant). 
- For parents \(A\), \(B\), …, respectively in the categories \(Cat_A\), \(Cat_B\), …, the category of \(F(A,B,...)\) is \(F_{Cat}\) where \(Cat\) is the meet of the categories \(Cat_A\), \(Cat_B\), …,. 
 - This covers two slightly different use cases: - In the first use case, one uses directly the construction functor to create new parents: - sage: tensor() # todo: not implemented (add an example) - >>> from sage.all import * >>> tensor() # todo: not implemented (add an example) - or even new elements, which indirectly constructs the corresponding parent: - sage: tensor(...) # todo: not implemented - >>> from sage.all import * >>> tensor(Ellipsis) # todo: not implemented 
- In the second use case, one implements a parent, and then put it in the category \(F_{Cat}\) to specify supplementary mathematical information about that parent. 
 - The main purpose of this class is to handle automatically the trivial part of the category hierarchy. For example, - CartesianProductsOf(Groups())is set automatically as a subcategory of- CartesianProductsOf(Monoids()).- In practice, each subclass of this class should provide the following attributes: - _functor_category– string which should match the name of the nested category class to be used in each category to specify information and generic operations for elements of this category
- _functor_name– string which specifies the name of the functor, and also (when relevant) of the method on parents and elements used for calling the construction
 - TODO: What syntax do we want for \(F_{Cat}\)? For example, for the tensor product construction, which one do we want among (see chat on IRC, on 07/12/2009): - tensor(Cat)
- tensor((Cat, Cat))
- tensor.of((Cat, Cat))
- tensor.category_from_categories((Cat, Cat, Cat))
- Cat.TensorProducts()
 - The syntax - Cat.TensorProducts()does not supports well multivariate constructions like- tensor.of([Algebras(), HopfAlgebras(), ...]). Also it forces every category to be (somehow) aware of all the tensorial construction that could apply to it, even those which are only induced from super categories.- Note: for each functorial construction, there probably is one (or several) largest categories on which it applies. For example, the - CartesianProducts()construction makes only sense for concrete categories, that is subcategories of- Sets(). Maybe we want to model this one way or the other.- category_from_categories(categories)[source]¶
- 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 monoids and Category of Cartesian products of commutative additive groups sage: cartesian_product.category_from_categories((Cat1, Cat2)) Category of Cartesian products of monoids - >>> from sage.all import * >>> Cat1 = Rings() >>> Cat2 = Groups() >>> cartesian_product.category_from_categories((Cat1, Cat1, Cat1)) Join of Category of rings and ... and Category of Cartesian products of monoids and Category of Cartesian products of commutative additive groups >>> cartesian_product.category_from_categories((Cat1, Cat2)) Category of Cartesian products of monoids 
 - category_from_category(category)[source]¶
- Return the category of \(F(A,B,...)\) for \(A,B,...\) parents in - category.- INPUT: - self– a functor \(F\)
- category– a category
 - EXAMPLES: - sage: tensor.category_from_category(ModulesWithBasis(QQ)) Category of tensor products of vector spaces with basis over Rational Field - >>> from sage.all import * >>> tensor.category_from_category(ModulesWithBasis(QQ)) Category of tensor products of vector spaces with basis over Rational Field - # TODO: add support for parametrized functors 
 - category_from_parents(parents)[source]¶
- Return the category of \(F(A,B,...)\) for \(A,B,...\) parents. - INPUT: - self– a functor \(F\)
- parents– a list (or iterable) of parents
 - EXAMPLES: - sage: E = CombinatorialFreeModule(QQ, ["a", "b", "c"]) # needs sage.modules sage: tensor.category_from_parents((E, E, E)) # needs sage.modules Category of tensor products of finite dimensional vector spaces with basis over Rational Field - >>> from sage.all import * >>> E = CombinatorialFreeModule(QQ, ["a", "b", "c"]) # needs sage.modules >>> tensor.category_from_parents((E, E, E)) # needs sage.modules Category of tensor products of finite dimensional vector spaces with basis over Rational Field 
 
- class sage.categories.covariant_functorial_construction.FunctorialConstructionCategory(category, *args)[source]¶
- Bases: - Category- Abstract class for categories \(F_{Cat}\) obtained through a functorial construction - base_category()[source]¶
- Return the base category of the category - self.- For any category - B= \(F_{Cat}\) obtained through a functorial construction \(F\), the call- B.base_category()returns the category \(Cat\).- EXAMPLES: - sage: Semigroups().Quotients().base_category() Category of semigroups - >>> from sage.all import * >>> Semigroups().Quotients().base_category() Category of semigroups 
 - classmethod category_of(category, *args)[source]¶
- Return the image category of the functor \(F_{Cat}\). - This is the main entry point for constructing the category \(F_{Cat}\) of parents \(F(A,B,...)\) constructed from parents \(A,B,...\) in \(Cat\). - INPUT: - cls– the category class for the functorial construction \(F\)
- category– a category \(Cat\)
- *args– further arguments for the functor
 - EXAMPLES: - sage: C = sage.categories.tensor.TensorProductsCategory sage: C.category_of(ModulesWithBasis(QQ)) Category of tensor products of vector spaces with basis over Rational Field sage: C = sage.categories.algebra_functor.AlgebrasCategory sage: C.category_of(FiniteMonoids(), QQ) Join of Category of finite dimensional algebras with basis over Rational Field and Category of monoid algebras over Rational Field and Category of finite set algebras over Rational Field - >>> from sage.all import * >>> C = sage.categories.tensor.TensorProductsCategory >>> C.category_of(ModulesWithBasis(QQ)) Category of tensor products of vector spaces with basis over Rational Field >>> C = sage.categories.algebra_functor.AlgebrasCategory >>> C.category_of(FiniteMonoids(), QQ) Join of Category of finite dimensional algebras with basis over Rational Field and Category of monoid algebras over Rational Field and Category of finite set algebras over Rational Field 
 - extra_super_categories()[source]¶
- Return the extra super categories of a construction category. - Default implementation which returns - [].- EXAMPLES: - sage: Sets().Subquotients().extra_super_categories() [] sage: Semigroups().Quotients().extra_super_categories() [] - >>> from sage.all import * >>> Sets().Subquotients().extra_super_categories() [] >>> Semigroups().Quotients().extra_super_categories() [] 
 - super_categories()[source]¶
- Return 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] - >>> from sage.all import * >>> Sets().Subquotients().super_categories() [Category of sets] >>> Semigroups().Quotients().super_categories() [Category of subquotients of semigroups, Category of quotients of sets] 
 
- class sage.categories.covariant_functorial_construction.RegressiveCovariantConstructionCategory(category, *args)[source]¶
- Bases: - CovariantConstructionCategory- Abstract class for categories \(F_{Cat}\) obtained through a regressive covariant functorial construction - classmethod default_super_categories(category, *args)[source]¶
- 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] - >>> from sage.all import * >>> Monoids().Subquotients().super_categories() [Category of monoids, Category of subquotients of semigroups]