def test(): n = 9 G = Group.symmetric(n) t = Young(G, (4, 3, 1, 1)) assert t.rows == [[0, 1, 2, 3], [4, 5, 6], [7], [8]] assert t.cols == [[0, 4, 7, 8], [1, 5], [2, 6], [3]] G = t.get_rowperms() assert len(G) == factorial(4) * factorial(3)
def h2(x1, x2): x1 %= p x2 %= p total = 0 for r1 in range(p): for r2 in range(p): if r1 + r2 != p: continue total += -div((x1**r1) * (x2**r2) % p, factorial(r1) * factorial(r2) % p) return total % p
def test(): for n in [2, 3, 4]: ops = build_An(n) assert len(mulclose(ops))==factorial(n) ops = build_Bn(n) assert len(mulclose(ops))==2**n*factorial(n) ops = build_Dn(n) assert len(mulclose(ops))==2**(n-1)*factorial(n) from numpy import kron as tensor def allclose(A, B): return numpy.abs(A - B).sum()==0 for A in ops: for B in ops: assert (A==B) == (hash(A)==hash(B)) assert (A!=B) != (A==B) lhs = (A*B).todense() rhs = ((numpy.dot(A.todense(), B.todense()))) assert allclose(lhs, rhs) lhs = (A.tensor(B)).todense() rhs = ((tensor(A.todense(), B.todense()))) assert allclose(lhs, rhs) for A in ops: assert allclose(A.transpose().todense(), A.todense().transpose()), str(A) ops = mulclose(build_Bn(2)) tops = [] for A in ops: for B in ops: C = Tensor([A, B]) tops.append(C) #print(len(tops)) for A in tops: assert A.get_canonical() == A for A in tops: for B in tops: assert (A==B) == allclose(A.todense(), B.todense()) assert (A==B) == (A.get_canonical()==B.get_canonical()) assert (A==B) == (hash(A)==hash(B)) print("OK")
def test_hilbert_sl3(): # --------------------------------------------------------------- # Here we work out the coefficients of a Hilbert polynomial # given by the rational function top/bot. # These coefficients give the dimension of irreps of SL(3). # See also test_graded_sl3 below. ring = Q zero = Poly({}, ring) one = Poly({():1}, ring) x = Poly("x", ring) y = Poly("y", ring) z = Poly("z", ring) top = one - x*y bot = ((one-x)**3) * ((one-y)**3) def diff(top, bot, var): top, bot = top.diff(var)*bot - bot.diff(var)*top, bot*bot return top, bot fracs = {} fracs[0,0] = (top, bot) N = 3 for i in range(N): for j in range(N): top, bot = fracs[i, j] top, bot = diff(top, bot, 'x') fracs[i, j+1] = top, bot top, bot = fracs[i, j] top, bot = diff(top, bot, 'y') fracs[i+1, j] = top, bot print(".", end="", flush=True) print() for i in range(N+1): for j in range(N+1): if (i, j) not in fracs: continue top, bot = fracs[i, j] t = top.get_const() b = bot.get_const() val = t//b//factorial(i)//factorial(j) assert val == dim_sl3(i, j) print(val, end=" ") print()
def getitem(self, idx): name = self.get_name(idx) p = Poly(name, Q) p = self.subs.get(name, p) #p = Poly({((name, 1),) : Q.one//factorial(idx)}, Q) p = Q.one // factorial(idx) * p return p
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 symmetric(cls, n): assert n > 0 gen = [] items = list(range(n)) for i in range(n - 1): perm = list(items) perm[i] = i + 1 perm[i + 1] = i gen.append(Perm(perm)) G = Group(gen=gen) assert len(G) == factorial(n) return G
def alternating(cls, n): assert n > 0 gen = [] items = list(range(n)) for i in range(n - 2): perm = list(items) perm[i] = i + 1 perm[i + 1] = i + 2 perm[i + 2] = i gen.append(Perm(perm)) G = Group(gen=gen) assert len(G) == factorial(n) // 2 return G
def __getitem__(self, idx): U = Set(idx) FU = self.species[U] FU = list(FU) return self.ring.one * len(FU) / factorial(idx)
def tpl_factorial(idxs): r = 1 for i in idxs: r *= factorial(i) return r
def choose(m, n): assert m>=n>=0 value = factorial(m) // (factorial(n) * factorial(m-n)) assert value > 0 return value
def test(n): G = Weyl.build_A(n) # print "%d roots" % len(G.roots) # print G.roots # for g in G.gen: # print [g(root) for root in G.roots] gen = G.gen for i in range(n): for j in range(n): gi = gen[i] gj = gen[j] if i == j: assert gi * gj == G.identity elif abs(i - j) == 1: assert gi * gj != G.identity assert (gi * gj)**2 != G.identity assert (gi * gj)**3 == G.identity else: assert gi * gj != G.identity assert (gi * gj)**2 == G.identity if n < 5: assert len(mulclose(G.gen)) == factorial(n + 1) # --------------------------------------------------------- G = Weyl.build_B(n) gen = G.gen for g in gen: assert g * g == G.identity for i in range(n - 1): for j in range(i + 1, n - 1): gi = gen[i] gj = gen[j] if abs(i - j) == 1: assert gi * gj != G.identity assert (gi * gj)**2 != G.identity assert (gi * gj)**3 == G.identity else: assert gi * gj != G.identity assert (gi * gj)**2 == G.identity if i < n - 1: gj = gen[n - 1] assert gi * gj != G.identity assert (gi * gj)**2 == G.identity if n > 2: gi = gen[n - 2] gj = gen[n - 1] assert (gi * gj) != G.identity assert (gi * gj)**2 != G.identity assert (gi * gj)**3 != G.identity assert (gi * gj)**4 == G.identity if n < 5: assert len(mulclose(G.gen)) == (2**n) * factorial(n) # --------------------------------------------------------- G = Weyl.build_C(n) # --------------------------------------------------------- if n < 3: return # <---------------------- return G = Weyl.build_D(n) gen = G.gen for i in range(n - 1): gi = gen[i] for j in range(i + 1, n - 1): gj = gen[j] if abs(i - j) == 1: assert gi * gj != G.identity assert (gi * gj)**2 != G.identity assert (gi * gj)**3 == G.identity else: assert gi * gj != G.identity assert (gi * gj)**2 == G.identity gj = gen[n - 1] if i < n - 3 or i == n - 2: assert gi * gj != G.identity assert (gi * gj)**2 == G.identity elif i == n - 3: assert gi * gj != G.identity assert (gi * gj)**2 != G.identity assert (gi * gj)**3 == G.identity if n < 5: assert len(mulclose(G.gen)) == (2**(n - 1)) * factorial(n)
def main(): X, Z = build_Bn(2) I = Op.identity(2) l = argv.get("l", 2) if argv.B2: #toric(X, Z) code = Toric(l, X, Z) print("OK") return #print(I) #print(X) #print(Z) II = Op.identity(4) P2 = [X.tensor(I), Z.tensor(I), I.tensor(X), I.tensor(Z)] P2 = mulclose(P2) assert len(P2) == 32 assert II in P2 errors = [] for A in P2: if A == II or A == -II or -A in errors: continue errors.append(A) assert len(errors) == 15 if 0: G = mulclose(P2) for g in G: A = g.todense() vals = numpy.linalg.eigvals(A) print(vals) # all +1, -1 d = argv.get("d", 4) gen = build_Bn(d) n = (2**d) * factorial(d) assert len(mulclose(gen)) == n # slow... G = mulclose(gen, n) H = [g for g in G if g not in P2] for ops in all_quads(H): X1, X2, Z1, Z2 = ops ss = set() print("quad") # no quads found ... for E in errors: #s = tuple(order(E*A) for A in ops) #ss.append(s) ss.add(tuple(E * A * inverse(E) * inverse(A) for A in ops)) #ss.add(tuple(order(E*A) for A in ops)) #print(len(set(ss))) if len(set(ss)) == len(errors): write("/") toric([X1, X2], [Z1, Z2]) else: write("\\")
def r(n): result = 0 for d in divisors(n): result += factorial(n) // (factorial(d) * factorial(n // d)) return result
def test(): # triangle: g = Geometry("aB aC bA bC cB cA".split(), { 'a': 'p', 'b': 'p', 'c': 'p', 'A': 'l', 'B': 'l', 'C': 'l' }) assert len(g.items) == 6 #print g.flags_type('l') #print g.flags_type('p') #g = g.residue(["a"]) for n in range(2, 7): g = Geometry.polygon(n) assert len(g.items) == 2 * n assert len(g.maximal_flags()) == 2 * n assert len(g.flags_type(['p'])) == n assert len(g.flags_type(['l'])) == n assert len(g.flags_type(['p', 'l'])) == 2 * n if n > 3: assert not g.is_projective_plane() g = Geometry.simplex(2) h = g.residue([(0, ), (0, 1)]) assert len(h.items) == 1 assert len(g.flags_type([0, 1])) == 6 for dim in range(4): g = Geometry.simplex(dim) assert len(g.items) == 2**(dim + 1) - 1 assert len(g.maximal_flags()) == factorial(dim + 1) h = g.residue([(0, )]) if dim > 0: g.residue([(0, ), (0, 1)]) g = Geometry.cube() d = g.get_diagram() #assert d == [('e', 'v'), ('f', 'e')], repr(d) assert d == [('e', 'f'), ('e', 'v')] assert Geometry.simplex(4).get_diagram() == [(0, 1), (1, 2), (2, 3) ] # A_4 Dynkin diagram ! #g = tesellate_3d() g = fano() assert g.get_diagram() == [('l', 'p')] n = argv.get("n", 3) assert n >= 3 g = projective(n) assert len(g.tplookup[0]) == qbinomial(n, 1) assert len(g.tplookup[1]) == qbinomial(n, 2) if argv.cube: g = Geometry.cube() elif argv.simplex: g = Geometry.simplex(2) elif argv.triangle: g = Geometry.polygon(3) elif argv.projective: dim = argv.get("dim", 2) g = projective(n, dim) if dim > 2: assert len(g.tplookup[2]) == qbinomial(n, 3) elif argv.bruhat: if argv.A_2: monoid = BruhatMonoid("LP", {("L", "P"): 3}) elif argv.A_3: monoid = BruhatMonoid("LPS", {("L", "P"): 3, ("L", "S"): 3}) elif argv.A_4: monoid = BruhatMonoid("LPSH", { ("L", "P"): 3, ("L", "S"): 3, ("S", "H"): 3 }) elif argv.B_2: monoid = BruhatMonoid("LP", {("L", "P"): 4}) elif argv.B_3: monoid = BruhatMonoid("LPS", {("L", "P"): 3, ("P", "S"): 4}) elif argv.D_4: monoid = BruhatMonoid("LPSH", { ("L", "P"): 3, ("L", "S"): 3, ("L", "H"): 3 }) else: return monoid.build() system = MonoidSystem(monoid) magnitude_homology(system=system) else: return if argv.system: system = System(g) return if argv.magnitude: magnitude_homology(g) if argv.hecke: hecke(g) #print g.get_symmetry() #s = g.get_system() #s.get_symmetry() return print("OK")
def main(): X, Z = build(2) I = dot(X, X) #print(I) #print(X) #print(Z) II = tensor(I, I) P2 = [tensor(X, I), tensor(Z, I), tensor(I, X), tensor(I, Z)] found = set() for g in mulclose(P2): s = shortstr(g) found.add(s) assert len(found) == 32 assert shortstr(II) in found if 0: G = mulclose(P2) for g in G: A = numpy.array(g, dtype=numpy.float) vals = numpy.linalg.eigvals(A) print(vals) # all +1, -1 d = argv.get("d", 4) gen = build(d) n = (2**d) * factorial(d) assert len(mulclose(gen)) == n # slow... G = mulclose(gen, n) print("orders:") for g in G: print(order(g), end=' ') print() if 0: for g in G: A = numpy.array(g, dtype=numpy.float) vals = numpy.linalg.eigvals(A) print(vals) # all kinds of stuff.. if d == 4: assert len([g for g in G if shortstr(g) in found]) == 32 pairs = [] c_comm = 0 c_anti = 0 total = 0 for i in range(len(G)): for j in range(len(G)): g = G[i] h = G[j] gh = dot(g, h) hg = dot(h, g) total += 1 if eq(gh, -hg): c_anti += 1 elif eq(gh, hg): c_comm += 1 if shortstr(g) in found or shortstr(h) in found: continue if eq(gh, -hg) and i < j: #assert order(g)==2 print(order(g), end=' ') #print(g) #print(h) #print(eq(g, g.transpose()), end=' ') #print(eq(h, h.transpose())) if eq(g, g.transpose()) and eq(h, h.transpose()) and i < j: pairs.append((g, h)) #print(".", end='') #print() #print(c_comm, c_anti, total) print("pairs:", len(pairs)) ops = {} for (g, h) in pairs: ops[shortstr(g)] = g ops[shortstr(h)] = h ops = list(ops.values()) print(len(ops)) for g in ops: for h in ops: a = eq(dot(g, h), dot(h, g)) b = eq(dot(g, h), -dot(h, g)) if a == b == False: s = ' ' elif a: s = '+ ' elif b: s = '- ' print(s, end=' ') print() return A, B, C, D = gen pairs = [ s.split() for s in ("ABDA CBDC", "BACB DCDA", "BACB DCDC", "BACDBCBADCBC DCABDCDABACD") ] for l, r in pairs: left = [eval(s) for s in l] right = [eval(s) for s in r] left = dotx(*left) right = dotx(*right) if 1: print(shortstr(left)) print(shortstr(left) in found) print() print(shortstr(right)) print(shortstr(right) in found) print() print(shortstr(dotx(left, right))) print() print() assert eq((dotx(right, left)), -(dotx(left, right)))
def getitem(self, idx): ring = self.ring return ring.one // factorial(idx)