def _my_indices(d: int, m: tuple):
""" return an iterator of tuples for the Cartan formula for chiPsQ_mon """
if len(m) == 0:
return
elif len(m) == 1:
if m[0] >= d and binom_mod2(m[0], d):
yield m[0] - d,
return
for i in range(min(d, m[0]) + 1):
if binom_mod2(m[0], i):
for t in _my_indices(d - i, m[1:]):
yield (m[0] - i, ) + t
def PQ_mon(r: int, m: tuple) -> DyerLashof:
""" return P^rQ^m x assuming P^r x=0 for r > 0 """
if len(m) == 0:
return DyerLashof.unit() if r == 0 else DyerLashof.zero()
elif len(m) == 1:
return DyerLashof.gen(m[0] -
r) if binom_mod2(r, m[0] -
2 * r) else DyerLashof.zero()
else:
s = m[0] # recursive
return sum((DyerLashof.gen(s - r + i) * PQ_mon(i, m[1:])
for i in range(max(0, r - s // 2), r // 2 + 1)
if binom_mod2(r - 2 * i, s - 2 * r + 2 * i)),
DyerLashof.zero())
def diff(self):
data = set()
for m in self.data:
for i in range(len(m)):
data ^= {
m[:i] + (m[i] - j, j - 1) + m[i + 1:]
for j in range(1, m[i] // 2 + 1)
if binom_mod2(m[i] - 2 * j, j)
}
return LambdaAlg(data).simplify()
def adem(mon: tuple, index: tuple) -> Set[tuple]:
if index[1] == 0:
return {tuple(sorted(mon))}
elif index[1] == 1:
i = index[0]
return {tuple(sorted(mon[0:i] + mon[i + 2:] + (0, mon[i] * 2)))}
elif index[1] == 2:
i = index[0]
r, s = mon[i], mon[i + 1]
return {mon[0:i] + m + mon[i + 2:] for m in _my_adem(r, s)}
elif index[1] == 3:
i = index[0]
n = 0
while mon[i] % (1 << n) == 0:
n += 1
I, s = mon[:n], mon[i]
return {
tuple(I[j] - J[j]
for j in range(n)) + mon[n:i] + (s + k, ) + mon[i + 1:]
for k in range(1 << n - 1,
sum(I) + 1, 1 << n - 1)
if binom_mod2(k + (1 << n - 1), s)
for J in _indexing_set(I, k) if _is_good(I)
} # ##################
def _my_adem(r: int, s: int) -> Set[tuple]:
""" The Adem relation for \sR. Assert r <= s """
assert r <= s
if s % 2:
return {(r - k, s + k)
for k in range(1, r + 1, 2) if binom_mod2(k + 1, s)}
if r % 2:
result = set()
for r1, s1 in _my_adem(2 * r, 2 * s):
result ^= {(r1 >> 1, s1 >> 1)} if not s1 & 2 else _my_adem(
r1 >> 1, s1 >> 1)
return result
n = r.bit_length() - 1
if n == s.bit_length() - 1:
# s = 2^n - 2^m + ...
m = n
while binom_mod2(1 << m - 1, s) == 0:
m -= 1
if r < (1 << n) + (1 << m - 1):
set1 = {(r - (1 << n) + k, s + (1 << n) - k)
for k in range(2, (1 << n) - (1 << (m - 1)) + 2, 2)
if binom_mod2(k, r - 1)}
set2 = {(s - (1 << n) + k, r + (1 << n) - k)
for k in range(2, (1 << m - 1) + 2, 2)
if binom_mod2(k, s - 1)}
return set1 ^ set2 ^ {(0, r + s)}
else:
set1 = {(r - (1 << n) + k, s + (1 << n) - k)
for k in range(2, (1 << n + 1) - r, 2)
if binom_mod2(k, r - 1)}
set2 = {(s - (1 << n) + k, r + (1 << n) - k)
for k in range(2, (1 << n + 1) - s, 2)
if binom_mod2(k, s - 1)}
return set1 ^ set2 ^ {(0, r + s)}
else:
if binom_mod2(1 << n, s) == 0: # s = 2^{n+1} + 2^n + ...
return {(r1 + (1 << n), s1 + (1 << n + 1))
for r1, s1 in _my_adem(r - (1 << n), s - (1 << n + 1))}
elif binom_mod2(1 << n - 1, r): # r = 2^n + r_1, r_1 < 2^{n-2}
set1 = _my_adem(r - (1 << n - 1), s - (1 << n)) # recursive
set2 = {(r1, s1 + (3 << n-1)) for r1, s1 in set1} ^ \
{(r1 + (1 << n - 1), s1 + (1 << n)) for r1, s1 in set1} ^ \
{(r - (1 << n - 1), s + (1 << n-1))}
return set2
else: # r = 2^n + 2^{n-1} + ..., s = 2^{n+1} + s_1 + ..., s_1 < 2^n
if s < (0b101 << n - 1):
set1 = {(r - (1 << n) + k, s + (1 << n) - k)
for k in range(2, (1 << n + 1) - r, 2)
if binom_mod2(k, r - 1)}
set2 = {(s - (1 << n + 1) + k, r + (1 << n + 1) - k)
for k in range(2, (1 << n) * 3 - s, 2)
if binom_mod2(k, s - 1)}
return set1 ^ set2 ^ {(s - (1 << n), r + (1 << n))}
else: # r = 2^n + 2^{n-1} + ..., s = 2^{n+1} + 2^{n-1} + ...
if r - (1 << n) <= s - (1 << n + 1):
# s = 2^{n+1} + 2^n - 2^m + ...
m = n - 1
while (1 << m - 1) & s:
m -= 1
if r < (3 << n - 1) + (1 << m - 1):
set1 = {(r - (1 << n) + k, s + (1 << n) - k)
for k in range((1 << n - 1) - (1 << m - 1) +
2, (1 << n + 1) - r + 2, 2)
if binom_mod2(k, r - 1)}
set2 = {(s - (1 << n + 1) + k, r + (1 << n + 1) - k)
for k in range(2, (1 << m - 1) + 2, 2)
if binom_mod2(k, s - 1)}
set3 = {(r - (1 << n - 1) + k, s + (1 << n - 1) - k)
for k in range(2, (1 << n - 1) - (1 << m - 1) +
2, 2) if binom_mod2(k, r - 1)}
set4 = {(s - (3 << n - 1) + k, r + (3 << n - 1) - k)
for k in range(2, (1 << m - 1) + 2, 2)
if binom_mod2(k, s - 1)}
return set1 ^ set2 ^ set3 ^ set4
else:
set2 = {(s - (1 << n + 1) + k, r + (1 << n + 1) - k)
for k in range(2, (3 << n) - s + 2, 2)
if binom_mod2(k, s - 1)}
set3 = {(r - (1 << n - 1) + k, s + (1 << n - 1) - k)
for k in range(2, (1 << n + 1) - r + 2, 2)
if binom_mod2(k, r - 1)}
set4 = {(s - (3 << n - 1) + k, r + (3 << n - 1) - k)
for k in range(2, (3 << n) - s + 2, 2)
if binom_mod2(k, s - 1)}
return set2 ^ set3 ^ set4
else:
# r = 2^{n+1}-2^m
m = n - 1
while (1 << m - 1) & r:
m -= 1
if s < (0b101 << n - 1) + (1 << m - 1):
set1 = {(r - (1 << n) + k, s + (1 << n) - k)
for k in range((1 << m - 1) + 2, (1 << n + 1) -
r + 2, 2)
if binom_mod2(k, r - 1)}
set2 = {(s - (1 << n + 1) + k, r + (1 << n + 1) - k)
for k in range(2, (1 << n - 1) - (1 << m - 1) +
2, 2) if binom_mod2(k, s - 1)}
set3 = {(r - (1 << n - 1) + k, s + (1 << n - 1) - k)
for k in range(2, (1 << m - 1) + 2, 2)
if binom_mod2(k, r - 1)}
set4 = {(s - (3 << n - 1) + k, r + (3 << n - 1) - k)
for k in range(2, (1 << n - 1) - (1 << m - 1) +
2, 2) if binom_mod2(k, s - 1)}
return set1 ^ set2 ^ set3 ^ set4
else:
set2 = {(s - (1 << n + 1) + k, r + (1 << n + 1) - k)
for k in range(2, (3 << n) - s + 2, 2)
if binom_mod2(k, s - 1)}
set3 = {(r - (1 << n - 1) + k, s + (1 << n - 1) - k)
for k in range(2, (1 << n + 1) - r + 2, 2)
if binom_mod2(k, r - 1)}
set4 = {(s - (3 << n - 1) + k, r + (3 << n - 1) - k)
for k in range(2, (3 << n) - s + 2, 2)
if binom_mod2(k, s - 1)}
return set2 ^ set3 ^ set4
def adem(mon, i):
return set(
(mon[:i] + (mon[i + 1] - mon[i] - 1 - k, 2 * mon[i] + 1 + k) +
mon[i + 2:]) for k in range(mon[i + 1] // 2 - mon[i])
if binom_mod2(mon[i + 1] - 2 * (mon[i] + 1 + k), k) == 1)