Additive magmas#
- class sage.categories.additive_magmas.AdditiveMagmas(s=None)#
Bases:
sage.categories.category_singleton.Category_singleton
The category of additive magmas.
An additive magma is a set endowed with a binary operation \(+\).
EXAMPLES:
sage: AdditiveMagmas() Category of additive magmas sage: AdditiveMagmas().super_categories() [Category of sets] sage: AdditiveMagmas().all_super_categories() [Category of additive magmas, Category of sets, Category of sets with partial maps, Category of objects]
The following axioms are defined by this category:
sage: AdditiveMagmas().AdditiveAssociative() Category of additive semigroups sage: AdditiveMagmas().AdditiveUnital() Category of additive unital additive magmas sage: AdditiveMagmas().AdditiveCommutative() Category of additive commutative additive magmas sage: AdditiveMagmas().AdditiveUnital().AdditiveInverse() Category of additive inverse additive unital additive magmas sage: AdditiveMagmas().AdditiveAssociative().AdditiveCommutative() Category of commutative additive semigroups sage: AdditiveMagmas().AdditiveAssociative().AdditiveCommutative().AdditiveUnital() Category of commutative additive monoids sage: AdditiveMagmas().AdditiveAssociative().AdditiveCommutative().AdditiveUnital().AdditiveInverse() Category of commutative additive groups
- AdditiveAssociative#
alias of
sage.categories.additive_semigroups.AdditiveSemigroups
- class AdditiveCommutative(base_category)#
Bases:
sage.categories.category_with_axiom.CategoryWithAxiom_singleton
- class Algebras(category, *args)#
Bases:
sage.categories.algebra_functor.AlgebrasCategory
- extra_super_categories()#
Implement the fact that the algebra of a commutative additive magmas is commutative.
EXAMPLES:
sage: AdditiveMagmas().AdditiveCommutative().Algebras(QQ).extra_super_categories() [Category of commutative magmas] sage: AdditiveMagmas().AdditiveCommutative().Algebras(QQ).super_categories() [Category of additive magma algebras over Rational Field, Category of commutative magmas]
- class CartesianProducts(category, *args)#
Bases:
sage.categories.cartesian_product.CartesianProductsCategory
- extra_super_categories()#
Implement the fact that a Cartesian product of commutative additive magmas is a commutative additive magma.
EXAMPLES:
sage: C = AdditiveMagmas().AdditiveCommutative().CartesianProducts() sage: C.extra_super_categories() [Category of additive commutative additive magmas] sage: C.axioms() frozenset({'AdditiveCommutative'})
- class AdditiveUnital(base_category)#
Bases:
sage.categories.category_with_axiom.CategoryWithAxiom_singleton
- class AdditiveInverse(base_category)#
Bases:
sage.categories.category_with_axiom.CategoryWithAxiom_singleton
- class CartesianProducts(category, *args)#
Bases:
sage.categories.cartesian_product.CartesianProductsCategory
- class ElementMethods#
Bases:
object
- extra_super_categories()#
Implement the fact that a Cartesian product of additive magmas with inverses is an additive magma with inverse.
EXAMPLES:
sage: C = AdditiveMagmas().AdditiveUnital().AdditiveInverse().CartesianProducts() sage: C.extra_super_categories() [Category of additive inverse additive unital additive magmas] sage: sorted(C.axioms()) ['AdditiveInverse', 'AdditiveUnital']
- class Algebras(category, *args)#
Bases:
sage.categories.algebra_functor.AlgebrasCategory
- class ParentMethods#
Bases:
object
- one_basis()#
Return the zero of this additive magma, which index the one of this algebra, as per
AlgebrasWithBasis.ParentMethods.one_basis()
.EXAMPLES:
sage: S = CommutativeAdditiveMonoids().example(); S An example of a commutative monoid: the free commutative monoid generated by ('a', 'b', 'c', 'd') sage: A = S.algebra(ZZ) sage: A.one_basis() 0 sage: A.one() B[0] sage: A(3) 3*B[0]
- extra_super_categories()#
EXAMPLES:
sage: C = AdditiveMagmas().AdditiveUnital().Algebras(QQ) sage: C.extra_super_categories() [Category of unital magmas] sage: C.super_categories() [Category of unital algebras with basis over Rational Field, Category of additive magma algebras over Rational Field]
- class CartesianProducts(category, *args)#
Bases:
sage.categories.cartesian_product.CartesianProductsCategory
- class ParentMethods#
Bases:
object
- zero()#
Returns the zero of this group
EXAMPLES:
sage: GF(8,'x').cartesian_product(GF(5)).zero() (0, 0)
- extra_super_categories()#
Implement the fact that a Cartesian product of unital additive magmas is a unital additive magma.
EXAMPLES:
sage: C = AdditiveMagmas().AdditiveUnital().CartesianProducts() sage: C.extra_super_categories() [Category of additive unital additive magmas] sage: C.axioms() frozenset({'AdditiveUnital'})
- class ElementMethods#
Bases:
object
- class Homsets(category, *args)#
Bases:
sage.categories.homsets.HomsetsCategory
- class ParentMethods#
Bases:
object
- zero()#
EXAMPLES:
sage: R = QQ['x'] sage: H = Hom(ZZ, R, AdditiveMagmas().AdditiveUnital()) sage: f = H.zero() sage: f Generic morphism: From: Integer Ring To: Univariate Polynomial Ring in x over Rational Field sage: f(3) 0 sage: f(3) is R.zero() True
- extra_super_categories()#
Implement the fact that a homset between two unital additive magmas is a unital additive magma.
EXAMPLES:
sage: AdditiveMagmas().AdditiveUnital().Homsets().extra_super_categories() [Category of additive unital additive magmas] sage: AdditiveMagmas().AdditiveUnital().Homsets().super_categories() [Category of additive unital additive magmas, Category of homsets]
- class ParentMethods#
Bases:
object
- is_empty()#
Return whether this set is empty.
Since this set is an additive magma it has a zero element and hence is not empty. This method thus always returns
False
.EXAMPLES:
sage: A = AdditiveAbelianGroup([3,3]) sage: A in AdditiveMagmas() True sage: A.is_empty() False sage: B = CommutativeAdditiveMonoids().example() sage: B.is_empty() False
- zero()#
Return the zero of this additive magma, that is the unique neutral element for \(+\).
The default implementation is to coerce
0
intoself
.It is recommended to override this method because the coercion from the integers:
is not always meaningful (except for \(0\)), and
often uses
self.zero()
otherwise.
EXAMPLES:
sage: S = CommutativeAdditiveMonoids().example() sage: S.zero() 0
- class SubcategoryMethods#
Bases:
object
- AdditiveInverse()#
Return the full subcategory of the additive inverse objects of
self
.An inverse
additive magma
is aunital additive magma
such that every element admits both an additive inverse on the left and on the right. Such an additive magma is also called an additive loop.EXAMPLES:
sage: AdditiveMagmas().AdditiveUnital().AdditiveInverse() Category of additive inverse additive unital additive magmas sage: from sage.categories.additive_monoids import AdditiveMonoids sage: AdditiveMonoids().AdditiveInverse() Category of additive groups
- class WithRealizations(category, *args)#
Bases:
sage.categories.with_realizations.WithRealizationsCategory
- class ParentMethods#
Bases:
object
- zero()#
Return the zero of this unital additive magma.
This default implementation returns the zero of the realization of
self
given bya_realization()
.EXAMPLES:
sage: A = Sets().WithRealizations().example(); A The subset algebra of {1, 2, 3} over Rational Field sage: A.zero.__module__ 'sage.categories.additive_magmas' sage: A.zero() 0
- additional_structure()#
Return whether
self
is a structure category.See also
The category of unital additive magmas defines the zero as additional structure, and this zero shall be preserved by morphisms.
EXAMPLES:
sage: AdditiveMagmas().AdditiveUnital().additional_structure() Category of additive unital additive magmas
- class Algebras(category, *args)#
Bases:
sage.categories.algebra_functor.AlgebrasCategory
- class ParentMethods#
Bases:
object
- algebra_generators()#
The generators of this algebra, as per
MagmaticAlgebras.ParentMethods.algebra_generators()
.They correspond to the generators of the additive semigroup.
EXAMPLES:
sage: S = CommutativeAdditiveSemigroups().example(); S An example of a commutative semigroup: the free commutative semigroup generated by ('a', 'b', 'c', 'd') sage: A = S.algebra(QQ) sage: A.algebra_generators() Finite family {0: B[a], 1: B[b], 2: B[c], 3: B[d]}
Todo
This doctest does not actually test this method, but rather the method of the same name for
AdditiveSemigroups
. Find a better doctest!
- product_on_basis(g1, g2)#
Product, on basis elements, as per
MagmaticAlgebras.WithBasis.ParentMethods.product_on_basis()
.The product of two basis elements is induced by the addition of the corresponding elements of the group.
EXAMPLES:
sage: S = CommutativeAdditiveSemigroups().example(); S An example of a commutative semigroup: the free commutative semigroup generated by ('a', 'b', 'c', 'd') sage: A = S.algebra(QQ) sage: a,b,c,d = A.algebra_generators() sage: a * d * b B[a + b + d]
Todo
This doctest does not actually test this method, but rather the method of the same name for
AdditiveSemigroups
. Find a better doctest!
- extra_super_categories()#
EXAMPLES:
sage: AdditiveMagmas().Algebras(QQ).extra_super_categories() [Category of magmatic algebras with basis over Rational Field] sage: AdditiveMagmas().Algebras(QQ).super_categories() [Category of magmatic algebras with basis over Rational Field, Category of set algebras over Rational Field]
- class CartesianProducts(category, *args)#
Bases:
sage.categories.cartesian_product.CartesianProductsCategory
- class ElementMethods#
Bases:
object
- extra_super_categories()#
Implement the fact that a Cartesian product of additive magmas is an additive magma.
EXAMPLES:
sage: C = AdditiveMagmas().CartesianProducts() sage: C.extra_super_categories() [Category of additive magmas] sage: C.super_categories() [Category of additive magmas, Category of Cartesian products of sets] sage: C.axioms() frozenset()
- class ElementMethods#
Bases:
object
- class Homsets(category, *args)#
Bases:
sage.categories.homsets.HomsetsCategory
- extra_super_categories()#
Implement the fact that a homset between two magmas is a magma.
EXAMPLES:
sage: AdditiveMagmas().Homsets().extra_super_categories() [Category of additive magmas] sage: AdditiveMagmas().Homsets().super_categories() [Category of additive magmas, Category of homsets]
- class ParentMethods#
Bases:
object
- addition_table(names='letters', elements=None)#
Return a table describing the addition operation.
Note
The order of the elements in the row and column headings is equal to the order given by the table’s
column_keys()
method. The association can also be retrieved with thetranslation()
method.INPUT:
names
– the type of names used:'letters'
- lowercase ASCII letters are used for a base 26 representation of the elements’ positions in the list given bycolumn_keys()
, padded to a common width with leading ‘a’s.'digits'
- base 10 representation of the elements’ positions in the list given bycolumn_keys()
, padded to a common width with leading zeros.'elements'
- the string representations of the elements themselves.a list - a list of strings, where the length of the list equals the number of elements.
elements
– (default:None
) A list of elements of the additive magma, in forms that can be coerced into the structure, eg. their string representations. This may be used to impose an alternate ordering on the elements, perhaps when this is used in the context of a particular structure. The default is to use whatever ordering theS.list
method returns. Or theelements
can be a subset which is closed under the operation. In particular, this can be used when the base set is infinite.
OUTPUT:
The addition table as an object of the class
OperationTable
which defines several methods for manipulating and displaying the table. See the documentation there for full details to supplement the documentation here.EXAMPLES:
All that is required is that an algebraic structure has an addition defined.The default is to represent elements as lowercase ASCII letters.
sage: R = IntegerModRing(5) sage: R.addition_table() + a b c d e +---------- a| a b c d e b| b c d e a c| c d e a b d| d e a b c e| e a b c d
The
names
argument allows displaying the elements in different ways. Requestingelements
will use the representation of the elements of the set. Requestingdigits
will include leading zeros as padding.sage: R = IntegerModRing(11) sage: P = R.addition_table(names='elements') sage: P + 0 1 2 3 4 5 6 7 8 9 10 +--------------------------------- 0| 0 1 2 3 4 5 6 7 8 9 10 1| 1 2 3 4 5 6 7 8 9 10 0 2| 2 3 4 5 6 7 8 9 10 0 1 3| 3 4 5 6 7 8 9 10 0 1 2 4| 4 5 6 7 8 9 10 0 1 2 3 5| 5 6 7 8 9 10 0 1 2 3 4 6| 6 7 8 9 10 0 1 2 3 4 5 7| 7 8 9 10 0 1 2 3 4 5 6 8| 8 9 10 0 1 2 3 4 5 6 7 9| 9 10 0 1 2 3 4 5 6 7 8 10| 10 0 1 2 3 4 5 6 7 8 9 sage: T = R.addition_table(names='digits') sage: T + 00 01 02 03 04 05 06 07 08 09 10 +--------------------------------- 00| 00 01 02 03 04 05 06 07 08 09 10 01| 01 02 03 04 05 06 07 08 09 10 00 02| 02 03 04 05 06 07 08 09 10 00 01 03| 03 04 05 06 07 08 09 10 00 01 02 04| 04 05 06 07 08 09 10 00 01 02 03 05| 05 06 07 08 09 10 00 01 02 03 04 06| 06 07 08 09 10 00 01 02 03 04 05 07| 07 08 09 10 00 01 02 03 04 05 06 08| 08 09 10 00 01 02 03 04 05 06 07 09| 09 10 00 01 02 03 04 05 06 07 08 10| 10 00 01 02 03 04 05 06 07 08 09
Specifying the elements in an alternative order can provide more insight into how the operation behaves.
sage: S = IntegerModRing(7) sage: elts = [0, 3, 6, 2, 5, 1, 4] sage: S.addition_table(elements=elts) + a b c d e f g +-------------- a| a b c d e f g b| b c d e f g a c| c d e f g a b d| d e f g a b c e| e f g a b c d f| f g a b c d e g| g a b c d e f
The
elements
argument can be used to provide a subset of the elements of the structure. The subset must be closed under the operation. Elements need only be in a form that can be coerced into the set. Thenames
argument can also be used to request that the elements be represented with their usual string representation.sage: T = IntegerModRing(12) sage: elts=[0, 3, 6, 9] sage: T.addition_table(names='elements', elements=elts) + 0 3 6 9 +-------- 0| 0 3 6 9 3| 3 6 9 0 6| 6 9 0 3 9| 9 0 3 6
The table returned can be manipulated in various ways. See the documentation for
OperationTable
for more comprehensive documentation.sage: R = IntegerModRing(3) sage: T = R.addition_table() sage: T.column_keys() (0, 1, 2) sage: sorted(T.translation().items()) [('a', 0), ('b', 1), ('c', 2)] sage: T.change_names(['x', 'y', 'z']) sage: sorted(T.translation().items()) [('x', 0), ('y', 1), ('z', 2)] sage: T + x y z +------ x| x y z y| y z x z| z x y
- summation(x, y)#
Return the sum of
x
andy
.The binary addition operator of this additive magma.
INPUT:
x
,y
– elements of this additive magma
EXAMPLES:
sage: S = CommutativeAdditiveSemigroups().example() sage: (a,b,c,d) = S.additive_semigroup_generators() sage: S.summation(a, b) a + b
A parent in
AdditiveMagmas()
must either implementsummation()
in the parent class or_add_
in the element class. By default, the addition method on elementsx._add_(y)
callsS.summation(x,y)
, and reciprocally.As a bonus effect,
S.summation
by itself models the binary function fromS
toS
:sage: bin = S.summation sage: bin(a,b) a + b
Here,
S.summation
is just a bound method. Whenever possible, it is recommended to enrichS.summation
with extra mathematical structure. Lazy attributes can come handy for this.Todo
Add an example.
- summation_from_element_class_add(x, y)#
Return the sum of
x
andy
.The binary addition operator of this additive magma.
INPUT:
x
,y
– elements of this additive magma
EXAMPLES:
sage: S = CommutativeAdditiveSemigroups().example() sage: (a,b,c,d) = S.additive_semigroup_generators() sage: S.summation(a, b) a + b
A parent in
AdditiveMagmas()
must either implementsummation()
in the parent class or_add_
in the element class. By default, the addition method on elementsx._add_(y)
callsS.summation(x,y)
, and reciprocally.As a bonus effect,
S.summation
by itself models the binary function fromS
toS
:sage: bin = S.summation sage: bin(a,b) a + b
Here,
S.summation
is just a bound method. Whenever possible, it is recommended to enrichS.summation
with extra mathematical structure. Lazy attributes can come handy for this.Todo
Add an example.
- class SubcategoryMethods#
Bases:
object
- AdditiveAssociative()#
Return the full subcategory of the additive associative objects of
self
.An
additive magma
\(M\) is associative if, for all \(x,y,z \in M\),\[x + (y + z) = (x + y) + z\]EXAMPLES:
sage: AdditiveMagmas().AdditiveAssociative() Category of additive semigroups
- AdditiveCommutative()#
Return the full subcategory of the commutative objects of
self
.An
additive magma
\(M\) is commutative if, for all \(x,y \in M\),\[x + y = y + x\]EXAMPLES:
sage: AdditiveMagmas().AdditiveCommutative() Category of additive commutative additive magmas sage: AdditiveMagmas().AdditiveAssociative().AdditiveUnital().AdditiveCommutative() Category of commutative additive monoids sage: _ is CommutativeAdditiveMonoids() True
- AdditiveUnital()#
Return the subcategory of the unital objects of
self
.An
additive magma
\(M\) is unital if it admits an element \(0\), called neutral element, such that for all \(x \in M\),\[0 + x = x + 0 = x\]This element is necessarily unique, and should be provided as
M.zero()
.EXAMPLES:
sage: AdditiveMagmas().AdditiveUnital() Category of additive unital additive magmas sage: from sage.categories.additive_semigroups import AdditiveSemigroups sage: AdditiveSemigroups().AdditiveUnital() Category of additive monoids sage: CommutativeAdditiveMonoids().AdditiveUnital() Category of commutative additive monoids
- super_categories()#
EXAMPLES:
sage: AdditiveMagmas().super_categories() [Category of sets]