Finitely generated free graded left modules over connected graded algebras¶
Let \(A\) be a connected graded algebra. Some methods here require in addition that \(A\) be an algebra over a field or a PID and that Sage has a description of a basis for \(A\).
For example, let \(p\) be a prime number. The mod \(p\) Steenrod algebra \(A_p\) is a connected algebra over the finite field of \(p\) elements. Many of the modules presented here will be defined over \(A_p\), or one of its sub-Hopf algebras. E.g.:
sage: A = SteenrodAlgebra(p=2)
>>> from sage.all import *
>>> A = SteenrodAlgebra(p=Integer(2))
However, the current implementation can use any connected graded algebra that has a graded basis where each graded part is finite dimensional. Another good family is the exterior algebras:
sage: E.<x,y,z> = ExteriorAlgebra(QQ)
>>> from sage.all import *
>>> E = ExteriorAlgebra(QQ, names=('x', 'y', 'z',)); (x, y, z,) = E._first_ngens(3)
A free module is defined by the graded algebra and an ordered tuple of degrees for the generators:
sage: M = A.free_graded_module(generator_degrees=(0,1))
sage: M
Free graded left module on 2 generators over
 mod 2 Steenrod algebra, milnor basis
sage: F.<a,b,c> = E.free_graded_module((0,3,6))
sage: F
Free graded left module on 3 generators over
 The exterior algebra of rank 3 over Rational Field
>>> from sage.all import *
>>> M = A.free_graded_module(generator_degrees=(Integer(0),Integer(1)))
>>> M
Free graded left module on 2 generators over
 mod 2 Steenrod algebra, milnor basis
>>> F = E.free_graded_module((Integer(0),Integer(3),Integer(6)), names=('a', 'b', 'c',)); (a, b, c,) = F._first_ngens(3)
>>> F
Free graded left module on 3 generators over
 The exterior algebra of rank 3 over Rational Field
The resulting free modules will have generators in the degrees as specified:
sage: M.generator_degrees()
(0, 1)
sage: F.generator_degrees()
(0, 3, 6)
>>> from sage.all import *
>>> M.generator_degrees()
(0, 1)
>>> F.generator_degrees()
(0, 3, 6)
The default names for the generators are g[degree] if they are in
distinct degrees, g[degree, i] otherwise. They can be given other
names, as was done when creating the module F:
sage: M.generators()
(g[0], g[1])
sage: F.generators()
(a, b, c)
>>> from sage.all import *
>>> M.generators()
(g[0], g[1])
>>> F.generators()
(a, b, c)
The connectivity of a module over a connected graded algebra is the minimum degree of all its module generators. Thus, if the module is non-trivial, the connectivity is an integer:
sage: M.connectivity()
0
>>> from sage.all import *
>>> M.connectivity()
0
Module elements¶
For an \(A\)-module with generators \(\{g_i\}_{i=1}^N\), any homogeneous element of degree \(n\) has the form
where \(a_i\in A_{n-\deg(g_i)}\) for all \(i\). The ordered set \(\{a_i\}\) is referred to as the coefficients of \(x\).
You can produce module elements from a given set of coefficients:
sage: coeffs = [Sq(5), Sq(1,1)]
sage: x = M(coeffs); x
Sq(5)*g[0] + Sq(1,1)*g[1]
>>> from sage.all import *
>>> coeffs = [Sq(Integer(5)), Sq(Integer(1),Integer(1))]
>>> x = M(coeffs); x
Sq(5)*g[0] + Sq(1,1)*g[1]
You can also use the module action:
sage: Sq(2) * x
(Sq(4,1)+Sq(7))*g[0] + Sq(3,1)*g[1]
>>> from sage.all import *
>>> Sq(Integer(2)) * x
(Sq(4,1)+Sq(7))*g[0] + Sq(3,1)*g[1]
Each nonzero element has a well-defined degree:
sage: x.degree()
5
>>> from sage.all import *
>>> x.degree()
5
However the zero element does not:
sage: zero = M.zero(); zero
0
sage: zero.degree()
Traceback (most recent call last):
...
ValueError: the zero element does not have a well-defined degree
>>> from sage.all import *
>>> zero = M.zero(); zero
0
>>> zero.degree()
Traceback (most recent call last):
...
ValueError: the zero element does not have a well-defined degree
Any two elements can be added as long as they are in the same degree:
sage: y = M.an_element(5); y
Sq(2,1)*g[0] + Sq(4)*g[1]
sage: x + y
(Sq(2,1)+Sq(5))*g[0] + (Sq(1,1)+Sq(4))*g[1]
>>> from sage.all import *
>>> y = M.an_element(Integer(5)); y
Sq(2,1)*g[0] + Sq(4)*g[1]
>>> x + y
(Sq(2,1)+Sq(5))*g[0] + (Sq(1,1)+Sq(4))*g[1]
or when at least one of them is zero:
sage: x + zero == x
True
>>> from sage.all import *
>>> x + zero == x
True
Finally, additive inverses exist:
sage: x - x
0
>>> from sage.all import *
>>> x - x
0
For every integer \(n\), the set of module elements of degree \(n\) form a free module over the ground ring \(k\). A basis for this free module can be computed:
sage: M.basis_elements(5)
(Sq(2,1)*g[0], Sq(5)*g[0], Sq(1,1)*g[1], Sq(4)*g[1])
>>> from sage.all import *
>>> M.basis_elements(Integer(5))
(Sq(2,1)*g[0], Sq(5)*g[0], Sq(1,1)*g[1], Sq(4)*g[1])
together with a corresponding free module presentation:
sage: M.vector_presentation(5)
Vector space of dimension 4 over Finite Field of size 2
>>> from sage.all import *
>>> M.vector_presentation(Integer(5))
Vector space of dimension 4 over Finite Field of size 2
Given any element, its coordinates with respect to this basis can be computed:
sage: v = x.vector_presentation(); v
(0, 1, 1, 0)
>>> from sage.all import *
>>> v = x.vector_presentation(); v
(0, 1, 1, 0)
Going the other way, any element can be constructed by specifying its coordinates:
sage: x_ = M.element_from_coordinates((0,1,1,0), 5)
sage: x_
Sq(5)*g[0] + Sq(1,1)*g[1]
sage: x_ == x
True
>>> from sage.all import *
>>> x_ = M.element_from_coordinates((Integer(0),Integer(1),Integer(1),Integer(0)), Integer(5))
>>> x_
Sq(5)*g[0] + Sq(1,1)*g[1]
>>> x_ == x
True
Module homomorphisms¶
Homomorphisms of free graded \(A\)-modules \(M\to N\) are linear maps of their underlying free \(k\)-module which commute with the \(A\)-module structure.
To create a homomorphism, first create the object modeling the set of all
such homomorphisms using the free function Hom:
sage: M = A.free_graded_module((0,1))
sage: N.<c2> = A.free_graded_module((2,))
sage: homspace = Hom(M, N); homspace
Set of Morphisms from Free graded left module on 2 generators
  over mod 2 Steenrod algebra, milnor basis
 to Free graded left module on 1 generator
  over mod 2 Steenrod algebra, milnor basis
 in Category of finite dimensional graded modules with basis
  over mod 2 Steenrod algebra, milnor basis
>>> from sage.all import *
>>> M = A.free_graded_module((Integer(0),Integer(1)))
>>> N = A.free_graded_module((Integer(2),), names=('c2',)); (c2,) = N._first_ngens(1)
>>> homspace = Hom(M, N); homspace
Set of Morphisms from Free graded left module on 2 generators
  over mod 2 Steenrod algebra, milnor basis
 to Free graded left module on 1 generator
  over mod 2 Steenrod algebra, milnor basis
 in Category of finite dimensional graded modules with basis
  over mod 2 Steenrod algebra, milnor basis
Just as module elements, homomorphisms are created using the homspace object. The only argument is a list of module elements in the codomain, corresponding to the module generators of the domain:
sage: values = [Sq(2)*c2, Sq(2)*Sq(1)*c2]
sage: f = homspace(values)
>>> from sage.all import *
>>> values = [Sq(Integer(2))*c2, Sq(Integer(2))*Sq(Integer(1))*c2]
>>> f = homspace(values)
The resulting homomorphism is the one sending the \(i\)-th generator of the domain to the \(i\)-th codomain value given:
sage: f
Module morphism:
  From: Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> Sq(2)*c2
        g[1] |--> (Sq(0,1)+Sq(3))*c2
>>> from sage.all import *
>>> f
Module morphism:
  From: Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> Sq(2)*c2
        g[1] |--> (Sq(0,1)+Sq(3))*c2
Convenience methods exist for creating the trivial morphism:
sage: homspace.zero()
Module morphism:
  From: Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> 0
        g[1] |--> 0
>>> from sage.all import *
>>> homspace.zero()
Module morphism:
  From: Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> 0
        g[1] |--> 0
as well as the identity endomorphism:
sage: Hom(M, M).identity()
Module endomorphism of Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> g[0]
        g[1] |--> g[1]
>>> from sage.all import *
>>> Hom(M, M).identity()
Module endomorphism of Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> g[0]
        g[1] |--> g[1]
Homomorphisms can be evaluated on elements of the domain module:
sage: v1 = f(Sq(7)*M.generator(0)); v1
Sq(3,2)*c2
sage: v2 = f(Sq(17)*M.generator(1)); v2
(Sq(11,3)+Sq(13,0,1)+Sq(17,1))*c2
>>> from sage.all import *
>>> v1 = f(Sq(Integer(7))*M.generator(Integer(0))); v1
Sq(3,2)*c2
>>> v2 = f(Sq(Integer(17))*M.generator(Integer(1))); v2
(Sq(11,3)+Sq(13,0,1)+Sq(17,1))*c2
and they respect the module action:
sage: v1 == Sq(7)*f(M.generator(0))
True
sage: v2 == Sq(17)*f(M.generator(1))
True
>>> from sage.all import *
>>> v1 == Sq(Integer(7))*f(M.generator(Integer(0)))
True
>>> v2 == Sq(Integer(17))*f(M.generator(Integer(1)))
True
Any non-trivial homomorphism has a well-defined degree:
sage: f.degree()
4
>>> from sage.all import *
>>> f.degree()
4
but just as module elements, the trivial homomorphism does not:
sage: zero_map = homspace.zero()
sage: zero_map.degree()
Traceback (most recent call last):
...
ValueError: the zero morphism does not have a well-defined degree
>>> from sage.all import *
>>> zero_map = homspace.zero()
>>> zero_map.degree()
Traceback (most recent call last):
...
ValueError: the zero morphism does not have a well-defined degree
Any two homomorphisms can be added as long as they are of the same degree:
sage: f2 = homspace([Sq(2)*c2, Sq(3)*c2])
sage: f + f2
Module morphism:
  From: Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> 0
        g[1] |--> Sq(0,1)*c2
>>> from sage.all import *
>>> f2 = homspace([Sq(Integer(2))*c2, Sq(Integer(3))*c2])
>>> f + f2
Module morphism:
  From: Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis
  To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
  Defn: g[0] |--> 0
        g[1] |--> Sq(0,1)*c2
or when at least one of them is zero:
sage: f + zero_map == f
True
>>> from sage.all import *
>>> f + zero_map == f
True
Finally, additive inverses exist:
sage: f - f == 0
True
>>> from sage.all import *
>>> f - f == Integer(0)
True
The restriction of a homomorphism to the free module of \(n\)-dimensional module elements is a linear transformation:
sage: f_4 = f.vector_presentation(4); f_4
Vector space morphism represented by the matrix:
[0 1 0]
[1 1 1]
[0 1 0]
[0 0 0]
Domain: Vector space of dimension 4 over Finite Field of size 2
Codomain: Vector space of dimension 3 over Finite Field of size 2
>>> from sage.all import *
>>> f_4 = f.vector_presentation(Integer(4)); f_4
Vector space morphism represented by the matrix:
[0 1 0]
[1 1 1]
[0 1 0]
[0 0 0]
Domain: Vector space of dimension 4 over Finite Field of size 2
Codomain: Vector space of dimension 3 over Finite Field of size 2
This is compatible with the vector presentations of its domain and codomain modules:
sage: f.domain() is M
True
sage: f.codomain() is N
True
sage: f_4.domain() is M.vector_presentation(4)
True
sage: f_4.codomain() is N.vector_presentation(4 + f.degree())
True
>>> from sage.all import *
>>> f.domain() is M
True
>>> f.codomain() is N
True
>>> f_4.domain() is M.vector_presentation(Integer(4))
True
>>> f_4.codomain() is N.vector_presentation(Integer(4) + f.degree())
True
AUTHORS:
- Robert R. Bruner, Michael J. Catanzaro (2012): Initial version. 
- Sverre Lunoee–Nielsen and Koen van Woerden (2019-11-29): Updated the original software to Sage version 8.9. 
- Sverre Lunoee–Nielsen (2020-07-01): Refactored the code and added new documentation and tests. 
- class sage.modules.fp_graded.free_module.FreeGradedModule(algebra, generator_degrees, category, names=None, **kwds)[source]¶
- Bases: - CombinatorialFreeModule- Create a finitely generated free graded module over a connected graded algebra, with generators in specified degrees. - INPUT: - algebra– the graded connected algebra over which the module is defined; this algebra must be equipped with a graded basis
- generator_degrees– tuple of integers defining the number of generators of the module, and their degrees
- names– (optional) the names of the generators. If- namesis a comma-separated string like- 'a, b, c', then those will be the names. Otherwise, for example if- namesis- abc, then the names will be- abc(d,i).
 - By default, if all generators are in distinct degrees, then the - namesof the generators will have the form- g_{d}where- dis the degree of the generator. If the degrees are not distinct, then the generators will be called- g_{d,i}where- dis the degree and- iis its index in the list of generators in that degree.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: E.<x,y,z> = ExteriorAlgebra(QQ) sage: M = FreeGradedModule(E, (-1,3)) sage: M Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field sage: M.generator_degrees() (-1, 3) sage: a, b = M.generators() sage: (x*y*b).degree() 5 - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> E = ExteriorAlgebra(QQ, names=('x', 'y', 'z',)); (x, y, z,) = E._first_ngens(3) >>> M = FreeGradedModule(E, (-Integer(1),Integer(3))) >>> M Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field >>> M.generator_degrees() (-1, 3) >>> a, b = M.generators() >>> (x*y*b).degree() 5 - namesof generators:- sage: M.generators() (g[-1], g[3]) sage: FreeGradedModule(E, (0, 0, 2)).generators() (g[0, 0], g[0, 1], g[2, 0]) sage: FreeGradedModule(E, (0, 0, 2), names='x, y, z').generators() (x, y, z) sage: FreeGradedModule(E, (0, 0, 2), names='xyz').generators() (xyz[0, 0], xyz[0, 1], xyz[2, 0]) - >>> from sage.all import * >>> M.generators() (g[-1], g[3]) >>> FreeGradedModule(E, (Integer(0), Integer(0), Integer(2))).generators() (g[0, 0], g[0, 1], g[2, 0]) >>> FreeGradedModule(E, (Integer(0), Integer(0), Integer(2)), names='x, y, z').generators() (x, y, z) >>> FreeGradedModule(E, (Integer(0), Integer(0), Integer(2)), names='xyz').generators() (xyz[0, 0], xyz[0, 1], xyz[2, 0]) - namescan also be defined implicitly using Sage’s- M.<...>syntax:- sage: A = SteenrodAlgebra(2) sage: M.<x,y,z> = FreeGradedModule(A, (-2,2,4)) sage: M Free graded left module on 3 generators over mod 2 Steenrod algebra, milnor basis sage: M.gens() (x, y, z) - >>> from sage.all import * >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (-Integer(2),Integer(2),Integer(4)), names=('x', 'y', 'z',)); (x, y, z,) = M._first_ngens(3) >>> M Free graded left module on 3 generators over mod 2 Steenrod algebra, milnor basis >>> M.gens() (x, y, z) - Element[source]¶
- alias of - FreeGradedModuleElement
 - an_element(n=None)[source]¶
- Return an element of - self.- This function chooses deterministically an element of the module in the given degree. - INPUT: - n– (optional) the degree of the element to construct
 - OUTPUT: - An element (of the given degree if specified). - EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (0,2,4)) sage: M.an_element(172) Sq(0,0,2,0,1,0,1)*g[0] + Sq(0,4,0,0,1,0,1)*g[2] + Sq(7,1,0,0,1,0,1)*g[4] - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (Integer(0),Integer(2),Integer(4))) >>> M.an_element(Integer(172)) Sq(0,0,2,0,1,0,1)*g[0] + Sq(0,4,0,0,1,0,1)*g[2] + Sq(7,1,0,0,1,0,1)*g[4] - Zero is the only element in the trivial module: - sage: FreeGradedModule(A, ()).an_element() 0 - >>> from sage.all import * >>> FreeGradedModule(A, ()).an_element() 0 
 - basis_elements(n)[source]¶
- Return a basis for the free module of degree - nmodule elements.- Note - Suppose - selfis a module over the graded algebra \(A\) with base ring \(R\). This returns a basis as a free module over \(R\), not a basis as a free module over \(A\).- INPUT: - n– integer
 - OUTPUT: - A sequence of homogeneous module elements of degree - n, which is a basis for the free module of all degree- nmodule elements.- EXAMPLES: - sage: A = SteenrodAlgebra(2) sage: M.<m0, m2, m4> = A.free_graded_module((0,2,4)) sage: M.basis_elements(8) (Sq(1,0,1)*m0, Sq(2,2)*m0, Sq(5,1)*m0, Sq(8)*m0, Sq(0,2)*m2, Sq(3,1)*m2, Sq(6)*m2, Sq(1,1)*m4, Sq(4)*m4) - >>> from sage.all import * >>> A = SteenrodAlgebra(Integer(2)) >>> M = A.free_graded_module((Integer(0),Integer(2),Integer(4)), names=('m0', 'm2', 'm4',)); (m0, m2, m4,) = M._first_ngens(3) >>> M.basis_elements(Integer(8)) (Sq(1,0,1)*m0, Sq(2,2)*m0, Sq(5,1)*m0, Sq(8)*m0, Sq(0,2)*m2, Sq(3,1)*m2, Sq(6)*m2, Sq(1,1)*m4, Sq(4)*m4) 
 - change_ring(algebra)[source]¶
- Change the base ring of - self.- INPUT: - algebra– a connected graded algebra
 - OUTPUT: - The free graded module over - algebradefined with the same number of generators of the same degrees as- self.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: A2 = SteenrodAlgebra(2, profile=(3,2,1)) sage: M = FreeGradedModule(A, [0,1]) sage: N = M.change_ring(A2); N Free graded left module on 2 generators over sub-Hopf algebra of mod 2 Steenrod algebra, milnor basis, profile function [3, 2, 1] - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> A2 = SteenrodAlgebra(Integer(2), profile=(Integer(3),Integer(2),Integer(1))) >>> M = FreeGradedModule(A, [Integer(0),Integer(1)]) >>> N = M.change_ring(A2); N Free graded left module on 2 generators over sub-Hopf algebra of mod 2 Steenrod algebra, milnor basis, profile function [3, 2, 1] - Changing back yields the original module: - sage: N.change_ring(A) is M True - >>> from sage.all import * >>> N.change_ring(A) is M True 
 - connectivity()[source]¶
- The connectivity of - self.- OUTPUT: - An integer equal to the minimal degree of all the generators, if this module is non-trivial. Otherwise, \(+\infty\). - EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (-2,2,4)) sage: M.connectivity() -2 - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (-Integer(2),Integer(2),Integer(4))) >>> M.connectivity() -2 
 - element_from_coordinates(coordinates, n)[source]¶
- The module element of degree - nhaving the given coordinates with respect to the basis of module elements given by- basis_elements().- INPUT: - coordinates– a sequence of elements of the ground ring
- n– integer
 - OUTPUT: a module element of degree - n- See also - EXAMPLES: - sage: A = SteenrodAlgebra(2) sage: M = A.free_graded_module((0,1)) sage: x = M.element_from_coordinates((0,1,0,1), 5); x Sq(5)*g[0] + Sq(4)*g[1] sage: basis = M.basis_elements(5) sage: y = 0*basis[0] + 1*basis[1] + 0*basis[2] + 1*basis[3] sage: x == y True sage: M.element_from_coordinates((0,0,0,0), 5) 0 - >>> from sage.all import * >>> A = SteenrodAlgebra(Integer(2)) >>> M = A.free_graded_module((Integer(0),Integer(1))) >>> x = M.element_from_coordinates((Integer(0),Integer(1),Integer(0),Integer(1)), Integer(5)); x Sq(5)*g[0] + Sq(4)*g[1] >>> basis = M.basis_elements(Integer(5)) >>> y = Integer(0)*basis[Integer(0)] + Integer(1)*basis[Integer(1)] + Integer(0)*basis[Integer(2)] + Integer(1)*basis[Integer(3)] >>> x == y True >>> M.element_from_coordinates((Integer(0),Integer(0),Integer(0),Integer(0)), Integer(5)) 0 
 - gen(index)[source]¶
- Return the module generator with the given index. - EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (0,2,4)) sage: M.generator(0) g[0] sage: M.generator(1) g[2] sage: M.generator(2) g[4] - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (Integer(0),Integer(2),Integer(4))) >>> M.generator(Integer(0)) g[0] >>> M.generator(Integer(1)) g[2] >>> M.generator(Integer(2)) g[4] 
 - generator(index)[source]¶
- Return the module generator with the given index. - EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (0,2,4)) sage: M.generator(0) g[0] sage: M.generator(1) g[2] sage: M.generator(2) g[4] - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (Integer(0),Integer(2),Integer(4))) >>> M.generator(Integer(0)) g[0] >>> M.generator(Integer(1)) g[2] >>> M.generator(Integer(2)) g[4] 
 - generator_degrees()[source]¶
- The degrees of the module generators. - OUTPUT: - A tuple containing the degrees of the generators for this module, in the order that the generators were given when - selfwas constructed.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (-2,2,4)) sage: M.generator_degrees() (-2, 2, 4) - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (-Integer(2),Integer(2),Integer(4))) >>> M.generator_degrees() (-2, 2, 4) 
 - generators()[source]¶
- Return all the module generators. - EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (-2,1)) sage: M.generators() (g[-2], g[1]) - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (-Integer(2),Integer(1))) >>> M.generators() (g[-2], g[1]) 
 - has_relations()[source]¶
- Return - Falseas this has no relations.- This is for compatibility with - FPModule.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: F = FreeGradedModule(A, (-2,2,4)) sage: F.has_relations() False - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> F = FreeGradedModule(A, (-Integer(2),Integer(2),Integer(4))) >>> F.has_relations() False 
 - is_trivial()[source]¶
- Return - Trueif this module is trivial and- Falseotherwise.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: FreeGradedModule(A, (-2,2,4)).is_trivial() False sage: FreeGradedModule(A, ()).is_trivial() True - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> FreeGradedModule(A, (-Integer(2),Integer(2),Integer(4))).is_trivial() False >>> FreeGradedModule(A, ()).is_trivial() True 
 - minimal_presentation(top_dim=None, verbose=False)[source]¶
- Return a minimal presentation of - self.- OUTPUT: the identity morphism as - selfis free- EXAMPLES: - sage: from sage.modules.fp_graded.module import FPModule sage: A2 = SteenrodAlgebra(2) sage: M = A2.free_graded_module([0,1]) sage: M.minimal_presentation().is_identity() True - >>> from sage.all import * >>> from sage.modules.fp_graded.module import FPModule >>> A2 = SteenrodAlgebra(Integer(2)) >>> M = A2.free_graded_module([Integer(0),Integer(1)]) >>> M.minimal_presentation().is_identity() True 
 - relations()[source]¶
- Return the relations of - self, which is- ().- This is for compatibility with - FPModule.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: F = FreeGradedModule(A, (-2,2,4)) sage: F.relations() () - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> F = FreeGradedModule(A, (-Integer(2),Integer(2),Integer(4))) >>> F.relations() () 
 - resolution(k, top_dim=None, verbose=False)[source]¶
- Return a free resolution of - selfof length- k.- Since - selfis free, the initial map in the resolution will be the identity, and the rest of the maps will be zero.- INPUT: - k– nonnegative integer
- top_dim– stop the computation at this degree. Ignored, for compatibility with- sage.modules.fp_graded.module.FPModule.resolution().
- verbose– boolean (default:- False); controls whether log messages should be emitted
 - OUTPUT: - A list of homomorphisms \([1_M, 0, 0, \ldots, 0]\) consisting of the identity map on this module followed by zero maps. Other than this module, the other modules in the resolution will be zero. - EXAMPLES: - sage: E.<x,y,z> = ExteriorAlgebra(QQ) sage: M = E.free_graded_module((1,2)) sage: M.resolution(0) [Module endomorphism of Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field Defn: g[1] |--> g[1] g[2] |--> g[2]] sage: M.resolution(1) [Module endomorphism of Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field Defn: g[1] |--> g[1] g[2] |--> g[2], Module morphism: From: Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field To: Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field] sage: M.resolution(4) [Module endomorphism of Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field Defn: g[1] |--> g[1] g[2] |--> g[2], Module morphism: From: Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field To: Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field, Module endomorphism of Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field, Module endomorphism of Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field, Module endomorphism of Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field] - >>> from sage.all import * >>> E = ExteriorAlgebra(QQ, names=('x', 'y', 'z',)); (x, y, z,) = E._first_ngens(3) >>> M = E.free_graded_module((Integer(1),Integer(2))) >>> M.resolution(Integer(0)) [Module endomorphism of Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field Defn: g[1] |--> g[1] g[2] |--> g[2]] >>> M.resolution(Integer(1)) [Module endomorphism of Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field Defn: g[1] |--> g[1] g[2] |--> g[2], Module morphism: From: Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field To: Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field] >>> M.resolution(Integer(4)) [Module endomorphism of Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field Defn: g[1] |--> g[1] g[2] |--> g[2], Module morphism: From: Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field To: Free graded left module on 2 generators over The exterior algebra of rank 3 over Rational Field, Module endomorphism of Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field, Module endomorphism of Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field, Module endomorphism of Free graded left module on 0 generators over The exterior algebra of rank 3 over Rational Field] 
 - suspension(t)[source]¶
- Suspend - selfby the given degree- t.- INPUT: - t– integer
 - OUTPUT: - A module which is isomorphic to this module by a shift of degrees by the integer - t.- EXAMPLES: - sage: from sage.modules.fp_graded.free_module import FreeGradedModule sage: A = SteenrodAlgebra(2) sage: M = FreeGradedModule(A, (0,2,4)) sage: M.suspension(4).generator_degrees() (4, 6, 8) sage: M.suspension(-4).generator_degrees() (-4, -2, 0) - >>> from sage.all import * >>> from sage.modules.fp_graded.free_module import FreeGradedModule >>> A = SteenrodAlgebra(Integer(2)) >>> M = FreeGradedModule(A, (Integer(0),Integer(2),Integer(4))) >>> M.suspension(Integer(4)).generator_degrees() (4, 6, 8) >>> M.suspension(-Integer(4)).generator_degrees() (-4, -2, 0) 
 - vector_presentation(n)[source]¶
- Return a free module over the ground ring of the module algebra isomorphic to the degree - nelements of- self.- Let \(\mathcal{k}\) be the ground ring of the algebra over this module is defined, and let \(M_n\) be the free module of module elements of degree - n.- The return value of this function is the free module \(\mathcal{k}^{r}\) where \(r = dim(M_n)\). - The isomorphism between \(k^{r}\) and \(M_n\) is given by the bijection taking the standard basis element \(e_i\) to the \(i\)-th element of the array returned by - basis_elements().- INPUT: - n– integer degree
 - OUTPUT: - A free module over the ground ring of the algebra over which - selfis defined, isomorphic to the free module of module elements of degree- n.- See also - EXAMPLES: - sage: A1 = SteenrodAlgebra(2, profile=[2,1]) sage: M.<x> = A1.free_graded_module((0,)) sage: M.vector_presentation(3) Vector space of dimension 2 over Finite Field of size 2 sage: M.basis_elements(3) (Sq(0,1)*x, Sq(3)*x) sage: [M.vector_presentation(i).dimension() for i in range(-2, 9)] [0, 0, 1, 1, 1, 2, 1, 1, 1, 0, 0] - >>> from sage.all import * >>> A1 = SteenrodAlgebra(Integer(2), profile=[Integer(2),Integer(1)]) >>> M = A1.free_graded_module((Integer(0),), names=('x',)); (x,) = M._first_ngens(1) >>> M.vector_presentation(Integer(3)) Vector space of dimension 2 over Finite Field of size 2 >>> M.basis_elements(Integer(3)) (Sq(0,1)*x, Sq(3)*x) >>> [M.vector_presentation(i).dimension() for i in range(-Integer(2), Integer(9))] [0, 0, 1, 1, 1, 2, 1, 1, 1, 0, 0]