def check_toric(): global toric # arff ! import qupy.ldpc.solve import bruhat.solve qupy.ldpc.solve.int_scalar = bruhat.solve.int_scalar from bruhat.solve import shortstr, zeros2, dot2, array2, solve from numpy import alltrue, zeros, dot l = argv.get("l", 2) from qupy.ldpc.toric import Toric2D toric = Toric2D(l) Hx, Hz = toric.Hx, toric.Hz assert alltrue(dot2(Hx, Hz.transpose()) == 0) from qupy.condmat.isomorph import Tanner, search src = Tanner.build2(Hx, Hz) #tgt = Tanner.build2(Hx, Hz) tgt = Tanner.build2(Hz, Hx) # weak duality mx, n = Hx.shape mz, n = Hz.shape fns = [] perms = [] for fn in search(src, tgt): assert len(fn) == mx + mz + n bitmap = [] for i in range(n): bitmap.append(fn[i + mx + mz] - mx - mz) perm = tuple(bitmap) #print(bitmap) fixed = [i for i in range(n) if bitmap[i] == i] print("perm:", perm) print("fixed:", fixed) g = Perm(perm, list(range(n))) assert g.order() == 2 perms.append(perm) for hx in Hx: print(toric.strop(hx)) print("--->") hx = array2([hx[i] for i in perm]) print(toric.strop(hx)) print("--->") hx = array2([hx[i] for i in perm]) print(toric.strop(hx)) print() check_dualities(Hz, Hx.transpose(), perms)
def get_perms(items, parts): perms = [] for part in parts: for i in range(len(part) - 1): perm = dict((item, item) for item in items) perm[part[i]] = part[i + 1] perm[part[i + 1]] = part[i] perm = Perm(perm, items) perms.append(perm) if not perms: # identity perms = [Perm(dict((item, item) for item in items), items)] G = Group.generate(perms) return G
def petersen_graph(R=2.0, r=1.0): nodes = range(10) layout = {} w = 2 * pi / 6 for i in range(6): layout[i] = R * cos(w * i), R * sin(w * i) w = 2 * pi / 3 for i in range(6, 9): layout[i] = r * sin(w * i), -r * cos(w * i) layout[9] = (0., 0.) edges = [(i, (i + 1) % 6) for i in range(6)] for i in range(3): edges.append((6 + i, 9)) edges.append((6 + i, 2 * i)) edges.append((6 + i, (2 * i + 3) % 6)) if 0: # TODO: should be able to construct G from all graph # automorphisms. Choose the ones that preserve the distance between nodes. perm = {} for i in range(6): perm[i] = (i + 2) % 6 for i in range(3): perm[i + 6] = (i + 1) % 3 + 6 perm[9] = 9 g = Perm(perm, nodes) perm = {0: 3, 1: 2, 2: 1, 3: 0, 4: 5, 5: 4, 6: 6, 7: 8, 8: 7, 9: 9} h = Perm(perm, nodes) G = Group.generate([g, h]) assert len(G) == 6 yield Graph(nodes, edges, layout) # ------------ edges = [(i, (i + 1) % 5) for i in range(5)] for i in range(5): edges.append((i, i + 5)) edges.append((i + 5, (i + 2) % 5 + 5)) w = 2 * pi / 5 layout = {} for i in range(5): layout[i] = R * sin(w * i), R * cos(w * i) layout[i + 5] = r * sin(w * i), r * cos(w * i) yield Graph(nodes, edges, layout)
def orbiplex(G, k=4): #import numpy #from gelim import zeros, dotx, rank, nullity print("orbiplex: |G|=%d" % len(G)) items = G.items k = argv.get("k", k) for n in range(k): write("|C_%d| ="%n) #if n > len(items): # break tpls = list(uniqtuples(items, n)) perms = [] for perm in G: _perm = {} for key in tpls: value = tuple(perm[i] for i in key) _perm[key] = value _perm = Perm(_perm, tpls) perms.append(_perm) G2 = Group(perms, tpls) orbits = list(G2.orbits()) d = len(orbits) write("%d,"%d)
def test_hom(): ring = element.Q n = argv.get("n", 3) V = Space(ring, n) # build action of symmetric group on the space V items = list(range(n)) gen1 = [] gen2 = [] for i in range(n - 1): perm = dict((item, item) for item in items) perm[items[i]] = items[i + 1] perm[items[i + 1]] = items[i] g = Perm(perm, items) gen1.append(g) A = elim.zeros(ring, n, n) for k, v in perm.items(): A[v, k] = ring.one lin = Lin(V, V, A) gen2.append(lin) perms = mulclose(gen1) G = Group(perms, items) #print(G) action = mulclose_hom(gen1, gen2) for g in G: for h in G: assert action[g * h] == action[g] * action[h] # check it's a group hom
def __init__(self, roots, gen, simple=None, name=None, order=None, check=True): #assert self.__class__ != Weyl # hmmm... do we need this? self.roots = roots # list of tuples self.gen = gen # list of Weyl group generators (Perm's) self.identity = Perm.identity(roots, '') self.simple = simple for g in gen: assert g * g == self.identity self.n = len(gen) self.name = name self.order = order if self.simple is None: self.build_simple() assert self.simple is not None if check: self.check_simple()
def get_gens(self): labels = self.labels neighbors = self.neighbors ngens = self.ngens cosets = [] # act on these for idx, row in enumerate(neighbors): jdx = self.get_label(idx) if idx == jdx: cosets.append(idx) n = len(cosets) #print("cosets:", n) lookup = dict((v, k) for (k, v) in enumerate(cosets)) gens = [] items = list(range(n)) for i in range(ngens): perm = {} for idx in cosets: nbd = neighbors[idx] assert nbd[i] is not None, nbd src, tgt = lookup[idx], lookup[self.get_label(nbd[i])] assert perm.get(src) is None perm[src] = tgt perm = Perm(perm, items) gens.append(perm) return gens
def get_autos(nxgraph): graph0 = mkgraph(nxgraph) graph1 = mkgraph(nxgraph) items = [point.idx for point in graph0] perms = [] for f in isomorph.search(graph0, graph1): perm = Perm(f, items) perms.append(perm) #print perm G = Group(perms, items) return G
def specht(n, space): assert n >= 2 d = len(space) ring = space.ring items = list(range(n)) gen1 = [] for i in range(n - 1): perm = dict((item, item) for item in items) perm[items[i]] = items[i + 1] perm[items[i + 1]] = items[i] perm = Perm(perm, items) gen1.append(perm) perms = mulclose(gen1) G = Group(perms, items) #I = space.ident # tensor power of the space tensor = lambda x, y: x @ y tspace = reduce(tensor, [space] * n) # build action of symmetric group on the tensor power thom = Hom(tspace, tspace) gen2 = [] for g in gen1: items = [] for idxs in tspace.gen: jdxs = tuple(idxs[g[i]] for i in range(len(idxs))) items.append(((idxs, jdxs), ring.one)) #print(idxs, "->", jdxs) #print() swap = Map(items, thom) gen2.append(swap) action = mulclose_hom(gen1, gen2) for g in G: for h in G: assert action[g * h] == action[g] * action[h] # check it's a group hom tp = Cat(G, ring) rep = Rep(action, tspace, tp) return rep
def make_group(ops): ops = list(ops) lookup = dict((numrepr(A), i) for (i, A) in enumerate(ops)) #for A in ops: # print(repr(numrepr(A))) items = list(range(len(ops))) perms = [] for i, A in enumerate(ops): perm = {} for j, B in enumerate(ops): C = dot(A, B) k = lookup[numrepr(C)] perm[j] = k perm = Perm(perm, items) perms.append(perm) G = Group(perms, items) return G
def cayley(elements): "build the regular permutation representation" elements = list(elements) lookup = {} for idx, e in enumerate(elements): lookup[e] = idx items = list(range(len(elements))) perms = [] for i, e in enumerate(elements): perm = {} for j, f in enumerate(elements): g = e*f k = lookup[g] perm[j] = k perm = Perm(perm, items) perms.append(perm) G = Group(perms, items) return G
def build_B(cls, n, k=1, **kw): roots = [] lookup = {} # long roots for i in range(n): for j in range(i + 1, n): for a in [-1, 1]: for b in [-1, 1]: root = [0] * n root[i] = a root[j] = b root = tuple(root) lookup[root] = len(roots) roots.append(root) # short roots for i in range(n): for a in [-1, 1]: root = [0] * n root[i] = a * k root = tuple(root) lookup[root] = len(roots) roots.append(root) assert len(lookup) == len(roots) assert len(roots) == 2 * n**2 gen = [] for i in range(n - 1): perm = [] for idx, root in enumerate(roots): _root = list(root) _root[i], _root[i + 1] = _root[i + 1], _root[i] # swap i, i+1 coords jdx = lookup[tuple(_root)] perm.append(jdx) perm = Perm(perm, roots) gen.append(perm) perm = [] for idx, root in enumerate(roots): _root = list(root) _root[n - 1] = -_root[n - 1] jdx = lookup[tuple(_root)] perm.append(jdx) perm = Perm(perm, roots) gen.append(perm) return Weyl_B(roots, gen, name="B_%d" % n, **kw)
def parabolic(roots, simple): "use _generators from reflections of simple roots" for root in simple: assert root in roots n = len(roots[0]) idxs = range(n) lookup = dict((root, i) for (i, root) in enumerate(roots)) gen = [] for alpha in simple: #print "alpha:", alpha r0 = sum(alpha[i]*alpha[i] for i in idxs) perm = [] for root in roots: #print " root:", root r = sum(alpha[i]*root[i] for i in idxs) _root = tuple(root[i] - 2*Fraction(r, r0)*alpha[i] for i in idxs) #print " _root:", _root perm.append(lookup[_root]) perm = Perm(perm, roots) gen.append(perm) return Group.generate(gen, items=roots)
def build_D(cls, n, **kw): assert n >= 2 roots = [] lookup = {} for i in range(n): for j in range(i + 1, n): for a in [-1, 1]: for b in [-1, 1]: root = [0] * n root[i] = a root[j] = b root = tuple(root) lookup[root] = len(roots) roots.append(root) assert len(lookup) == len(roots) assert len(roots) == 2 * n * (n - 1) gen = [] for i in range(n - 1): perm = [] for idx, root in enumerate(roots): _root = list(root) _root[i], _root[i + 1] = _root[i + 1], _root[i] # swap i, i+1 coords jdx = lookup[tuple(_root)] perm.append(jdx) perm = Perm(perm, roots) gen.append(perm) perm = [] for idx, root in enumerate(roots): _root = list(root) _root[n - 1], _root[n - 2] = -_root[n - 2], -_root[ n - 1] # swap & negate last two coords jdx = lookup[tuple(_root)] perm.append(jdx) perm = Perm(perm, roots) gen.append(perm) return Weyl_D(roots, gen, name="D_%d" % n, **kw)
def main(): name = argv.next() or "icosahedron" geometry = make_geometry(name) graph = geometry.get_bag() graph1 = geometry.get_bag() #print graph n = len(graph) items = [i for i in range(n) if graph[i].desc=="vert"] #print items perms = [] for f in isomorph.search(graph, graph1): #print f f = dict((i, f[i]) for i in items) perm = Perm(f, items) perms.append(perm) write('.') print("symmetry:", len(perms)) assert len(set(perms)) == len(perms) G = Group(perms, items) orbiplex(G)
def build_A(cls, n, **kw): roots = [] simple = [] lookup = {} for i in range(n + 1): for j in range(n + 1): if i == j: continue root = [0] * (n + 1) root[i] = 1 root[j] = -1 root = tuple(root) lookup[root] = len(roots) roots.append(root) if j == i + 1: simple.append(root) #assert len(pos_roots) == choose(n+1, 2) # number of positive roots assert len(lookup) == len(roots) assert len(roots) == n * (n + 1) gen = [] for i in range(n): perm = [] for idx, root in enumerate(roots): _root = list(root) _root[i], _root[i + 1] = _root[i + 1], _root[i] # swap i, i+1 coords jdx = lookup[tuple(_root)] perm.append(jdx) perm = Perm(perm, roots) gen.append(perm) return Weyl_A(roots, gen, simple, name="A_%d" % n, **kw)
def main(): # for name in """desargues_graph petersen_graph # dodecahedral_graph icosahedral_graph""".split(): name = argv.next() if name is None: return if name == "cayley": n = argv.get("n", 3) items = range(n) gen = [] for i in range(n - 1): perm = dict((item, item) for item in items) perm[items[i]] = items[i + 1] perm[items[i + 1]] = items[i] gen.append(perm) gen = [Perm(perm, items) for perm in gen] for g in gen: print(g) graph = cayley(gen) elif name == "transpositions": n = argv.get("n", 3) items = range(n) gen = [] for i in range(n - 1): for j in range(i + 1, n): perm = dict((item, item) for item in items) perm[items[i]] = items[j] perm[items[j]] = items[i] gen.append(perm) gen = [Perm(perm, items) for perm in gen] print("gen:", len(gen)) graph = cayley(gen) elif name == "cycles": n = argv.get("n", 3) items = range(n) gen = [] for i in range(n): for j in range(i + 1, n): for k in range(j + 1, n): perm = dict((item, item) for item in items) perm[items[i]] = items[j] perm[items[j]] = items[k] perm[items[k]] = items[i] gen.append(perm) perm = dict((item, item) for item in items) perm[items[i]] = items[k] perm[items[k]] = items[j] perm[items[j]] = items[i] gen.append(perm) gen = [Perm(perm, items) for perm in gen] print("gen:", len(gen)) graph = cayley(gen) else: builder = getattr(small, name, None) if builder is None: builder = getattr(classic, name, None) if builder is None: print(name, "not found") return n = argv.n if n is not None: graph = builder(n) else: graph = builder() print("|nodes|=%d, edges=|%d|" % (len(graph.nodes()), len(graph.edges()))) if argv.visualize: from visualize import draw_graph draw_graph(graph) return if argv.spec: print("spec:", ) spec = nx.adjacency_spectrum(graph) spec = [x.real for x in spec] spec.sort() print(' '.join("%5f" % x for x in spec)) return G = get_autos(graph) print("|G|=%d" % len(G)) if argv.all_subgroups: Hs = list(G.subgroups()) Hs.sort(key=lambda H: len(H)) else: Hs = [Group.generate([G.identity])] for H in Hs: print("|H|=%d" % len(H)) A = build_orbigraph(graph, H) print(A) spec = numpy.linalg.eigvals(A) spec = [x.real for x in spec] spec.sort(reverse=True) s = ' '.join(("%5f" % x).rjust(9) for x in spec) s = s.replace(".000000", "") print("spec:", s) print return
def hecke(self): bag0 = self.get_bag() bag1 = self.get_bag() points = [p for p in bag0 if p.desc == '0'] lines = [p for p in bag0 if p.desc == '1'] print(points) print(lines) flags = [] for p in points: ls = [l for l in p.nbd if l != p] print(p, ls) for l in ls: flags.append((p, l)) print("flags:", len(flags)) # for point in bag0: # print point, repr(point.desc) #items = [(point.idx, line.idx) for point in points for line in lines] #items = [(a.idx, b.idx) for a in points for b in points] items = [(a, b) for a in flags for b in flags] # fixing two points gives the Klein four group, Z_2 x Z_2: #for f in isomorph.search(bag0, bag1): # if f[0]==0 and f[1]==1: # print f perms = [] for f in isomorph.search(bag0, bag1): #print f g = dict((bag0[idx], bag0[f[idx]]) for idx in list(f.keys())) perm = {} for a, b in items: a1 = (g[a[0]], g[a[1]]) b1 = (g[b[0]], g[b[1]]) assert (a1, b1) in items perm[a, b] = a1, b1 perm = Perm(perm, items) perms.append(perm) write('.') print() g = Group(perms, items) print("group:", len(g)) orbits = g.orbits() #print orbits print("orbits:", len(orbits)) eq = numpy.allclose dot = numpy.dot n = len(flags) basis = [] gen = [] I = identity2(n) for orbit in orbits: A = zeros2(n, n) #print orbits for a, b in orbit: A[flags.index(a), flags.index(b)] = 1 print(shortstr(A)) print(A.sum()) #print basis.append(A) if A.sum() == 42: gen.append(A) assert len(gen) == 2 L = gen[0] P = gen[1] q = 2 assert eq(dot(L, L), L + q * I) assert eq(dot(P, P), P + q * I) assert eq(dot(L, dot(P, L)), dot(P, dot(L, P)))
def main(): p = argv.get("p", 3) deg = argv.get("deg", 1) field = FiniteField(p) if deg == 1: G = GL2(field) return base, field = field, field.extend(deg) assert len(field.elements) == p**deg print("GF(%d)"%len(field.elements)) print(field.mod) print() items = [a for a in field.elements if a!=0] perm = Perm(dict((a, a**p) for a in items), items) G = Group.generate([perm]) print("|G| =", len(G)) orbits = G.orbits() print("orbits:", len(orbits), end=", ") fixed = 0 for orbit in orbits: if len(orbit)==1: fixed += 1 print(len(orbit), end=" ") print() print("fixed points:", fixed) if 0: # find other solutions to the extension polynomial ring = PolynomialRing(field) poly = ring.evaluate(field.mod) assert str(poly) == str(field.mod) assert poly(field.x) == 0 subs = [] for a in field.elements: if poly(a) == field.zero: subs.append(a) print(a) return lin = Linear(deg, base) zero = field.zero one = field.one x = field.x a = one basis = [] for i in range(deg): basis.append(a) a = x*a for a in field.elements: if a == zero: continue op = [[0 for j in range(deg)] for i in range(deg)] for j, b in enumerate(basis): c = a*b poly = c.value # unwrap for i in range(deg): op[i][j] = poly[i] op = lin.get(op) print(str(op).replace("\n", ""), a) print() if argv.check: zero = field.zero div = {} for a in field.elements: for b in field.elements: c = a*b div[c, a] = b div[c, b] = a for a in field.elements: for b in field.elements: if b != zero: assert (a, b) in div
mul = set(items) for i in items: for j in items: if (i * j) % n: continue if i in mul: mul.remove(i) items = list(mul) items.sort() perms = [] for i in items: perm = dict((j, (j * i) % n) for j in items) perm = Perm(perm, items) perms.append(perm) G = Group(perms, items) print(" ", end="") for jdx, qerm in enumerate(perms): j = items[jdx] print("%3d" % j, end="") print() print(" ", "---" * len(items)) for idx, perm in enumerate(perms): i = items[idx] print("%3d" % i, end="") for jdx, qerm in enumerate(perms): j = items[jdx] kdx = perms.index(perm * qerm)
def test_monoid(G): "build the Coxeter-Bruhat monoid, represented as a monoid of functions." "this representation is not faithful." roots = G.roots print("roots:", len(roots)) weyl = G.generate() print("weyl:", ) for w in weyl: print(w.word, ) print() print("weyl:", len(weyl)) r0 = roots[0] bdy = set([r0]) seen = set() identity = dict((r, r) for r in roots) perms = [dict(identity) for g in gen] while bdy: _bdy = set() seen.update(bdy) for r0 in bdy: for i in range(n): g = gen[i] perm = perms[i] r1 = g * r0 assert perm.get(r0) == r0 if r1 not in seen: perm[r0] = r1 _bdy.add(r1) bdy = _bdy gen = [Perm(perms[i], roots, gen[i].word) for i in range(len(perms))] identity = Perm(identity, roots) for g in gen: print(g.str()) assert g * g == g monoid = mulclose_short([identity] + gen) print("monoid:", len(monoid)) #monoid = mulclose(monoid) #print "monoid:", len(monoid) desc = "ABCDEFG"[:n] def txlate(word): "monoid to weyl" g = identity for c in word: g = g * G.gen[desc.index(c)] return g monoid = list(monoid) monoid.sort(key=lambda g: (len(g.word), g.word)) for g in monoid: tgt = list(set(g.perm.values())) g = txlate(g.word) print("%6s" % g.word, len(tgt)) print() return m = G.matrix(desc) from coxeter import BruhatMonoid monoid = BruhatMonoid(desc, m, bruhat=True, build=True) #for w in monoid.words: # print w, #print def txlate(word): "_translate to function monoid" g = identity for c in word: g = g * gen[desc.index(c)] return g lookup = {} for w0 in monoid.words: g = txlate(w0) w1 = lookup.get(g) if w1 is not None: print(w0, "=", w1) else: lookup[g] = w0 print(w0) for w0 in monoid.words: for w1 in monoid.words: w2 = monoid.mul[w0, w1] if txlate(w0) * txlate(w1) == txlate(w2): pass else: print("%r*%r = %r" % (w0, w1, w2), ) print(" ****************** FAIL")
def test_young(): # code ripped from qu.py d = argv.get("d", 2) n = argv.get("n", 3) p = argv.get("p") if p is None: ring = element.Q else: ring = element.FiniteField(p) print("ring:", ring) space = Space(ring, d) # tensor power of the space tspace = reduce(matmul, [space] * n) # build action of symmetric group on the tensor power items = list(range(n)) gen1 = [] gen2 = [] for i in range(n - 1): perm = dict((item, item) for item in items) perm[items[i]] = items[i + 1] perm[items[i + 1]] = items[i] g = Perm(perm, items) gen1.append(g) lin = tspace.get_swap([g[i] for i in items]) #print(lin.hom) gen2.append(lin) perms = mulclose(gen1) G = Group(perms, items) #print(G) action = mulclose_hom(gen1, gen2) for g in G: for h in G: assert action[g * h] == action[g] * action[h] # check it's a group hom # Build the young symmetrizers projs = [] part = argv.get("part") parts = list(partitions(n)) if part is None else [part] for part in parts: assert sum(part) == n t = Young(G, part) rowG = t.get_rowperms() colG = t.get_colperms() horiz = None for g in rowG: P = action[g] horiz = P if horiz is None else (horiz + P) vert = None for g in colG: P = action[g] s = g.sign() P = ring.promote(s) * P vert = P if vert is None else (vert + P) A = horiz * vert assert vert * vert == len(colG) * vert assert horiz * horiz == len(rowG) * horiz #A = A.transpose() projs.append(A) print("part:", part) print(t) print("rank:", A.rank()) print("is_zero:", A.is_zero()) #if not A.is_zero(): # print(A) print()
def make_cyclic(n, check=False): R = PolynomialRing(Z) p = cyclotomic(R, n) #print(p) #print(p(R.x*2)) ring = R / p zeta = ring.x #print("zeta: %r"%zeta) izeta = zeta**(n - 1) # inverse #print(zeta, izeta) #print(zeta.conj()) #G = mulclose([zeta]) #for g in G: # print(g, end=" ") #print() #G = cayley(G) items = list(range(n)) perms = [] e = Perm(dict((i, i) for i in range(n)), items) a = Perm(dict((i, (i + 1) % n) for i in range(n)), items) perms = [e, a] for i in range(2, n): b = perms[-1] * a perms.append(b) G = Group(perms, items, check=True) # complex characters -------------------------------------------------- c_chars = [] for k in range(n): chi = dict((perms[i], zeta**(i * k)) for i in range(n)) chi = CFunc(G, chi) c_chars.append(chi) G.c_chars = c_chars for f in c_chars: for g in c_chars: r = f.dot(g) assert (f == g) == (r == 1) #print(f.dot(g), end=" ") #print() # real characters -------------------------------------------------- r_chars = [c_chars[0]] # triv if n % 2: for k in range(1, (n + 1) // 2): a = c_chars[k] + c_chars[n - k] r_chars.append(a) else: chi = dict((perms[i], (-1)**i) for i in range(n)) chi = CFunc(G, chi) r_chars.append(chi) for k in range(1, n // 2): #print("a = c_chars[k] + c_chars[n-k]") a = c_chars[k] + c_chars[n - k] r_chars.append(a) for f in r_chars: for g in r_chars: r = f.dot(g) assert (f == g) == (r != 0) #print(f.dot(g), end=" ") #print() G.r_chars = r_chars return G
def __init__(self, n, space): assert n >= 2 d = len(space) ring = space.ring items = list(range(n)) gen1 = [] for i in range(n - 1): perm = dict((item, item) for item in items) perm[items[i]] = items[i + 1] perm[items[i + 1]] = items[i] perm = Perm(perm, items) gen1.append(perm) perms = mulclose(gen1) G = Group(perms, items) #I = space.ident # tensor power of the space tensor = lambda x, y: x @ y tspace = reduce(tensor, [space] * n) # build action of symmetric group on the tensor power thom = Hom(tspace, tspace) gen2 = [] for g in gen1: items = [] for idxs in tspace.gen: jdxs = tuple(idxs[g[i]] for i in range(len(idxs))) items.append(((idxs, jdxs), ring.one)) #print(idxs, "->", jdxs) #print() swap = Map(items, thom) gen2.append(swap) action = mulclose_hom(gen1, gen2) for g in G: for h in G: assert action[ g * h] == action[g] * action[h] # check it's a group hom # Build the young symmetrizers projs = [] parts = [] for part in partitions(n): if len(part) > d: continue parts.append(part) t = Young(G, part) rowG = t.get_rowperms() colG = t.get_colperms() horiz = None for g in rowG: P = action[g] horiz = P if horiz is None else (horiz + P) vert = None for g in colG: P = action[g] s = g.sign() P = s * P vert = P if vert is None else (vert + P) A = vert * horiz + horiz * vert #A = horiz * vert assert vert * vert == len(colG) * vert assert horiz * horiz == len(rowG) * horiz #A = A.transpose() projs.append(A) #print(part) #print(t) #print(A) self.projs = projs self.parts = parts
def test_young0(): ring = element.Q n = argv.get("n", 3) part = argv.get("part", (1, 1, 1)) assert sum(part) == n V = Space(ring, n) # build action of symmetric group on the space V items = list(range(n)) gen1 = [] gen2 = [] for i in range(n - 1): perm = dict((item, item) for item in items) perm[items[i]] = items[i + 1] perm[items[i + 1]] = items[i] g = Perm(perm, items) gen1.append(g) A = elim.zeros(ring, n, n) for k, v in perm.items(): A[v, k] = ring.one lin = Lin(V, V, A) gen2.append(lin) perms = mulclose(gen1) G = Group(perms, items) #print(G) action = mulclose_hom(gen1, gen2) for g in G: for h in G: assert action[g * h] == action[g] * action[h] # check it's a group hom young = Young(G, part) rowG = young.get_rowperms() print("rowG", len(rowG)) colG = young.get_colperms() print("colG", len(colG)) horiz = None for g in rowG: P = action[g] horiz = P if horiz is None else (horiz + P) vert = None for g in colG: P = action[g] s = g.sign() P = ring.promote(s) * P vert = P if vert is None else (vert + P) A = horiz * vert assert vert * vert == len(colG) * vert assert horiz * horiz == len(rowG) * horiz print("part:", part) print(young) print("rank:", A.rank()) print("is_zero:", A.is_zero()) print(A) #if not A.is_zero(): # print(A) print()
def main(): #ring = element.Z ring = element.Q qubit = Space(2, ring) q2 = qubit @ qubit hom = Hom(qubit, qubit) I = Map.from_array([[1, 0], [0, 1]], hom) X = Map.from_array([[0, 1], [1, 0]], hom) Z = Map.from_array([[1, 0], [0, -1]], hom) H = X + Z E = Map.from_array([[0, 1], [0, 0]], hom) # raising F = Map.from_array([[0, 0], [1, 0]], hom) # lowering II = I @ I XI = X @ I IX = I @ X XX = X @ X assert XI * IX == XX CNOT = Map.from_array( [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]], hom @ hom) SWAP = Map.from_array( [[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]], hom @ hom) assert SWAP * SWAP == II assert CNOT * CNOT == II G = mulclose([XI, IX, CNOT]) # order 8 G = mulclose([XI, IX, CNOT, SWAP]) # order 24.. must be S_4 G = mulclose([CNOT, SWAP]) # print(len(G)) # for g in G: # print(g) A = SWAP @ I B = I @ SWAP S_3 = list(mulclose([A, B])) assert len(S_3) == 6 # for g in G: # print(g) # print(g.hom) hom = A.hom space = hom.src N = 2**3 basis = space.get_basis() orbits = set() for v in basis: v1 = space.zero_vector() for g in S_3: u = g * v v1 = v1 + u orbits.add(v1) orbits = list(orbits) # for v in orbits: # print(v) HHH = H @ H @ H v = basis[7] #print(v) #print(HHH * v) # ---------------------------------------------------------- specht = Specht(4, qubit) for i, A in enumerate(specht.projs): print("part:", specht.parts[i]) print("proj:") im = A.image() #im = A src, tgt = im.hom for i in src: for j in tgt: v = im[j, i] if v != ring.zero: print("%s*%s" % (v, j), end=" ") print() return # ---------------------------------------------------------- items = [0, 1, 2, 3] g1 = Perm({0: 1, 1: 0, 2: 2, 3: 3}, items) g2 = Perm({0: 0, 1: 2, 2: 1, 3: 3}, items) g3 = Perm({0: 0, 1: 1, 2: 3, 3: 2}, items) gen1 = [g1, g2, g3] s1 = SWAP @ I @ I s2 = I @ SWAP @ I s3 = I @ I @ SWAP gen2 = [s1, s2, s3] G = mulclose(gen1) hom = mulclose_hom(gen1, gen2) for g in G: for h in G: assert hom[g * h] == hom[g] * hom[h] # check it's a group hom projs = [] for part in [(4, ), (3, 1), (2, 2)]: t = Young(part) rowG = t.get_rowperms() colG = t.get_colperms() horiz = None for g in rowG: P = hom[g] horiz = P if horiz is None else (horiz + P) vert = None for g in colG: P = hom[g] s = g.sign() P = s * P vert = P if vert is None else (vert + P) A = vert * horiz #A = horiz * vert assert vert * vert == len(colG) * vert assert horiz * horiz == len(rowG) * horiz #print(t) #print(A) projs.append(A) for A in projs: for B in projs: assert A * B == B * A # print() # for A in projs: # for g in G: # P = hom[g] # if P*A != A*P: # print(P*A) # print(A*P) # return for A in projs: print("proj:") im = A.image() #im = A src, tgt = im.hom for i in src: for j in tgt: v = im[j, i] if v != ring.zero: print("%s*%s" % (v, j), end=" ") print()
def test_galois(): p = argv.get("p", 2) r = argv.get("r", 2) print("q =", p**r) F = GF(p**r) print("GF(%d) = GF(%d)[x]/(%s)" % (p**r, p, F.mod)) print("omega =", F.omega) omega = F.omega #assert omega**2 == omega + 1 els = F.elements assert len(els) == len(set(els)) == p**r for a in els: for b in els: if b != 0: c = a / b # XXX fails for p=3, r=4 assert c * b == a def orbit(a): items = set([a]) while 1: a = F.frobenius(a) if a in items: break items.add(a) return items lookup = {e: i for (i, e) in enumerate(els)} for i, e in enumerate(els): print("%s: %s" % (i, e)) g = {lookup[e]: lookup[F.frobenius(e)] for e in els} #print(["%s:%s"%(k,v) for (k,v) in g.items()]) values = set(g.values()) assert len(values) == len(g) items = list(range(len(els))) g = Perm(g, items) I = Perm.identity(items) G = [I] h = g print(g) while h != I: G.append(h) h = g * h #print(len(G)) assert len(G) <= p**r print("|G| =", len(G)) G = Group.generate([g]) print("|G| =", len(G)) for i in els: n = len(orbit(i)) if n == 1: print("*", end="") print(n, end=" ") print() def inner(u, v): r = u * F.frobenius(v) - F.frobenius(u) * v return r print("els:", end=" ") for u in els: print(u, end=" ") print() print("inner(u,u):", end=" ") for u in els: print(inner(u, u), end=" ") print() print("inner(u,v):") for u in els: for v in els: print(inner(u, v), end=" ") print() print() for u in els: #print([int(inner(u,v)==0) for v in els]) for v in els: i = int(inner(u, v) == 0) print(i or '.', end=" ") print() print("test_galois: OK")
""" from bruhat.action import Perm, Group from bruhat.util import factorial from bruhat.argv import argv p = argv.get("p", 5) if 0: items = [i for i in range(1, p**2) if i % p] print(items) perms = [] for i in items: perm = dict((j, (j * i) % p**2) for j in items) perms.append(Perm(perm, items)) G = Group(perms, items) print(len(G)) print(G.is_cyclic()) def div(a, b): # a/b = c mod p # a = c*b mod p assert 0 <= a < p assert 0 < b < p for c in range(p): if a == (c * b) % p: return c