AUTHORS:
This package defines functions for computing various bases of the Steenrod algebra, and for converting between the Milnor basis and any other basis.
This packages implements a number of different bases, at least at the prime 2. The Milnor and Serre-Cartan bases are the most familiar and most standard ones, and all of the others are defined in terms of one of these. The bases are described in the documentation for the function steenrod_algebra_basis(); also see the papers by Monks [M] and Wood [W] for more information about them. For commutator bases, see the preprint by Palmieri and Zhang [PZ].
Most of the rest of the bases are only defined when . The only
exceptions are the
-bases and the commutator bases, which are
defined at all primes.
The main functions provided here are
INTERNAL DOCUMENTATION:
If you want to implement a new basis for the Steenrod algebra:
In the file steenrod_algebra.py:
For the class SteenrodAlgebra_generic, add functionality to the methods:
In the file steenrod_algebra_misc.py:
In this file steenrod_algebra_bases.py:
If the basis has an intrinsic way of defining a product, implement it in the file steenrod_algebra_mult.py and also in the product_on_basis method for SteenrodAlgebra_generic in steenrod_algebra.py.
REFERENCES:
Arnon’s C basis in dimension .
INPUT:
OUTPUT: tuple of basis elements in dimension n
The elements of Arnon’s C basis are monomials of the form
where for each
, we have
and
.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import arnonC_basis
sage: arnonC_basis(7)
((7,), (2, 5), (4, 3), (4, 2, 1))
If optional argument bound is present, include only those monomials whose first term is at least as large as bound:
sage: arnonC_basis(7,3)
((7,), (4, 3), (4, 2, 1))
Basis for dimension made of elements in ‘atomic’ degrees:
degrees of the form
.
This works at the prime 2 only.
INPUT:
OUTPUT: tuple of basis elements in dimension n
The atomic bases include Wood’s Y and Z bases, Wall’s basis,
Arnon’s A basis, the -bases, and the commutator
bases. (All of these bases are constructed similarly, hence their
constructions have been consolidated into a single function. Also,
see the documentation for ‘steenrod_algebra_basis’ for
descriptions of them.) For
-bases, you may also specify a
profile function and truncation type; profile functions are ignored
for the other bases.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import atomic_basis
sage: atomic_basis(6,'woody')
(((1, 0), (0, 1), (0, 0)), ((2, 0), (1, 0)), ((1, 1),))
sage: atomic_basis(8,'woodz')
(((2, 0), (0, 1), (0, 0)), ((0, 2), (0, 0)), ((1, 1), (1, 0)), ((3, 0),))
sage: atomic_basis(6,'woodz') == atomic_basis(6, 'woody')
True
sage: atomic_basis(9,'woodz') == atomic_basis(9, 'woody')
False
Wall’s basis:
sage: atomic_basis(8,'wall')
(((2, 2), (1, 0), (0, 0)), ((2, 0), (0, 0)), ((2, 1), (1, 1)), ((3, 3),))
Arnon’s A basis:
sage: atomic_basis(7,'arnona')
(((0, 0), (1, 1), (2, 2)), ((0, 0), (2, 1)), ((1, 0), (2, 2)), ((2, 0),))
-bases:
sage: atomic_basis(7,'pst_rlex')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((2, 1), (0, 2)), ((0, 3),))
sage: atomic_basis(7,'pst_llex')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((0, 2), (2, 1)), ((0, 3),))
sage: atomic_basis(7,'pst_deg')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((0, 2), (2, 1)), ((0, 3),))
sage: atomic_basis(7,'pst_revz')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((0, 2), (2, 1)), ((0, 3),))
Commutator bases:
sage: atomic_basis(7,'comm_rlex')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((2, 1), (0, 2)), ((0, 3),))
sage: atomic_basis(7,'comm_llex')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((0, 2), (2, 1)), ((0, 3),))
sage: atomic_basis(7,'comm_deg')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((0, 2), (2, 1)), ((0, 3),))
sage: atomic_basis(7,'comm_revz')
(((0, 1), (1, 1), (2, 1)), ((0, 1), (1, 2)), ((0, 2), (2, 1)), ((0, 3),))
-bases and commutator basis in dimension
at odd primes.
This function is called atomic_basis_odd in analogy with atomic_basis().
INPUT:
OUTPUT: tuple of basis elements in dimension n
The only possible difference in the implementations for
bases and commutator bases is that the former make sense, and
require filtering, if there is a nontrivial profile function.
This function is called by steenrod_algebra_basis(), and it
will not be called for commutator bases if there is a profile
function, so we treat the two bases exactly the same.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import atomic_basis_odd
sage: atomic_basis_odd(8, 'pst_rlex', 3)
(((), (((0, 1), 2),)),)
sage: atomic_basis_odd(18, 'pst_rlex', 3)
(((0, 2), ()), ((0, 1), (((1, 1), 1),)))
sage: atomic_basis_odd(18, 'pst_rlex', 3, profile=((), (2,2,2)))
(((0, 2), ()),)
Change-of-basis matrix, Milnor to ‘basis’, in dimension
.
INPUT:
OUTPUT: matrix - change-of-basis matrix, a square matrix over GF(p)
Note
This is called internally. It is not intended for casual
users, so no error checking is made on the integer , the
basis name, or the prime.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import convert_from_milnor_matrix, convert_to_milnor_matrix
sage: convert_from_milnor_matrix(12,'wall')
[1 0 0 1 0 0 0]
[0 0 1 1 0 0 0]
[0 0 0 1 0 1 1]
[0 0 0 1 0 0 0]
[1 0 1 0 1 0 0]
[1 1 1 0 0 0 0]
[1 0 1 0 1 0 1]
sage: convert_from_milnor_matrix(38,'serre_cartan')
72 x 72 dense matrix over Finite Field of size 2
sage: x = convert_to_milnor_matrix(20,'wood_y')
sage: y = convert_from_milnor_matrix(20,'wood_y')
sage: x*y
[1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0]
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]
The function takes an optional argument, the prime over
which to work:
sage: convert_from_milnor_matrix(17,'adem',3)
[2 1 1 2]
[0 2 0 1]
[1 2 0 0]
[0 1 0 0]
Change-of-basis matrix, ‘basis’ to Milnor, in dimension
, at the prime
.
INPUT:
OUTPUT:
matrix - change-of-basis matrix, a square matrix over GF(p)
Note
This is called internally. It is not intended for casual
users, so no error checking is made on the integer , the
basis name, or the prime. Also, users should call
convert_to_milnor_matrix() instead of this function
(which has a trailing underscore in its name), because the
former is the cached version of the latter.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import convert_to_milnor_matrix
sage: convert_to_milnor_matrix(5, 'adem') # indirect doctest
[0 1]
[1 1]
sage: convert_to_milnor_matrix(45, 'milnor')
111 x 111 dense matrix over Finite Field of size 2
sage: convert_to_milnor_matrix(12,'wall')
[1 0 0 1 0 0 0]
[1 1 0 0 0 1 0]
[0 1 0 1 0 0 0]
[0 0 0 1 0 0 0]
[1 1 0 0 1 0 0]
[0 0 1 1 1 0 1]
[0 0 0 0 1 0 1]
The function takes an optional argument, the prime over
which to work:
sage: convert_to_milnor_matrix(17,'adem',3)
[0 0 1 1]
[0 0 0 1]
[1 1 1 1]
[0 1 0 1]
sage: convert_to_milnor_matrix(48,'adem',5)
[0 1]
[1 1]
sage: convert_to_milnor_matrix(36,'adem',3)
[0 0 1]
[0 1 0]
[1 2 0]
Milnor basis in dimension with profile function profile.
INPUT:
OUTPUT: tuple of mod p Milnor basis elements in dimension n
At the prime 2, the Milnor basis consists of symbols of the form
, where each
is a non-negative integer and if
, then
. At odd primes, it consists of symbols of the
form
,
where
, each
is a
non-negative integer, and if
, then
.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import milnor_basis
sage: milnor_basis(7)
((0, 0, 1), (1, 2), (4, 1), (7,))
sage: milnor_basis(7, 2)
((0, 0, 1), (1, 2), (4, 1), (7,))
sage: milnor_basis(4, 2)
((1, 1), (4,))
sage: milnor_basis(4, 2, profile=[2,1])
((1, 1),)
sage: milnor_basis(4, 2, profile=(), truncation_type=0)
()
sage: milnor_basis(4, 2, profile=(), truncation_type=Infinity)
((1, 1), (4,))
sage: milnor_basis(9, 3)
(((1,), (1,)), ((0,), (2,)))
sage: milnor_basis(17, 3)
(((2,), ()), ((1,), (3,)), ((0,), (0, 1)), ((0,), (4,)))
sage: milnor_basis(48, p=5)
(((), (0, 1)), ((), (6,)))
sage: len(milnor_basis(100,3))
13
sage: len(milnor_basis(200,7))
0
sage: len(milnor_basis(240,7))
3
sage: len(milnor_basis(240,7, profile=((),()), truncation_type=Infinity))
3
sage: len(milnor_basis(240,7, profile=((),()), truncation_type=0))
0
List of ‘restricted’ partitions of n: partitions with parts taken from list.
INPUT:
OUTPUT: list of lists
One could also use Partitions(n, parts_in=l), but this
function may be faster. Also, while Partitions(n, parts_in=l,
max_slope=-1) should in theory return the partitions of with
parts in l with no repetitions, the max_slope=-1 argument
is ignored, so it doesn’t work. (At the moment, the
no_repeats=True case is the only one used in the code.)
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import restricted_partitions
sage: restricted_partitions(10, [7,5,1])
[[7, 1, 1, 1], [5, 5], [5, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]
sage: restricted_partitions(10, [6,5,4,3,2,1], no_repeats=True)
[[6, 4], [6, 3, 1], [5, 4, 1], [5, 3, 2], [4, 3, 2, 1]]
sage: restricted_partitions(10, [6,4,2])
[[6, 4], [6, 2, 2], [4, 4, 2], [4, 2, 2, 2], [2, 2, 2, 2, 2]]
sage: restricted_partitions(10, [6,4,2], no_repeats=True)
[[6, 4]]
‘l’ may have repeated elements. If ‘no_repeats’ is False, this has no effect. If ‘no_repeats’ is True, and if the repeated elements appear consecutively in ‘l’, then each element may be used only as many times as it appears in ‘l’:
sage: restricted_partitions(10, [6,4,2,2], no_repeats=True)
[[6, 4], [6, 2, 2]]
sage: restricted_partitions(10, [6,4,2,2,2], no_repeats=True)
[[6, 4], [6, 2, 2], [4, 2, 2, 2]]
(If the repeated elements don’t appear consecutively, the results are likely meaningless, containing several partitions more than once, for example.)
In the following examples, ‘no_repeats’ is False:
sage: restricted_partitions(10, [6,4,2])
[[6, 4], [6, 2, 2], [4, 4, 2], [4, 2, 2, 2], [2, 2, 2, 2, 2]]
sage: restricted_partitions(10, [6,4,2,2,2])
[[6, 4], [6, 2, 2], [4, 4, 2], [4, 2, 2, 2], [2, 2, 2, 2, 2]]
sage: restricted_partitions(10, [6,4,4,4,2,2,2,2,2,2])
[[6, 4], [6, 2, 2], [4, 4, 2], [4, 2, 2, 2], [2, 2, 2, 2, 2]]
Serre-Cartan basis in dimension .
INPUT:
OUTPUT: tuple of mod p Serre-Cartan basis elements in dimension n
The Serre-Cartan basis consists of ‘admissible monomials in the
Steenrod squares’. Thus at the prime 2, it consists of monomials
with
for each
. At odd primes, it consists of
monomials
with each
either 0 or 1,
for all
, and
.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import serre_cartan_basis
sage: serre_cartan_basis(7)
((7,), (6, 1), (4, 2, 1), (5, 2))
sage: serre_cartan_basis(13,3)
((1, 3, 0), (0, 3, 1))
sage: serre_cartan_basis(50,5)
((1, 5, 0, 1, 1), (1, 6, 1))
If optional argument bound is present, include only those monomials
whose last term is at least bound (when p=2), or those for which
(when p is odd).
sage: serre_cartan_basis(7, bound=2)
((7,), (5, 2))
sage: serre_cartan_basis(13, 3, bound=3)
((1, 3, 0),)
Basis for the Steenrod algebra in degree .
INPUT:
OUTPUT:
Tuple of objects representing basis elements for the Steenrod algebra in dimension n.
Note
Users should use steenrod_algebra_basis() instead of this function (which has a trailing underscore in its name): steenrod_algebra_basis() is the cached version of this one, and so will be faster.
The choices for the string basis are as follows; see the documentation for sage.algebras.steenrod.steenrod_algebra for details on each basis:
The rest of these bases are only defined when .
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import steenrod_algebra_basis
sage: steenrod_algebra_basis(7,'milnor') # indirect doctest
((0, 0, 1), (1, 2), (4, 1), (7,))
sage: steenrod_algebra_basis(5) # milnor basis is the default
((2, 1), (5,))
Bases in negative dimensions are empty:
sage: steenrod_algebra_basis(-2, 'wall')
()
The third (optional) argument to ‘steenrod_algebra_basis’ is the prime p:
sage: steenrod_algebra_basis(9, 'milnor', p=3)
(((1,), (1,)), ((0,), (2,)))
sage: steenrod_algebra_basis(9, 'milnor', 3)
(((1,), (1,)), ((0,), (2,)))
sage: steenrod_algebra_basis(17, 'milnor', 3)
(((2,), ()), ((1,), (3,)), ((0,), (0, 1)), ((0,), (4,)))
Other bases:
sage: steenrod_algebra_basis(7,'admissible')
((7,), (6, 1), (4, 2, 1), (5, 2))
sage: steenrod_algebra_basis(13,'admissible',p=3)
((1, 3, 0), (0, 3, 1))
sage: steenrod_algebra_basis(5,'wall')
(((2, 2), (0, 0)), ((1, 1), (1, 0)))
sage: steenrod_algebra_basis(5,'wall_long')
(((2, 2), (0, 0)), ((1, 1), (1, 0)))
sage: steenrod_algebra_basis(5,'pst-rlex')
(((0, 1), (2, 1)), ((1, 1), (0, 2)))
This performs crude error checking.
INPUT:
OUTPUT: None
This checks to see if the different bases have the same length, and if the change-of-basis matrices are invertible. If something goes wrong, an error message is printed.
This function checks at the prime p as the dimension goes up from 0 to dim.
If you set the Sage verbosity level to a positive integer (using set_verbose(n)), then some extra messages will be printed.
EXAMPLES:
sage: from sage.algebras.steenrod.steenrod_algebra_bases import steenrod_basis_error_check
sage: steenrod_basis_error_check(15,2) # long time
sage: steenrod_basis_error_check(40,3) # long time
sage: steenrod_basis_error_check(80,5) # long time
Decreasing list of degrees of the xi_i’s, starting in degree n.
INPUT:
OUTPUT: list - list of integers
When : decreasing list of the degrees of the
‘s with
degree at most n.
At odd primes: decreasing list of these degrees, each divided by
.
If reverse is False, then return an increasing list rather than a decreasing one.
EXAMPLES:
sage: sage.algebras.steenrod.steenrod_algebra_bases.xi_degrees(17)
[15, 7, 3, 1]
sage: sage.algebras.steenrod.steenrod_algebra_bases.xi_degrees(17, reverse=False)
[1, 3, 7, 15]
sage: sage.algebras.steenrod.steenrod_algebra_bases.xi_degrees(17,p=3)
[13, 4, 1]
sage: sage.algebras.steenrod.steenrod_algebra_bases.xi_degrees(400,p=17)
[307, 18, 1]