Finitely presented graded modules over the Steenrod algebra - Modules

Skip to content
Back to top
View this page
Edit this page

# 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)

  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)

    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

        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]

    Python

        >>> 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]

    When there are no relations, the resolution is trivial:

    Sage

        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]

    [Python]

        >>> 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]

class sage.modules.fp_graded.steenrod.module.SteenrodFreeModule(algebra, generator_degrees, category, names=None, **kwds)

  Bases: `FreeGradedModule`, `SteenrodModuleMixin`

class sage.modules.fp_graded.steenrod.module.SteenrodModuleMixin

  Bases: `object`

  Mixin class for common methods of the Steenrod algebra modules.

  export_module_definition(powers_of_two_only=True)

    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

        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

    Python

        >>> 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

  profile()

    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

        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)

    Python

        >>> 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)