Finitely presented graded modules over the Steenrod algebra

This package allows the user to define finitely presented modules over the mod \(p\) Steenrod algebra, elements of them, and morphisms between them. Methods are provided for doing basic homological algebra, e.g. computing kernels and images of homomorphisms, and finding free resolutions of modules.

Theoretical background

The category of finitely presented graded modules over an arbitrary non-Noetherian graded ring \(R\) is not abelian in general, since kernels of homomorphisms are not necessarily finitely presented.

The mod \(p\) Steenrod algebra is non-Noetherian, but it is the union of a countable set of finite sub-Hopf algebras ([Mar1983] Ch. 15, Sect. 1, Prop 7). It is therefore an example of a \(P\)-algebra ([Mar1983] Ch. 13).

Any finitely presented module over the Steenrod algebra is defined over one of these finite sub-Hopf algebras. Similarly, any homomorphism between finitely presented modules over the Steenrod algebra is defined over a finite sub-Hopf algebra of the Steenrod algebra. Further, tensoring up from the category of modules over a sub-Hopf algebra is an exact functor, since the Steenrod algebra is free over any sub-Hopf algebra.

It follows that kernels, cokernels, images, and, more generally, any finite limits or colimits can be computed in the category of modules over the Steenrod algebra by working in the category of modules over an appropriate finite sub-Hopf algebra.

It is also the case that presentations of modules and the images of the generators of the domain of a homomorphism are the same over the sub-Hopf algebra and over the whole Steenrod algebra, so that the tensoring up is entirely implicit and requires no computation.

The definitions and computations carried out by this package are thus done as follows. First, find a small finite sub-Hopf algebra over which the computation can be done. Then, carry out the calculation there, where it is a finite problem and can be reduced to linear algebra over a finite prime field.

For examples, see the Steenrod algebra modules thematic tutorial.

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.steenrod.module.SteenrodFPModule(j, names)[source]

Bases: FPModule, SteenrodModuleMixin

Create a finitely presented module over the Steenrod algebra.

See also

The thematic tutorial on Steenrod algebra modules.

INPUT:

One of the following:

  • arg0 – a morphism such that the module is the cokernel, or a free graded module, in which case the output is the same module, viewed as finitely presented

Otherwise:

  • arg0 – the graded connected algebra over which the module is defined; this algebra must be equipped with a graded basis

  • generator_degrees – tuple of integer degrees

  • relations – tuple of relations; a relation is a tuple of coefficients \((c_1, \ldots, c_n)\), ordered so that they correspond to the module generators, that is, such a tuple corresponds to the relation

    \[c_1 g_1 + \ldots + c_n g_n = 0\]

    if the generators are \((g_1, \ldots, g_n)\)

resolution(k, top_dim=None, verbose=False)[source]

A free resolution of self of the given length.

INPUT:

  • k – nonnegative integer

  • top_dim – (optional) stop the computation at this degree

  • verbose – boolean (default: False); whether log messages are printed

OUTPUT: list of homomorphisms \([\epsilon, f_1, \ldots, f_k]\) such that

\[\begin{split}\begin{gathered} f_i: F_i \to F_{i-1} \text{ for } 1\leq i\leq k, \\ \epsilon: F_0\to M, \end{gathered}\end{split}\]

where each \(F_i\) is a finitely generated free module, and the sequence

\[F_k \xrightarrow{f_k} F_{k-1} \xrightarrow{f_{k-1}} \ldots \rightarrow F_0 \xrightarrow{\epsilon} M \rightarrow 0\]

is exact. Note that the 0th element in this list is the map \(\epsilon\), and the rest of the maps are between free modules.

EXAMPLES:

sage: from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
sage: A = SteenrodAlgebra(2)
sage: Hko = SteenrodFPModule(A, [0], [[Sq(1)], [Sq(2)]])

sage: res = Hko.resolution(5, verbose=True)
Computing f_1 (1/5)
Computing f_2 (2/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [1, 8]: 1 2 3 4 5 6 7 8.
Computing f_3 (3/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [2, 10]: 2 3 4 5 6 7 8 9 10.
Computing f_4 (4/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [3, 13]: 3 4 5 6 7 8 9 10 11 12 13.
Computing f_5 (5/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [4, 18]: 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18.
sage: [x.domain() for x in res]
[Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 3 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 4 generators over mod 2 Steenrod algebra, milnor basis]

>>> from sage.all import *
>>> from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
>>> A = SteenrodAlgebra(Integer(2))
>>> Hko = SteenrodFPModule(A, [Integer(0)], [[Sq(Integer(1))], [Sq(Integer(2))]])

>>> res = Hko.resolution(Integer(5), verbose=True)
Computing f_1 (1/5)
Computing f_2 (2/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [1, 8]: 1 2 3 4 5 6 7 8.
Computing f_3 (3/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [2, 10]: 2 3 4 5 6 7 8 9 10.
Computing f_4 (4/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [3, 13]: 3 4 5 6 7 8 9 10 11 12 13.
Computing f_5 (5/5)
Computing using the profile:
(2, 1)
Resolving the kernel in the range of dimensions [4, 18]: 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18.
>>> [x.domain() for x in res]
[Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 2 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 3 generators over mod 2 Steenrod algebra, milnor basis,
 Free graded left module on 4 generators over mod 2 Steenrod algebra, milnor basis]

from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
A = SteenrodAlgebra(2)
Hko = SteenrodFPModule(A, [0], [[Sq(1)], [Sq(2)]])
res = Hko.resolution(5, verbose=True)
[x.domain() for x in res]

When there are no relations, the resolution is trivial:

sage: M = SteenrodFPModule(A, [0])
sage: M.resolution(4)
[Module endomorphism of Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
   Defn: g[0] |--> g[0],
 Module morphism:
   From: Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis
   To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis,
 Module endomorphism of Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis,
 Module endomorphism of Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis,
 Module endomorphism of Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis]

>>> from sage.all import *
>>> M = SteenrodFPModule(A, [Integer(0)])
>>> M.resolution(Integer(4))
[Module endomorphism of Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis
   Defn: g[0] |--> g[0],
 Module morphism:
   From: Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis
   To:   Free graded left module on 1 generator over mod 2 Steenrod algebra, milnor basis,
 Module endomorphism of Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis,
 Module endomorphism of Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis,
 Module endomorphism of Free graded left module on 0 generators over mod 2 Steenrod algebra, milnor basis]

M = SteenrodFPModule(A, [0])
M.resolution(4)
class sage.modules.fp_graded.steenrod.module.SteenrodFreeModule(algebra, generator_degrees, category, names=None, **kwds)[source]

Bases: FreeGradedModule, SteenrodModuleMixin

class sage.modules.fp_graded.steenrod.module.SteenrodModuleMixin[source]

Bases: object

Mixin class for common methods of the Steenrod algebra modules.

export_module_definition(powers_of_two_only=True)[source]

Return the module to the input format used by R. Bruner’s Ext software as a string.

INPUT:

  • powers_of_two_only – boolean (default: True); if the output should contain the action of all Steenrod squaring operations (restricted by the profile), or only the action of the operations of degree equal to a power of two

EXAMPLES:

sage: from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
sage: A1 = algebra=SteenrodAlgebra(p=2, profile=[2,1])
sage: M = SteenrodFPModule(A1, [0])
sage: print(M.export_module_definition())
8 0 1 2 3 3 4 5 6
0 1 1 1
2 1 1 4
3 1 1 5
6 1 1 7
0 2 1 2
1 2 2 3 4
2 2 1 5
3 2 1 6
4 2 1 6
5 2 1 7
sage: N = SteenrodFPModule(A1, [0], [[Sq(1)]])
sage: print(N.export_module_definition())
4 0 2 3 5
1 1 1 2
0 2 1 1
2 2 1 3
sage: print(N.export_module_definition(powers_of_two_only=False))
4 0 2 3 5
1 1 1 2
0 2 1 1
2 2 1 3
0 3 1 2
sage: A2 = SteenrodAlgebra(p=2, profile=[3,2,1])
sage: Hko = SteenrodFPModule(A2, [0], [[Sq(1)], [Sq(2)]])
sage: print(Hko.export_module_definition())
8 0 4 6 7 10 11 13 17
2 1 1 3
4 1 1 5
1 2 1 2
5 2 1 6
0 4 1 1
2 4 1 4
3 4 1 5
6 4 1 7

>>> from sage.all import *
>>> from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
>>> A1 = algebra=SteenrodAlgebra(p=Integer(2), profile=[Integer(2),Integer(1)])
>>> M = SteenrodFPModule(A1, [Integer(0)])
>>> print(M.export_module_definition())
8 0 1 2 3 3 4 5 6
0 1 1 1
2 1 1 4
3 1 1 5
6 1 1 7
0 2 1 2
1 2 2 3 4
2 2 1 5
3 2 1 6
4 2 1 6
5 2 1 7
>>> N = SteenrodFPModule(A1, [Integer(0)], [[Sq(Integer(1))]])
>>> print(N.export_module_definition())
4 0 2 3 5
1 1 1 2
0 2 1 1
2 2 1 3
>>> print(N.export_module_definition(powers_of_two_only=False))
4 0 2 3 5
1 1 1 2
0 2 1 1
2 2 1 3
0 3 1 2
>>> A2 = SteenrodAlgebra(p=Integer(2), profile=[Integer(3),Integer(2),Integer(1)])
>>> Hko = SteenrodFPModule(A2, [Integer(0)], [[Sq(Integer(1))], [Sq(Integer(2))]])
>>> print(Hko.export_module_definition())
8 0 4 6 7 10 11 13 17
2 1 1 3
4 1 1 5
1 2 1 2
5 2 1 6
0 4 1 1
2 4 1 4
3 4 1 5
6 4 1 7

from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
A1 = algebra=SteenrodAlgebra(p=2, profile=[2,1])
M = SteenrodFPModule(A1, [0])
print(M.export_module_definition())
N = SteenrodFPModule(A1, [0], [[Sq(1)]])
print(N.export_module_definition())
print(N.export_module_definition(powers_of_two_only=False))
A2 = SteenrodAlgebra(p=2, profile=[3,2,1])
Hko = SteenrodFPModule(A2, [0], [[Sq(1)], [Sq(2)]])
print(Hko.export_module_definition())
profile()[source]

Return a finite profile over which self can be defined.

Any finitely presented module over the Steenrod algebra can be defined over a finite-dimensional sub-Hopf algebra, and this method identifies such a sub-Hopf algebra and returns its profile function.

Note

The profile produced by this function is reasonably small but is not guaranteed to be minimal.

EXAMPLES:

sage: from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
sage: A = SteenrodAlgebra(2)
sage: M = SteenrodFPModule(A, [0,1], [[Sq(2),Sq(1)],[0,Sq(2)],[Sq(3),0]])
sage: M.profile()
(2, 1)

>>> from sage.all import *
>>> from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
>>> A = SteenrodAlgebra(Integer(2))
>>> M = SteenrodFPModule(A, [Integer(0),Integer(1)], [[Sq(Integer(2)),Sq(Integer(1))],[Integer(0),Sq(Integer(2))],[Sq(Integer(3)),Integer(0)]])
>>> M.profile()
(2, 1)

from sage.modules.fp_graded.steenrod.module import SteenrodFPModule
A = SteenrodAlgebra(2)
M = SteenrodFPModule(A, [0,1], [[Sq(2),Sq(1)],[0,Sq(2)],[Sq(3),0]])
M.profile()