def adem_antipode_on_basis(basis_elt, *, p, generic):
"""Compute the antipode on an Adem basis element.
Stolen from Sage with some neatening. Here's the Sage documentation:
ALGORITHM: according to Milnor, the antipode of Sq(n) is the sum of all the
Milnor basis elements in dimension n. We use this together with the fact that
the antipode is an antihomomorphism.
At odd primes, the antipode of P(n) is the sum of the Milnor P basis
elements in dimension n*2(p-1), multiplied by `(-1)^n`, and the antipode
of \beta = Q_0 is -Q_0.
"""
milnor_alg = MilnorAlgebra.getInstance(p, generic)
if not generic:
elts = [Vector.sum(milnor_alg.basis(n)) for n in basis_elt]
else:
def P_fn(n):
return (-1)**n * Vector.sum(milnor_alg.basis_even(n))
elts = adem.adem_basis_elt_generic_map(P_fn=P_fn,
b=(-1) * milnor_alg.Q(0),
basis_elt=basis_elt)
# Multiply in the reverse order because antipode is an antihomomorphism
milnor_antipode = reduce(lambda a, b: b * a, elts, milnor_alg.unit())
return milnor_antipode.to_adem()
def basis_elt_to_string(self, module, basis_elt):
"""Get string representation of basis vector. Overrides method in Vector."""
if self.algebra.generic:
result = adem.adem_basis_elt_generic_map(P_fn=lambda P: " P%s" % P,
b=" b",
basis_elt=basis_elt)
result = "".join(result)[1:]
else:
result = " ".join(["Sq%s" % s for s in basis_elt
]) # This is adem.adem_2_map inlined
return result or "1"
def adem_to_milnor_on_basis(basis_elt, *, p, generic):
"""Convert an Adem basis element to the Milnor basis.
This is easy because Sqi is a Milnor basis element and Adem basis elements
are products of Sqi's so we just move over the Sqi's and then multiply
in the MilnorAlgebra.
"""
A = MilnorAlgebra.getInstance(p=p, generic=generic)
unit = A.unit()
if generic:
sqs = adem.adem_basis_elt_generic_map(P_fn=A.P,
b=A.Q(0),
basis_elt=basis_elt)
else:
sqs = [A.Sq(i) for i in basis_elt]
return reduce(lambda a, b: a * b, sqs, unit)
def adem_basis_act(module_basis_elt, adem_basis_elt, *, module):
"""
This is for handing to linearly_extend_map. The argument module will be filled by
basis_elt.algebra which will be a Steenrod_Module.
algebra -- will be this.
"""
sqs = adem_basis_elt
if module.generic:
sqs = adem.adem_basis_elt_generic_map(P_fn=lambda P: P,
b='b',
basis_elt=adem_basis_elt)
sqs = sqs[::-1] # Reverse
module_vector = module.getBasisElement(module_basis_elt)
result = reduce(module.sq_act_on_vector, sqs, module_vector)
return result