def test(): n = 9 G = Group.symmetric(n) t = Young(G, (4, 3, 1, 1)) assert t.rows == [[0, 1, 2, 3], [4, 5, 6], [7], [8]] assert t.cols == [[0, 4, 7, 8], [1, 5], [2, 6], [3]] G = t.get_rowperms() assert len(G) == factorial(4) * factorial(3)
def test(): ring = element.Q n = argv.get("n", 3) G = Group.symmetric(n) tp = Cat(G, ring) burnside(tp) return rep = Rep.perm_rep(G, cat) rep.check() r2 = rep @ rep r2.check() r2.dump()
def test(): ring = element.Q n = argv.get("n", 3) d = argv.get("d", 2) G = Group.symmetric(n) algebra = GroupAlgebra(G, ring) v = algebra.zero for g in G: v = v + g assert 2 * v == v + v assert v - v == algebra.zero for g in algebra.basis: assert g * v == v assert v * g == v center = algebra.get_center() for v in center: for g in algebra.basis: assert g * v == v * g # --------------------------------------- # build standard representation of symmetric group act = G.left_action(list(range(n))) #print(act) tp = Cat(G, ring) rep = Rep.mk_rep(act, tp) #rep.dump() module = algebra.extend(rep) #print(module.action(v)) # --------------------------------------- # build representation of symmetric group on tensor product space = Space(d, ring) rep = tensor_rep(G, space) #rep.check() module = algebra.extend(rep) #print(module.action(v)) # --------------------------------------- # Build the young symmetrizers projs = [] part = argv.get("part") parts = [part] if part else partitions(n) for part in parts: items = G.items A = algebra.zero for g in G: labels = [g[item] for item in items] tableau = Young(G, part, labels) P = algebra.get_symmetrizer(tableau) A = A + P #tableau = Young(G, part) #A = algebra.get_symmetrizer(tableau) print("partition:", part) #print("H:") #print(module.action(H)) #print("V:") #print(module.action(V)) print([g * A == A * g for g in algebra.basis]) specht = [] for v in algebra.basis: u = v * A specht.append(u.to_array()) hom = Space(len(G), ring).endo_hom() specht = Map.from_array(specht, hom) specht = specht.image() #print(specht) dim = specht.shape[1] print("S(n)-algebra dim:", dim) if len(part) > d: continue print("A:", A) P = module.action(A) #P = P.transpose() P = P.image() print(P.longstr()) print(P.shape) return print("multiplicity:", P.shape[1]) src = P.src for v in src.get_basis(): u = P * v #print(u.longstr()) items = [] for g in algebra.basis: g = module.action(g) w = g * u #print(w.longstr()) items.append(w) A = find_span(items) print("dimension:", A.shape[1])
#!/usr/bin/env python3 """ Verifying that the normalizer of a subgroup is the automorphism group of the corresponding G-set. """ from bruhat.action import Group, Perm from bruhat.argv import argv G = Group.symmetric(4) print(len(G)) Hs = G.subgroups() print(len(Hs)) def setpromote(items): if isinstance(items, Perm): items = {items} else: items = set(items) for item in items: assert isinstance(item, Perm) return items def setmul(*itemss): items = itemss[0] items = setpromote(items)
def super_young(U, V, part): ring = U.ring n = sum(part) lookup = {} summands = [] for idxs in cross([(0, 1)] * n): spaces = [[U, V][idx] for idx in idxs] space = reduce(matmul, spaces) lookup[idxs] = len(summands) summands.append(space) #print(idxs, end=" ") #print(space.n) src = reduce(add, summands) G = Group.symmetric(n) hom = {} colim = src.identity() for action in G: perm = tuple(action[i] for i in range(n)) #print(perm) sumswap = [None] * len(summands) fs = [] for i, idxs in enumerate(cross([(0, 1)] * n)): jdxs = tuple(idxs[i] for i in perm) #print(idxs, "-->", jdxs) sumswap[lookup[jdxs]] = i space = src.items[i] f = space.get_swap(perm) fs.append(f) #print(sumswap) f = reduce(dsum, fs) #print(f.src.name, "-->", f.tgt.name) g = f.tgt.get_swap(sumswap) #print(g.src.name, "-->", g.tgt.name) assert f.tgt == g.src assert g.tgt == src hom[action] = (g, f) #print() young = Young(G, part) #print("Young:") #print(young) rowperms = young.get_rowperms() colperms = young.get_colperms() #print("rowperms", len(rowperms)) #print("colperms", len(colperms)) horiz = None for action in rowperms: (g, f) = hom[action] gf = g * f horiz = gf if horiz is None else (horiz + gf) assert horiz is not None vert = None for action in colperms: sign = action.sign() * ring.one g, f = hom[action] g = sign * g gf = g * f vert = gf if vert is None else (vert + gf) assert vert is not None P = horiz * vert P = P.row_reduce() #print(P.rank()) #print(P) #for a in src.items: # print(a) even = src.identity() odd = src.identity() i = 0 j = 0 for space in src.items: j += space.n while i < j: if space.grade % 2 == 0: odd[i, i] = ring.zero else: even[i, i] = ring.zero i += 1 return (P * even).rank(), (P * odd).rank()
def main(): ring = element.Q zero = ring.zero one = ring.one n = argv.get("n", 3) if argv.cyclic: G = Group.cyclic(n) else: G = Group.symmetric(n) comm = G.is_abelian() print(G) d = len(G) K = Space(ring, 1, name="K") V = Space(ring, d, name="V") VV = V @ V scalar = K.identity() I = V.identity() swap = VV.get_swap() lunit = Lin(V, K @ V, elim.identity(ring, d)) runit = Lin(V, V @ K, elim.identity(ring, d)) cap = Lin(K, V @ V) # tgt, src cup = Lin(V @ V, K) # tgt, src for i in range(d): cup[i + d * i, 0] = one cap[0, i + d * i] = one # green spiders g_ = Lin(K, V) # uniform discard _g = Lin(V, K) # uniform create g_gg = Lin(VV, V) # copy gg_g = Lin(V, VV) # pointwise mul for i in range(d): g_[0, i] = one _g[i, 0] = one g_gg[i + d * i, i] = one gg_g[i, i + d * i] = one eq = lambda lhs, rhs: lhs.weak_eq(rhs) assert eq(g_gg >> (g_ @ I), I) # counit assert eq(g_gg >> (I @ g_), I) # counit assert eq(g_gg >> (g_gg @ I), g_gg >> (I @ g_gg)) # coassoc assert eq(gg_g * (_g @ I), I) # unit assert eq(gg_g * (I @ _g), I) # unit assert eq(gg_g * (gg_g @ I), gg_g * (I @ gg_g)) # assoc assert eq((g_gg @ I) >> (I @ gg_g), (I @ g_gg) >> (gg_g @ I)) # frobenius assert eq((g_gg @ I) >> (I @ gg_g), gg_g >> g_gg) # extended frobenius assert eq(_g >> g_, d * scalar) assert eq(gg_g >> g_, cap) assert eq(_g >> g_gg, cup) # red spiders r_ = Lin(K, V) # discard unit _r = Lin(V, K) # create unit r_rr = Lin(VV, V) # comul rr_r = Lin(V, VV) # mul # hopf involution inv = Lin(V, V) lookup = dict((v, k) for (k, v) in enumerate(G)) for i in range(d): g = G[i] if g.is_identity(): r_[0, i] = one _r[i, 0] = one inv[lookup[~g], i] = one for j in range(d): h = G[j] gh = g * h k = lookup[gh] rr_r[k, i + j * d] = one r_rr[i + j * d, k] = one assert eq(r_rr >> (r_ @ I), I) # unit assert eq(r_rr >> (I @ r_), I) # unit assert eq(r_rr >> (r_rr @ I), r_rr >> (I @ r_rr)) # assoc assert eq(rr_r * (_r @ I), I) # unit assert eq(rr_r * (I @ _r), I) # unit assert eq(rr_r * (rr_r @ I), rr_r * (I @ rr_r)) # assoc assert eq((r_rr @ I) >> (I @ rr_r), (I @ r_rr) >> (rr_r @ I)) # frobenius assert eq((r_rr @ I) >> (I @ rr_r), rr_r >> r_rr) # extended frobenius assert eq((_r >> r_), scalar) assert not eq(rr_r >> r_, cap) assert not eq(_r >> r_rr, cup) # K[G] is a bialgebra assert eq(rr_r >> g_, g_ @ g_) assert eq(_r >> g_gg, _r @ _r) assert eq(_r >> g_, scalar) if not argv.skip: assert eq(rr_r >> g_gg, (g_gg @ g_gg) >> (I @ swap @ I) >> (rr_r @ rr_r)) print("K[G] is comm ", eq(swap >> rr_r, rr_r)) print("K[G] is cocomm", eq(g_gg >> swap, g_gg)) # K[G] is hopf rhs = g_ >> _r assert eq(g_gg >> (I @ inv) >> rr_r, rhs) assert eq(g_gg >> (inv @ I) >> rr_r, rhs) # k^G is a bialgebra assert eq(gg_g >> r_, r_ @ r_) assert eq(_g >> r_rr, _g @ _g) assert eq(_g >> r_, scalar) if not argv.skip: assert eq(gg_g >> r_rr, (r_rr @ r_rr) >> (I @ swap @ I) >> (gg_g @ gg_g)) # k^G is hopf rhs = r_ >> _g assert eq(r_rr >> (I @ inv) >> gg_g, rhs) assert eq(r_rr >> (inv @ I) >> gg_g, rhs) print("k^G is comm ", eq(swap >> gg_g, gg_g)) print("k^G is cocomm ", eq(r_rr >> swap, r_rr)) #print(rr_r) #print(r_rr) # unimodular r_cup = _r >> r_rr g_cap = gg_g >> g_ assert eq(r_cup >> (I @ g_), _g) assert eq(r_cup >> (g_ @ I), _g) assert eq((I @ _r) >> g_cap, r_) assert eq((_r @ I) >> g_cap, r_) assert eq(inv, (I @ r_cup) >> (swap @ I) >> (I @ g_cap)) assert eq(inv, (r_cup @ I) >> (I @ swap) >> (g_cap @ I)) assert eq(r_rr >> rr_r, d * I) assert eq(g_gg >> gg_g, I) # special # complementary frobenius structures ? # Heunen & Vicary eq (6.4) lhs = (_r @ I) >> (r_rr @ g_gg) >> (I @ gg_g @ I) >> (I @ g_ @ I) >> ( I @ lunit) >> rr_r rhs = g_ >> _r assert eq(lhs, rhs) lhs = (I @ _r) >> (r_rr @ g_gg) >> (I @ gg_g @ I) >> (I @ g_ @ I) >> ( I @ lunit) >> rr_r #assert eq(lhs, rhs) # FAIL lhs = (_g @ I) >> (g_gg @ r_rr) >> (I @ rr_r @ I) >> (I @ r_ @ I) >> ( I @ lunit) >> gg_g rhs = r_ >> _g assert eq(lhs, rhs) lhs = (I @ _g) >> (g_gg @ r_rr) >> (I @ rr_r @ I) >> (I @ r_ @ I) >> ( I @ lunit) >> gg_g #assert eq(lhs, rhs) # FAIL # Heunen & Vicary eq (6.5) lhs = (_r @ I) >> (r_rr @ I) >> (I @ gg_g) >> (I @ g_) rhs = (I @ _r) >> (I @ r_rr) >> (gg_g @ I) >> (g_ @ I) assert eq(lhs, rhs) lhs = (_g @ I) >> (g_gg @ I) >> (I @ rr_r) >> (I @ r_) rhs = (I @ _g) >> (I @ g_gg) >> (rr_r @ I) >> (r_ @ I) assert eq(lhs, rhs) assert eq(r_rr, r_rr >> swap) == G.is_abelian() assert eq(rr_r, swap >> rr_r) == G.is_abelian() assert eq(_r >> r_rr, _r >> r_rr >> swap) assert eq(rr_r >> r_, swap >> rr_r >> r_)