def test():
p = argv.get("p", 2)
ring = element.FiniteField(p)
space = Space(ring)
zeros = space.zeros
rand = space.rand
dot = space.dot
kron = space.kron
direct_sum = space.direct_sum
identity = space.identity
coequalizer = space.coequalizer
compose = space.compose
rank = space.rank
pseudo_inverse = space.pseudo_inverse
tensor_swap = space.tensor_swap
sum_swap = space.sum_swap
schur = space.schur
is_zero = space.is_zero
is_identity = space.is_identity
s = tensor_swap(3, 4)
si = tensor_swap(4, 3)
#print(shortstr(s))
assert eq(dot(si, s), identity(3 * 4))
assert eq(dot(s, si), identity(4 * 3))
m, n = 2, 3
A1 = rand(m, n, 1, 1)
A2 = rand(m, n, 1, 1)
B = kron(A1, A2)
for m in range(1, 5):
I = identity(m * m)
s = tensor_swap(m, m)
f = coequalizer(I, s)
assert eq(compose(s, f), f)
assert rank(f) == [1, 3, 6, 10][m - 1]
# ---------------------------------
m = argv.get("m", 3)
n = argv.get("n", 4)
if argv.toric:
A = zeros(m, m)
for i in range(m):
A[i, i] = ring.one
A[i, (i + 1) % m] = -ring.one
elif argv.surface:
A = zeros(m - 1, m)
for i in range(m - 1):
A[i, i] = ring.one
A[i, (i + 1) % m] = -ring.one
else:
A = rand(m, n, p - 1, p - 1)
if argv.transpose:
A = A.transpose()
print("A:")
print(shortstr(A))
n, m = A.shape
In = identity(n)
Im = identity(m)
H1s = kron(Im, A), -kron(A, Im)
H1 = numpy.concatenate(H1s, axis=0) # horizontal concatenate
H0s = kron(A, In), kron(In, A)
H0 = numpy.concatenate(H0s, axis=1) # horizontal concatenate
assert is_zero(dot(H0, H1))
assert H1.shape == (n * m + m * n, m * m)
assert H0.shape == (n * n, n * m + m * n)
f0 = -tensor_swap(n, n)
a = direct_sum(-tensor_swap(m, n), -tensor_swap(n, m))
b = sum_swap(n * m, m * n)
assert is_identity(compose(b, b))
f1 = compose(a, b)
assert is_identity(compose(f1, f1))
f2 = tensor_swap(m, m)
assert eq(compose(f2, H1), compose(H1, f1))
lhs, rhs = ((compose(f1, H0), compose(H0, f0)))
#print("lhs:")
#print(shortstr(lhs))
#print("rhs:")
#print(shortstr(rhs))
assert eq(compose(f1, H0), compose(H0, f0))
g0 = coequalizer(f0, identity(f0.shape[0]))
assert eq(compose(H0, g0), compose(f1, H0, g0))
e = compose(H0, g0)
g1, J0 = coequalizer(f1, identity(f1.shape[0]), e)
assert eq(compose(H0, g0), compose(g1, J0))
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)
def test():
i = 1j
I = Mobius()
g = Mobius(1., 2., 3., 7)
assert g*~g == I
K = Mobius.cayley()
assert K*~K == I
h = g.todisc()
assert g.is_sl()
#print(h)
for z in (h(1), h(-1), h(i), h(-i)):
assert abs(z*z.conjugate() - 1.) < EPSILON
assert h.is_su()
assert abs(h.det - 1.) < EPSILON, h.det
theta = 2*pi / 5
g = Mobius.rotate(theta)
assert g.order() == 5
p0, q0, r0 = 1., 2+i, 3+1.1*i
p1, q1, r1 = 5., 1.1*i, 7*i
g = Mobius.send(p0, q0, r0, p1, q1, r1)
assert abs(g(p0) - p1) < EPSILON
assert abs(g(q0) - q1) < EPSILON
assert abs(g(q0) - q1) < EPSILON
rnd = lambda : 2*random() - 1.
z = rnd() + rnd()*1j
C = Mobius(1, 0, 0, 1, True) # conjugation
assert abs(C(z) - z.conjugate()) < EPSILON
# test group action property
gs = [Mobius(rnd(), rnd(), rnd(), rnd(), bool(random()>0.5)) for i in range(10)]
for g in gs:
for h in gs:
z = rnd() + rnd()*1j
lhs = (g*h)(z)
rhs = g(h(z))
assert abs(lhs - rhs) < EPSILON
for g in gs:
h = ~g
assert g*h == I
z = rnd() + rnd()*1j
lhs = (g*h)(z)
rhs = g(h(z))
assert abs(lhs - rhs) < EPSILON
assert abs(lhs - z) < EPSILON
N = argv.get("N", 100)
gens = [Mobius(1, 1, 0, 1), Mobius(0, 1, -1, 0)]
G = Generator(gens, verbose=False, maxsize=N)
#gens = [Mobius(1, 2, 0, 1), Mobius(1, 0, -2, 1)]
#H = Generator(gens, verbose=False, maxsize=N)
ops = []
for g in G:
if g.a.real%3 == 1 and g.c.real%3 == 0 and g.d.real%3 == 1:
ops.append(g)
print(len(ops))
H = Generator(ops, maxsize=N)
if 0:
# ------------ {5,5} ------------------------
N = argv.get("N", 100)
gens = mktriangle(5, 2, 5)
G = Generator(gens, verbose=True, maxsize=N)
a, b = gens
assert a.order() == 10
assert b.order() == 4
assert (a*b).order() == 5
h = a*a*b
h = h*h
assert h.order() == None
H = Generator([h])
while len(H) < N:
for g in G:
h1 = g * h * (~g)
H.add(h1)
ops = list(H)
for h0 in ops:
for h1 in ops:
H.add(h0*h1)
print("|H| =", len(H))
# ------------ todisc ------------------------
gens = [g.todisc() for g in gens]
a, b = gens
print(a.inner_fixed())
print(b.inner_fixed())
print((a*b).inner_fixed())
def get_code():
name = argv.get("code")
code = None
if name == "toric":
G = parse("""
1.1.....
.1...1..
11.11...
.111..1.
1...11.1
""") # l=2 toric code X logops + X stabs
elif name == "toric3":
G = parse("""
.....1.....1.....1
............1.1.1.
.111..........1...
...111..........1.
1.....11...1......
..1....111........
....1....111......
......1.....11...1
........1....111..
..........1....111
""") # l=3 toric code X logops + X stabs
elif name == "steane":
G = parse("""
1111111
1111...
.1.11.1
..11.11
""")
elif name == "haah":
# triorthogonal matrix
G = parse("""
1111111.......
.......1111111
1.1.1.11.1.1.1
.11..11.11..11
...1111...1111
""")
G = parse("""
1.1.1.11.1.1.1
.11..11.11..11
...1111...1111
""")
G = parse("""
..............1111111111111111
......11111111........11111111
..1111....1111....1111....1111
.1..11..11..11..11..11..11..11
11.1.1.1.1.1.1.1.1.1.1.1.1.1.1
""")
elif name == "rm":
r = argv.get("r", 1)
m = argv.get("m", 3)
code = reed_muller(r, m)
if argv.puncture:
code = code.puncture(0)
elif name == "rand":
n = argv.get("n", 8)
m = argv.get("m", 4)
G = rand2(m, n)
code = Code(G)
else:
assert 0, "no code chosen"
if code is None:
code = Code(G)
if argv.dual:
code = code.get_dual()
return code
def search():
# Bravyi, Haah, 1209.2426v1 sec IX.
# https://arxiv.org/pdf/1209.2426.pdf
verbose = argv.get("verbose")
m = argv.get("m", 6) # _number of rows
k = argv.get("k", None) # _number of odd-weight rows
# these are the variables N_x
xs = list(cross([(0, 1)]*m))
maxweight = argv.maxweight
minweight = argv.get("minweight", 1)
xs = [x for x in xs if minweight <= sum(x)]
if maxweight:
xs = [x for x in xs if sum(x) <= maxweight]
N = len(xs)
lhs = []
rhs = []
# bi-orthogonality
for a in range(m):
for b in range(a+1, m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == x[b] == 1:
v[i] = 1
if v.sum():
lhs.append(v)
rhs.append(0)
# tri-orthogonality
for a in range(m):
for b in range(a+1, m):
for c in range(b+1, m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == x[b] == x[c] == 1:
v[i] = 1
if v.sum():
lhs.append(v)
rhs.append(0)
# # dissallow columns with weight <= 1
# for i, x in enumerate(xs):
# if sum(x)<=1:
# v = zeros2(N)
# v[i] = 1
# lhs.append(v)
# rhs.append(0)
if k is not None:
# constrain to k _number of odd-weight rows
assert 0<=k<m
for a in range(m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == 1:
v[i] = 1
lhs.append(v)
if a<k:
rhs.append(1)
else:
rhs.append(0)
A = array2(lhs)
rhs = array2(rhs)
#print(shortstr(A))
B = pseudo_inverse(A)
soln = dot2(B, rhs)
if not eq2(dot2(A, soln), rhs):
print("no solution")
return
if verbose:
print("soln:")
print(shortstr(soln))
soln.shape = (N, 1)
rhs.shape = A.shape[0], 1
K = array2(list(find_kernel(A)))
#print(K)
#print( dot2(A, K.transpose()))
#sols = []
#for v in span(K):
best = None
density = 1.0
size = 99*N
trials = argv.get("trials", 1024)
count = 0
for trial in range(trials):
u = rand2(len(K), 1)
v = dot2(K.transpose(), u)
#print(v)
v = (v+soln)%2
assert eq2(dot2(A, v), rhs)
if v.sum() > size:
continue
size = v.sum()
Gt = []
for i, x in enumerate(xs):
if v[i]:
Gt.append(x)
if not Gt:
continue
Gt = array2(Gt)
G = Gt.transpose()
assert is_morthogonal(G, 3)
if G.shape[1]<m:
continue
if 0 in G.sum(1):
continue
if argv.strong_morthogonal and not strong_morthogonal(G, 3):
continue
#print(shortstr(G))
# for g in G:
# print(shortstr(g), g.sum())
# print()
_density = float(G.sum()) / (G.shape[0]*G.shape[1])
#if best is None or _density < density:
if best is None or G.shape[1] <= size:
best = G
size = G.shape[1]
density = _density
if 0:
#sols.append(G)
Gx = even_rows(G)
assert is_morthogonal(Gx, 3)
if len(Gx)==0:
continue
GGx = array2(list(span(Gx)))
assert is_morthogonal(GGx, 3)
count += 1
print("found %d solutions" % count)
if best is None:
return
G = best
#print(shortstr(G))
for g in G:
print(shortstr(g), g.sum())
print()
print("density:", density)
print("shape:", G.shape)
G = linear_independent(G)
A = list(span(G))
print(strong_morthogonal(A, 1))
print(strong_morthogonal(A, 2))
print(strong_morthogonal(A, 3))
#print(shortstr(dot2(G, G.transpose())))
if 0:
B = pseudo_inverse(A)
v = dot2(B, rhs)
print("B:")
print(shortstr(B))
print("v:")
print(shortstr(v))
assert eq2(dot2(B, v), rhs)
fy = Rational(ring, 1-y**2, (1-y)**6)
cs = [fy[i] for i in range(5)]
assert cs == [1, 6, 20, 50, 105]
# course generating function for SL(3) irreps
f = Rational(ring, 1-x*y, (1-x)**3 * (1-y)**3)
cs = [[f[i,j] for i in range(4)] for j in range(4)]
assert cs == [[1, 3, 6, 10], [3, 8, 15, 24], [6, 15, 27, 42], [10, 24, 42, 64]]
if __name__ == "__main__":
_seed = argv.get("seed")
if _seed is not None:
seed(_seed)
profile = argv.profile
fn = argv.next()
if profile:
import cProfile as profile
profile.run("test()")
elif fn is None:
test()
else:
fn = eval(fn)
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 ball_seq():
import ode
from simulate import Sphere, Sim
mu = argv.get("mu", 0.)
sim = Sim(mu=mu, has_gravity=False)
sim.world.setGravity((0, -4., -1.0))
left = -width
right = 2 * width
walls = [
ode.GeomPlane(sim.space, (1, 0, 0), left),
ode.GeomPlane(sim.space, (-1, 0, 0), -right),
ode.GeomPlane(sim.space, (0, 0, 1), 0.), # bottom
]
#radius = 1.5
radius = 0.5 * (width / 10.)
# blue = color.rgb(0.4, 0.3, 0.9, 0.8)
# orange = color.rgb(0.8, 0.2, 0.2, 0.8)
person = loadsvg("person.svg")
cvs = canvas.canvas()
cvs.append(person)
person = AlignBox(CanBox(cvs), "center")
balls = []
def mkball(x, z):
ball = Sphere(sim, radius=radius)
ball.setPosition((x, radius, z))
balls.append(ball)
#print("balls:", len(balls))
rball = lambda: mkball(rnd(left + radius, right - radius), height + 2 *
radius + 40 * radius * random())
def rball_check(x0, y0, x1, y1):
if not balls:
return rball()
import kdtree
pts = []
for ball in balls:
x, _, y = ball.getPosition()
pts.append((x, y))
tree = kdtree.create(pts)
while 1:
x = rnd(x0, x1)
y = rnd(y0, y1)
nearest = tree.search_nn_dist((x, y), (1.9 * radius)**2)
if not nearest:
break
#print(".", end="")
mkball(x, y)
nballs = argv.get("nballs", 800)
#for i in range(400):
# rball_check(left+radius, radius, right-radius, 40*radius)
for i in range(nballs):
rball_check(left + radius, radius, right - radius, 80 * radius)
runner = sim.run()
speed = argv.get("speed", 1)
speed = int(speed)
scale = 1. / 4
frame = 0
while 1:
frame += 1
for _ in range(speed):
runner.__next__()
cvs = canvas.canvas()
if scale != 1.:
cvs.append(trafo.scale(scale, scale, 0.5 * width, 0.1 * height))
for ball in balls:
v = ball.getPosition()
x, _, y = v
#if x+radius < 0. or x-radius > width:
# continue
p = path.circle(x, y, radius)
cvs.fill(p, blue)
cvs.stroke(p)
#person.render(cvs, x, y)
yield cvs
if frame % 10 == 0 and len(balls) < 800:
rball_check(left + radius, 20 * radius, right - radius,
80 * radius)
if 100 < len(balls) and scale > 1. / 4:
scale *= 0.999
import sys, os
from math import floor
from mpmath import kleinj, mpc # sympy
import numpy
from PIL import Image
from bruhat.argv import argv
#z = mpc(1.0, 0.5)
#print(kleinj(z))
EPSILON = 1e-6
N = argv.get("N", 256)
tol = argv.get("tol", 0.5)
re0 = -1.
im0 = 1e-4
delta = 1. / N
r = 3**0.5
A = numpy.zeros((N, N, 3), dtype=numpy.uint8)
for i in range(N):
for j in range(N):
#z = mpc(re0 + 2*i*delta, im0 + 2*j*delta)
z = mpc(2 * (1 - EPSILON) * i / (N - 1) - 1.,
def sim_multi():
liness = []
n = None
ndice = 5
nframes = argv.get("nframes", 600)
dt = argv.get("dt", 0.02)
x = Vec(0, 6, 0)
#location = Vec(5., 10., 15.)
#look_at = Vec(2.5, 3., 0.)
#delta = location - look_at
#print(delta)
# negative z moves cam to the right (scene goes left)
# positive z moves cam to the left (scene goes right)
start = Vec(6., 6.5, +2)
stop = Vec(8., 4., +4.)
delta = Vec(4., 3., 4.)
sims = []
dice = []
for i in range(ndice):
sim = Sim()
if i == 0:
camera = Camera(sim, start + delta, start, 5. / 3)
sims.append(sim)
def make_dice():
i = len(dice)
assert i < ndice
sim = sims[i]
offset = 1. * i / ndice
body = Dice(sim)
body.setPosition(x)
theta = 0.7 * pi
a = cos(theta)
b = sin(theta)
body.setRotation([a, 1.5, -b, -1., 1., 0., b, 0., a])
#body.addForce([-0.0, 0.1, 0])
#body.setLinearVel((4.0 + 1.0*offset, 0., 0.))
body.setAngularVel((0.4 * offset, 0., 0.))
theta = 2 * pi * offset
dx = 0.5 * sin(theta)
dy = 0.5 * cos(theta)
body.setLinearVel((1.0 + dx, 0, dy))
dice.append(body)
dt = 0.02
iters = [sim.run(dt=dt) for sim in sims]
#camera.look_at = stop
#camera.location = stop+delta
for frame in range(nframes):
if len(dice) < ndice and frame % 15 == 0:
make_dice()
# x0 = Vec(0, 0, 0)
# for i in range(ndice):
# pos = dice[i].getPosition()
# x += pos
# x = x/ndice
#r = 0.01
#x = (1.-r)*camera.look_at + r*Vec()
# v = camera.look_at
# if v[1] > 1.:
# v = v + 0.7*dt*Vec(1, -1, 0)
# camera.look_at = v
# camera.location = v+delta
r = (frame - 1) / nframes # 0 ... 1
r = 0.5 - 0.5 * cos(pi * r)
v = (1 - r) * start + r * stop
camera.look_at = v
camera.location = v + delta
line = []
for i in range(ndice):
sim = sims[i]
line += iters[i].__next__()
print(line)
def test_psl2z():
# --------------------------------------------------------------
# PSL(2, Z)
# https://en.wikipedia.org/wiki/Modular_group
# G = <S, T | S*S==I, (S*T)**3 == I>
#ring = element.Z
class Z(object):
one = 1
zero = 0
def promote(self, item):
return int(item)
ring = Z()
construct = lambda *args: Mat.construct(ring, *args)
I = construct(1, 0, 0, 1)
S = construct(0, -1, 1, 0)
T = construct(1, 1, 0, 1)
assert S * S == I
assert (S * T)**3 == I
N = 100
G0 = mulclose_fast([S, T], maxsize=N)
#print(len(G0))
assert len(G0) >= N
N = argv.get("N", 3)
# Gamma_0(N)
gamma_0 = lambda m: (m.c % N == 0)
# Gamma_1(N)
gamma_1 = lambda m: ((m.a % N == 1 and m.d % N == 1 or (-m.a) % N == 1 and
(-m.d) % N == 1) and m.c % N == 0)
# Gamma(N)
gamma = lambda m: ((m.a % N == 1 and m.d % N == 1 or (-m.a) % N == 1 and
(-m.d) % N == 1) and m.b % N == 0 and m.c % N == 0)
for fn in [gamma_0, gamma_1, gamma]:
for g in G0:
assert fn(g) == fn(g.inv())
for h in G0:
if fn(g) and fn(h):
#print()
#print(g)
#print(h)
#print(g*h)
assert fn(g * h)
assert fn(h * g)
fn = gamma_0
assert not fn(S)
assert not fn(S * T)
assert not fn(S * T * S)
gen = [S, S * T * S]
curve = mulclose_subgroup(ring, [S, T], gamma, verbose=True)
#curve = mulclose_subgroup(ring, gen, gamma_0, verbose=True)
#curve = mulclose_subgroup(ring, G0, gamma, verbose=True)
print(curve)
#print(astr(curve.Hz))
#print(astr(curve.Hx))
fns = curve.get_autos()
print(len(fns))
def sim_balls():
velocity = argv.get("velocity", 5.)
sim = Sim(mu=1e4, bounce=1.0)
labels = ["ball%d" % i for i in range(1, 16)]
shuffle(labels)
#body = Sphere(sim, label="ball1")
#body.setPosition((0., 1+EPSILON, 0.))
R = 2. + EPSILON
v0 = Vec(0., 1. + EPSILON, 0.)
theta = 0.
w0 = Vec(R * sin(theta), 0., R * cos(theta))
theta += 2 * pi / 6
w1 = Vec(R * sin(theta), 0., R * cos(theta))
count = 0
balls = []
for i in range(5):
for j in range(5):
if i + j > 4:
continue
v = v0 + (i - 1.5) * w0 + (j - 1.5) * w1
label = labels[count]
body = Sphere(sim, label=label)
body.setPosition(v)
w = 2 * pi * random()
a, b = cos(w), sin(w)
body.setRotation([a, 1.5, -b, -1., 1., 0., b, 0., a])
balls.append(body)
count += 1
delta = Vec(20.2, 20., 20.2)
look_at = Vec(0., 0., 0.) # look_at
camera = Camera(sim, look_at + delta, look_at, 5. / 3)
i = sim.run()
for count in range(400):
for b in balls:
v = b.getPosition()
#print(v)
f = -10000. * v
b.addForce(f)
#print(b.getForce())
line = i.__next__()
#print(line)
#assert 0
#return
if 1:
v0 = Vec(12., 1. + EPSILON, -0.0)
body = Sphere(sim, label="ball0")
body.setPosition(v0)
body.setLinearVel((-50., 0, 0))
nframes = argv.get("nframes", 600)
r = 0.9
#for frame, line in enumerate(sim.run(nframes)):
for count in range(nframes):
line = i.__next__()
print(line)
def main():
m = argv.get("m", 3)
n = argv.get("n", 3)
if 0:
L = Network.build_lattice(m, n)
crit = L.get_critical()
zero = L.make_state([2, 1, 2, 1, 0, 1, 2, 1, 2])
a = L.make_state([2] * 9)
nega = L.make_state([2, 3, 2, 3, 2, 3, 2, 3, 2])
assert zero == zero
assert zero != crit
assert a + zero == a
assert zero + zero == zero
assert a + nega == zero
elif 1:
L = Network.build_wheel(m)
elif 1:
L = Network.build_lattice(m, n)
else:
L = Network.build_line(3)
crit = L.get_critical()
#states = mulclose([L.get_critical()] + L.gen, verbose=True)
#print(len(states))
print(L.T)
T = L.T.copy()
T[:, 0] = 1
print(numpy.linalg.det(T))
counts = set()
states = list(L.all_states())
print("states:", len(states))
G = L.critical_group()
print("G:", len(G))
if 0:
for b in states:
for a in L.gen:
print(a, ":", b, a + b)
if 0:
shuffle(states)
for b in states:
c = crit + b
count = 1
while c != crit:
c = c + b
count += 1
assert count < len(states)
if count not in counts:
print(count, end=" ", flush=True)
counts.add(count)
if 0:
group = set()
count = 0
for state in L.all_states():
a = crit + state
group.add(a)
count += 1
print(count)
print(len(group))
def main():
# https://golem.ph.utexas.edu/category/2018/01/more_secrets_of_the_associahed.html
zero = Poly({}, Q)
one = Poly({(): Q.one}, Q)
ring = type("ARing", (object, ), {})
ring.zero = zero
ring.one = one
# -----------------------------------
# Multiplicative inverse
print("\n\n# Multiplicative inverse ")
f = FormalExp("a", ring, {"a_0": 1})
g = FormalExp("b", ring, {"b_0": 1})
print("f =", f)
print("g =", g)
fg = f * g
for i in range(5):
print(fg[i])
print()
N = argv.get("N", 6)
items = solve(f, g, fg, ring)
for i in range(N):
lhs, rhs = items.__next__()
print(r" %s &= %s \\" % (lhs.str(), rhs.str()))
#print(lhs, "=", rhs)
# -----------------------------------
# Compositional inverse
print("\n\n# Compositional inverse")
f = Formal("a", ring, {"a_0": 0, "a_1": 1})
g = Formal("b", ring, {"b_0": 0, "b_1": 1})
print("f =", f)
print("g =", g)
fg = f(g)
for i in range(5):
print(fg[i])
print()
items = solve(f, g, fg, ring)
for i in range(5):
lhs, rhs = items.__next__()
print(r" %s &= %s \\" % (lhs.str(), rhs.str()))
#print(lhs, "=", rhs)
# -----------------------------------
# Dirichlet inverse
print("\n\n# Dirichlet inverse")
f = Formal("a", ring, {"a_0": 0, "a_1": 1})
g = Formal("b", ring, {"b_0": 0, "b_1": 1})
print("f =", f)
print("g =", g)
fg = f.dirichlet(g)
for i in range(5):
print(fg[i])
print()
items = solve(f, g, fg, ring)
for i in range(37):
lhs, rhs = items.__next__()
print(r" %s &= %s \\" % (lhs.str(), rhs.str()))
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
def search_extend():
# Extend the checks of a random code to make it triorthogonal.
# Based on the search function above.
verbose = argv.get("verbose")
m = argv.get("m", 6)
n = argv.get("n", m+2)
k = argv.get("k") # odd _numbered rows ( logical operators)
code = argv.get("code", "rand")
if code == "rand":
while 1:
G0 = rand2(m, n)
counts = G0.sum(0)
if min(counts)==2 and rank(G0) == m:
cols = set()
for i in range(n):
cols.add(tuple(G0[:, i]))
if len(cols) == n: # no repeated cols
break
elif code == "toric":
G0 = parse("""
11.11...
.111..1.
1...11.1
""") # l=2 toric code X logops + X stabs
l = argv.get("l", 3)
G0 = build_toric(l)
m, n = G0.shape
else:
return
code = Code(G0, check=False)
print(shortstr(G0))
print("is_triorthogonal:", code.is_triorthogonal())
# these are the variables N_x
xs = list(cross([(0, 1)]*m))
N = len(xs)
lookup = {}
for i, x in enumerate(xs):
lookup[x] = i
lhs = []
rhs = []
taken = set()
for i in range(n):
x = G0[:, i]
idx = lookup[tuple(x)]
assert idx not in taken
taken.add(idx)
if verbose:
for idx in range(N):
print(idx, xs[idx], "*" if idx in taken else "")
for idx in taken:
v = zeros2(N)
v[idx] = 1
lhs.append(v)
rhs.append(1)
# bi-orthogonality
for a in range(m):
for b in range(a+1, m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == x[b] == 1:
v[i] += 1
assert v.sum()
lhs.append(v)
rhs.append(0)
# tri-orthogonality
for a in range(m):
for b in range(a+1, m):
for c in range(b+1, m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == x[b] == x[c] == 1:
v[i] += 1
assert v.sum()
lhs.append(v)
rhs.append(0)
# dissallow columns with weight <= 1
for i, x in enumerate(xs):
if sum(x)<=1:
v = zeros2(N)
v[i] = 1
lhs.append(v)
rhs.append(0)
if k is not None:
# constrain to k _number of odd-weight rows
assert 0<=k<m
for a in range(m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == 1:
v[i] = 1
lhs.append(v)
if a<k:
rhs.append(1)
else:
rhs.append(0)
A = array2(lhs)
rhs = array2(rhs)
if verbose:
print("lhs:")
print(shortstr(A))
print("rhs:")
print(shortstr(rhs))
B = pseudo_inverse(A)
soln = dot2(B, rhs)
if not eq2(dot2(A, soln), rhs):
print("no solution")
return
if verbose:
print("soln:")
print(shortstr(soln))
soln.shape = (N, 1)
rhs.shape = A.shape[0], 1
K = array2(list(find_kernel(A)))
best = None
density = 1.0
size = 9999*n
trials = argv.get("trials", 1024)
count = 0
for trial in range(trials):
u = rand2(len(K), 1)
v = dot2(K.transpose(), u)
#print(v)
assert dot2(A, v).sum()==0
#if v.sum() != n:
# continue
assert v[0]==0
v = (v+soln)%2
assert eq2(dot2(A, v), rhs)
Gt = list(G0.transpose())
for i, x in enumerate(xs):
if v[i] and not i in taken:
Gt.append(x)
if not Gt:
continue
Gt = array2(Gt)
G = Gt.transpose()
if verbose:
print("G0")
print(shortstr(G0))
print("solution:")
print(shortstr(G))
assert is_morthogonal(G, 3)
if G.shape[1]<m:
continue
if 0 in G.sum(1):
continue
#print(shortstr(G))
# for g in G:
# print(shortstr(g), g.sum())
# print()
_density = float(G.sum()) / (G.shape[0]*G.shape[1])
#if best is None or _density < density:
if best is None or G.shape[1] < size:
best = G
density = _density
size = G.shape[1]
if 0:
#sols.append(G)
Gx = even_rows(G)
assert is_morthogonal(Gx, 3)
if len(Gx)==0:
continue
GGx = array2(list(span(Gx)))
assert is_morthogonal(GGx, 3)
count += 1
print("found %d solutions" % count)
G = best
#print(shortstr(G))
for g in G:
print(shortstr(g), g.sum())
print()
print("density:", density)
#!/usr/bin/env python2
from __future__ import print_function
from bruhat.dev.sage_env import *
from bruhat.argv import argv
d = argv.get("d", 2) # qudit dimension
def dag(op):
op = op.conjugate_transpose()
op.set_immutable() # ARGH!
return op
def mul(a, b):
c = a*b
c.set_immutable() # ARGH!
return c
def mulclose(gen, mul=mul, verbose=False, maxsize=None):
for A in gen:
A.set_immutable()
els = set(gen)
bdy = list(els)
changed = True
while bdy:
#if verbose:
# print "mulclose:", len(els)
_bdy = []
for A in gen:
def search_selfdual():
verbose = argv.get("verbose")
m = argv.get("m", 6) # _number of rows
k = argv.get("k", None) # _number of odd-weight rows
maxweight = argv.get("maxweight", m)
minweight = argv.get("minweight", 1)
# these are the variables N_x
print("building xs...")
if 0:
xs = cross([(0, 1)]*m)
xs = [x for x in xs if minweight <= sum(x) <= maxweight]
prune = argv.get("prune", 0.5)
xs = [x for x in xs if random() < prune]
xs = []
N = argv.get("N", m*100)
colweight = argv.get("colweight", maxweight)
assert colweight <= m
for i in range(N):
x = [0]*m
total = 0
while total < colweight:
idx = randint(0, m-1)
if x[idx] == 0:
x[idx] = 1
total += 1
xs.append(x)
N = len(xs)
lhs = []
rhs = []
# bi-orthogonality
for a in range(m):
for b in range(a+1, m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == x[b] == 1:
v[i] = 1
if v.sum():
lhs.append(v)
rhs.append(0)
k = 0 # all rows must have even weight
# constrain to k _number of odd-weight rows
assert 0<=k<m
for a in range(m):
v = zeros2(N)
for i, x in enumerate(xs):
if x[a] == 1:
v[i] = 1
lhs.append(v)
if a<k:
rhs.append(1)
else:
rhs.append(0)
logops = argv.logops
A = array2(lhs)
rhs = array2(rhs)
#print(shortstr(A))
print("solve...")
B = pseudo_inverse(A)
soln = dot2(B, rhs)
if not eq2(dot2(A, soln), rhs):
print("no solution")
return
if verbose:
print("soln:")
print(shortstr(soln))
soln.shape = (N, 1)
rhs.shape = A.shape[0], 1
K = array2(list(find_kernel(A)))
print("kernel:", K.shape)
if len(K)==0:
return
#print(K)
#print( dot2(A, K.transpose()))
#sols = []
#for v in span(K):
best = None
density = 1.0
size = 99*N
trials = argv.get("trials", 1024)
count = 0
print("trials...")
for trial in range(trials):
u = rand2(len(K), 1)
v = dot2(K.transpose(), u)
#print(v)
v = (v+soln)%2
assert eq2(dot2(A, v), rhs)
if v.sum() >= size:
continue
if v.sum() < m:
continue
if v.sum():
print(v.sum(), end=" ", flush=True)
size = v.sum()
if logops is not None and size != 2*m+logops:
continue
Gt = []
for i, x in enumerate(xs):
if v[i]:
Gt.append(x)
Gt = array2(Gt)
G = Gt.transpose()
if dot2(G, Gt).sum() != 0:
# not self-dual
print(shortstr(dot2(G, Gt)))
assert 0
return
#if G.shape[1]<m:
# continue
if 0 in G.sum(1):
print(".", end="", flush=True)
continue
#print(shortstr(G))
# for g in G:
# print(shortstr(g), g.sum())
# print()
_density = float(G.sum()) / (G.shape[0]*G.shape[1])
#if best is None or _density < density:
if best is None or G.shape[1] <= size:
best = G
size = G.shape[1]
density = _density
if 0:
#sols.append(G)
Gx = even_rows(G)
assert is_morthogonal(Gx, 3)
if len(Gx)==0:
continue
GGx = array2(list(span(Gx)))
assert is_morthogonal(GGx, 3)
count += 1
print("found %d solutions" % count)
if best is None:
return
G = best
#print(shortstr(G))
f = open("selfdual.ldpc", "w")
for spec in ["Hx =", "Hz ="]:
print(spec, file=f)
for g in G:
print(shortstr(g), file=f)
f.close()
print()
print("density:", density)
print("shape:", G.shape)
if 0:
B = pseudo_inverse(A)
v = dot2(B, rhs)
print("B:")
print(shortstr(B))
print("v:")
print(shortstr(v))
assert eq2(dot2(B, v), rhs)
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_)
def triortho():
code = get_code()
code.dump()
print(code)
Gx = []
for u in code.G:
print(shortstr(u), u.sum()%2)
parity = u.sum()%2
if parity==0:
Gx.append(u)
Gx = array2(Gx)
print("is_triorthogonal:", code.is_triorthogonal())
A = array2(list(span(Gx)))
print("span(Gx) is_morthogonal(2):", is_morthogonal(A, 2))
print("span(Gx) is_morthogonal(3):", is_morthogonal(A, 3))
return
G = code.G
# A = array2(list(span(G)))
# poly = {}
# for v in A:
# w = v.sum()
# poly[w] = poly.get(w, 0) + 1
# print(poly)
k, n = G.shape
if 0:
from comm import Poly
a = Poly({(1,0):1})
b = Poly({(0,1):1})
poly = Poly.zero(2)
for v in span(G):
w = v.sum()
term = Poly({(n-w,0) : 1}) * Poly({(0,w) : 1})
poly = poly + term
print(poly)
# print higher genus weight enumerator
genus = argv.get("genus", 1)
assert 1<=genus<=4
N = 2**genus
idxs = list(cross([(0,1)]*genus))
cs = {} # _coefficients : map exponent to coeff
for vs in cross([list(span(G)) for _ in range(genus)]):
key = [0]*N
for i in range(n):
ii = tuple(v[i] for v in vs)
idx = idxs.index(ii)
key[idx] += 1
key = tuple(key)
cs[key] = cs.get(key, 0) + 1
#print(cs)
keys = list(cs.keys())
keys.sort()
print(idxs)
for key in keys:
print(key, cs[key])
def test_graded_sl4():
# See: Miller & Sturmfels, p276
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
poly = lambda v : Poly(v, ring)
p1 = poly("p1")
p2 = poly("p2")
p3 = poly("p3")
p4 = poly("p4")
p12 = poly("p12")
p13 = poly("p13")
p14 = poly("p14")
p23 = poly("p23")
p24 = poly("p24")
p34 = poly("p34")
p123 = poly("p123")
p124 = poly("p124")
p134 = poly("p134")
p234 = poly("p234")
rels = [
p23*p1 - p13*p2 + p12*p3, p24*p1 - p14*p2 + p12*p4,
p34*p1 - p14*p3 + p13*p4, p34*p2 - p24*p3 + p23*p4,
p14*p23 - p13*p24 + p12*p34, p234*p1 - p134*p2 + p124*p3 - p123*p4,
p134*p12 - p124*p13 + p123*p14, p234*p12 - p124*p23 + p123*p24,
p234*p13 - p134*p23 + p123*p34, p234*p14 - p134*p24 + p124*p34,
]
rels = grobner(rels, verbose=True)
print("rels:", rels)
print()
grades = [
[p1, p2, p3, p4],
[p12, p13, p14, p23, p24, p34],
[p123, p124, p134, p234],
]
multi = argv.get("multi")
n = 5 if multi is None else sum(multi)+1
n = argv.get("n", n)
for g0 in range(n):
for g1 in range(n):
for g2 in range(n):
if multi is not None and (g0, g1, g2)!=multi:
#print(". ", end='')
continue
elif g0+g1+g2 > n-1:
print(". ", end='')
continue
gens = []
for m0 in all_monomials(grades[0], g0, ring):
for m1 in all_monomials(grades[1], g1, ring):
for m2 in all_monomials(grades[2], g2, ring):
m = m0*m1*m2
#for rel in rels:
# div, m = rel.reduce(m)
m = reduce_many(rels, m)
if m != 0:
gens.append(m)
print(len(gens), end=':', flush=True)
basis = grobner(gens)
lhs = len(basis)
rhs = (g0+1)*(g1+1)*(g2+1)*(g0+g1+2)*(g1+g2+2)*(g0+g1+g2+3)//12
assert lhs==rhs, ("%s != %s"%(lhs, rhs))
print(len(basis), end=' ', flush=True)
# basis.sort(key=str)
# heads = {}
# for p in basis:
# print(p.head, p)
# heads[p.head] = p
# print(len(heads))
# return
print()
print()
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()
