def main():
name = argv.next()
builder = getattr(small, name, None)
if builder is None:
builder = getattr(classic, name, None)
if builder is None:
builder = globals().get(name)
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())))
eigval = argv.get("eigval", 0)
nodes = list(graph.nodes())
edges = list(graph.edges())
nbd = dict((i, []) for i in nodes)
for i, j in edges:
nbd[i].append(j)
nbd[j].append(i)
print(edges)
print(nbd)
verbose = argv.verbose
G = get_autos(graph)
print("|G|", len(G))
valrange = argv.get("valrange")
if valrange:
vals = range(-valrange, 0) + range(1, valrange + 1)
else:
vals = argv.get("vals", [1, -1, 2, -2, 3, -3])
for vec in search(nodes, nbd, eigval, vals, verbose=verbose):
print("vec = ", strvec(vec))
H = get_stab(G, vec)
print("H:", len(H))
J = get_stab(G, vec, -1)
print("J:", len(J))
if argv.draw:
draw_graph(graph, vec)
break
if not argv.alleigs:
break
def main():
desc = argv.next()
assert desc
print("constructing %s" % desc)
assert "_" in desc, repr(desc)
name, idx = desc.split("_")
idx = int(idx)
attr = getattr(Weyl, "build_%s" % name)
G = attr(idx)
print(G)
e = G.identity
gen = G.gen
roots = G.roots
els = G.generate()
G = Group(els, roots)
print("order:", len(els))
ring = element.Z
value = zero = Poly({}, ring)
q = Poly("q", ring)
for g in els:
#print(g.word)
value = value + q**(len(g.word))
print(value.qstr())
n = len(gen)
Hs = []
for idxs in all_subsets(n):
print(idxs, end=" ")
gen1 = [gen[i] for i in idxs] or [e]
H = Group(mulclose(gen1), roots)
Hs.append(H)
gHs = G.left_cosets(H)
value = zero
for gH in gHs:
items = list(gH)
items.sort(key=lambda g: len(g.word))
#for g in items:
# print(g.word, end=" ")
#print()
g = items[0]
value = value + q**len(g.word)
#print(len(gH))
print(value.qstr())
G = Group(els, roots)
burnside(G, Hs)
def main():
desc = argv.next() or "B2"
n = int(desc[-1:])
if desc[0] == "A":
gen = build_An(n)
elif desc[0] == "B":
gen = build_Bn(n)
elif desc[0] == "D":
gen = build_Dn(n)
else:
print("no group desc found matching %s"%desc)
return
I = Op.identity(n)
zero = Op(n)
G = mulclose(gen)
print(len(G))
projs = []
for g in G:
if g==I:
continue
if g*g==I:
projs.append(posproj(g, I))
assert(len(set(projs))==len(projs))
#for H in search(projs):
# print("found")
pairs = []
for p in projs:
for q in projs:
if p*q != q*p:
pairs.append((p, q))
print("pairs:", len(pairs))
shuffle(pairs)
for (p1, q1) in pairs:
for (p2, q2) in pairs:
A = tensor(p1, p2)
B = tensor(q1, q2)
if A*B == B*A:
write(".")
print()
def main():
fn = argv.next()
if fn is not None:
fn = eval(fn)
else:
fn = sl_pascal
value = argv.get("q")
for row in range(7):
for col in range(row + 1):
p = fn(row, col)
if value is not None:
p = p.substitute({"q": value})
s = str(p).replace(" + ", "+")
else:
s = p.qstr("q")
#s = p.flatstr().replace(" + ", "+")
print(s, end=" ")
print()
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 main():
name = argv.next()
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())))
print(list(graph.nodes()))
print(list(graph.edges()))
if argv.pos_rand:
pts = pos_rand(graph)
elif argv.pos_circ:
pts = pos_circ(graph)
else:
pts = pos_circ(graph)
output = argv.get("output", "output")
if pts is not None:
draw_graph(graph, pts, output)
else:
print("failed to draw")
def burnside(tp): # make it a method
ring = tp.ring
G = tp.G
Hs = conjugacy_subgroups(G)
names = {}
letters = list(string.ascii_uppercase + string.ascii_lowercase)
letters.remove("O")
letters.remove("o")
letters = letters + [l + "'"
for l in letters] + [l + "''" for l in letters]
assert len(letters) >= len(Hs)
letters = letters[:len(Hs)]
for i, H in enumerate(Hs):
names[H] = "%s_0" % letters[i] # identity coset
acts = {}
for i, H in enumerate(Hs):
cosets = G.left_cosets(H)
assert len(G) == len(cosets) * len(H)
items = [names[H]]
letter = letters[i]
assert H in cosets
idx = 1
for gH in cosets:
if gH == H:
continue
name = "%s_%d" % (letter, idx)
names[gH] = name
items.append(name)
idx += 1
act = G.left_action(cosets)
assert act.src is G
act = act.rename(names, items)
act.name = letter
H.name = act.name
acts[letter] = act
assert len(act.components()) == 1 # transitive
#print act.tgt.perms
print(
"%s subgroup order = %d, number of cosets = %d, conjugates = %d" %
(act.name, len(H), len(cosets), len(H.conjugates)))
#print(list(names.values()))
reps = {}
for act in acts.values():
rep = Rep.mk_rep(act, tp)
reps[act.name] = rep
arg = argv.next() or "B*C"
assert "*" in arg
left, right = arg.split("*")
act0 = acts[left]
act1 = acts[right]
rep0 = reps[left]
rep1 = reps[right]
act2 = act0.pushout(act1)
rep = Rep.mk_rep(act2, tp)
U0 = Space(act0.items, ring)
U1 = Space(act1.items, ring)
UU = U0 @ U1
print(UU)
one = ring.one
hom = Hom(U0, U1)
for act in act2.components():
items = [((y, x), one) for (x, y) in act.items]
f = Map(items, hom)
print(f)
assert tp.is_hom(rep0, rep1, f)
print("kernel:")
g = f.kernel()
print(g)
print()
print("cokernel:")
g = f.cokernel()
print(g)
print()
disc.show_tiles(G)
p = path.circle(0, 0, 1)
cvs.clip(p)
cvs.stroke(p, [1.0 * thin])
#save("hyperbolic-55")
#save("fold-hyperbolic-55")
save("brings-curve")
print("OK")
print()
# -------------------------------------------------------------
if __name__ == "__main__":
from huygens import config
config(text="pdflatex",
latex_header=r"""
\usepackage{amsmath}
\usepackage{amssymb}
""")
from bruhat.argv import argv
name = argv.next() or "main"
fn = eval(name)
fn()
print("OK\n")
def test_all():
test_monoidal()
test_frobenius()
test_reassociate()
test_bialgebra()
test()
if __name__ == "__main__":
_seed = argv.get("seed")
if _seed is not None:
print("seed(%s)" % _seed)
seed(_seed)
profile = argv.profile
fn = argv.next() or "test_all"
print("%s()" % fn)
if profile:
import cProfile as profile
profile.run("%s()" % fn)
else:
fn = eval(fn)
fn()
print("OK")
print()
assert Zdag in pauli
assert Xdag in pauli
if d <= 3:
# slow..
lhs = atpow(X, d)
rhs = atpow(Z, d)
assert lhs * rhs == rhs * lhs
equ = {e: {g * e for g in phases} for e in pauli}
G = []
for i in range(d):
for j in range(d):
m = (X**i) * (Z**j)
G.append(m)
print(len(G))
for g in G:
for h in G:
i = int(g * h == h * g)
print(i or '.', end=" ")
print()
if __name__ == "__main__":
name = argv.next() or "test"
fn = eval(name)
fn()
graph = Schreier.make_D(N)
rels = list(graph.rels)
# add another reflection
rels.append((N, N))
for i in range(N - 2):
rels.append((i, N) * 2)
rels.append((N, N - 2, N, N - 1))
graph = Schreier(N + 1, rels)
graph.build()
assert len(graph) == 3840
if __name__ == "__main__":
profile = argv.profile
name = argv.next()
_seed = argv.get("seed")
if _seed is not None:
print("seed(%s)" % (_seed))
seed(_seed)
if profile:
import cProfile as profile
profile.run("%s()" % name)
elif name is not None:
fn = eval(name)
fn()
else:
test()
def main():
graph_name = argv.next()
fn = eval(graph_name)
n = argv.get("n")
if n is not None:
items = fn(int(n))
graph_name = graph_name + "_" + str(n)
else:
items = fn()
graphs = list(items)
layout = argv.get("layout", 0)
graph = graphs[layout]
if argv.autos:
G = graph.get_autos()
print("|autos| =", len(G))
#for g in G:
# print(g)
#break
if argv.draw:
graph.draw(name=graph_name)
return
autos = graph.get_autos()
isoms = graph.get_isoms()
print("|isoms| =", len(isoms))
A = graph.get_adjacency()
#print(A)
vals, vecs = numpy.linalg.eigh(A)
print("evals:", vals)
eigval = argv.get("eigval", vals[0])
name = argv.get("name", "output")
graph.draw(name=name)
for vec in graph.get_inteigs(eigval):
#print(vec)
count = 0
orbit = [vec]
for g in autos:
u = vec.act(g)
if u == vec:
count += 1
else:
orbit.append(u)
#dim = graph.get_dimension(orbit)
#print("count=%d, dim=%d" % (count, dim))
print(count, end=" ")
if argv.draw:
graph.draw(vec, name)
break
if count == 36:
graph.draw(vec, name)
break
print()
rep = Rep.perm_rep(G, cat)
rep.check()
r2 = rep @ rep
r2.check()
r2.dump()
def main():
ring = element.Z
space = Space(2, ring)
n = argv.get("n", 3)
rep = specht(n, space)
rep.check()
rep.dump()
if __name__ == "__main__":
fn = argv.next()
if fn:
fn = eval(fn)
fn()
else:
test()
def test_dimension():
name = argv.next() or "A2"
N = int(argv.next() or 4)
data = os.popen("./sl.sage %s %s"%(name, N)).read()
data = eval(data)
print(data)
data = numpy.array(data)
series = name[0]
n = int(name[1])
def Adim(*xs):
if len(xs)==1:
x = xs[0]
return x+1
#print("Adim", xs)
n = len(xs)
value = Adim(*xs[:-1])
#print("value =", value)
for i in range(n):
rhs = sum(xs[i:]) + n-i
#print(" *= sum(%s) + %s"%(xs[i:], n-i))
value *= rhs
div = factorial(n)
assert value%div == 0
value //= factorial(n)
#print(" =", value)
return value
def Cdim(*xs):
assert len(xs)>1
value = Adim(*xs)
if len(xs)==2:
return value * (xs[0] + 2*xs[1] + 3) // 3
if len(xs)==3:
a, b, c = xs
value *= (b+2*c+3)*(a+b+2*c+4)*(a+2*b+2*c+5)
div = 60
assert value%div == 0
value //= div
return value
if len(xs)==4:
a, b, c, d = xs
value *= (a+b+c+2*d+5)*(a+b+2*c+2*d+6)*(a+2*b+2*c+2*d+7)
value *= (b+c+2*d+4)*(b+2*c+2*d+5)*(c+2*d+3)
div = 5*6*7*4*5*3
assert value%div == 0
value //= div
return value
if name[0] == "A":
fn = Adim
elif name[0] == "B":
fn = Bdim
elif name[0] == "C":
fn = Cdim
else:
assert 0, name
idxs = tuple(range(N))
idxss = tuple(idxs for i in range(n))
result = numpy.zeros((N,)*n, dtype=int)
for idx in numpy.ndindex(result.shape):
value = fn(*idx)
result[idx] = value
print(result)
assert numpy.alltrue(data == result)
e = compose(H1, g1)
g2, J1 = coequalizer(f2, identity(f2.shape[0]), e)
assert eq(compose(H1, g1), compose(g2, J1))
assert is_zero(compose(J1, J0))
n = J1.shape[0]
J1t = J1.transpose()
mz = rank(J1t)
mx = rank(J0)
print("J1t:", J1t.shape, rank(J1t))
print(shortstr(J1t))
print("J0:", J0.shape)
print(shortstr(J0))
print("n:", n)
print("mz:", mz)
print("mx:", mx)
print("k =", n - mx - mz)
if __name__ == "__main__":
fn = argv.next() or "test"
fn = eval(fn)
fn()
print("OK")
main = setup()
main.append(cvs)
name = "frames/%.4d" % frame
main.writePNGfile("%s.png" % name)
if frame == 0:
main.writePDFfile("%s.pdf" % name)
print(".", end="", flush=True)
frame += 1
if nframes is not None and frame > nframes:
break
print("OK")
if __name__ == "__main__":
live = argv.live
frames = argv.next()
assert frames is not None, "please specify sequence name"
frames = eval(frames)
frames = frames()
if live:
Live(W, H, frames)
else:
main(frames)
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
