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
