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()