def main():
p = argv.get("p")
if p:
genus = get_genus(p)
print("genus:", genus)
else:
for p in all_primes(104):
if p < 5:
continue
genus = get_genus(p)
print("p=%d, genus=%d" % (p, genus))
from argv import argv
r = Symbol("r", real=True, positive=True)
phi = Symbol("phi", real=True)
theta = Symbol("theta", real=True)
Z = Symbol("Z", positive=True, integer=True, nonzero=True)
"""
# Psi_nlm(n, l, m, r, phi, theta, Z)
n, l, m quantum numbers ‘n’, ‘l’ and ‘m’
r radial coordinate
phi azimuthal angle
theta polar angle
Z atomic number (1 for Hydrogen, 2 for Helium, …)
"""
n = argv.get("n", 3)
l = argv.get("l", 1)
m = argv.get("m", 0)
density = argv.get("density", 1.0)
f = Psi_nlm(n, l, m, r, phi, theta, 1)
print("psi(r, phi, theta) =", f)
vmin = -15. * n
vmax = 15. * n
N = 32
delta = (vmax - vmin) / N
vals = list(numpy.arange(vmin, vmax, delta))
nx = ny = nz = len(vals)
data = []
def even_code():
p = argv.get("p", 7)
#assert (p%8) in [1, 7]
# equivalent to "2 (binary!) is a quadratic _residue mod p"
# eg. 7 17 23 31 41 47 71 73 79 89 97
def neginv(i):
if i == 0:
return p
if i == p:
return 0
for j in range(1, p):
if (i * j) % p == 1:
break
else:
assert 0
return (-j) % p
nonresidues = set(range(1, p))
residues = set()
for i in range(1, p):
j = (i * i) % p
if j not in residues:
residues.add(j)
nonresidues.remove(j)
print("residues:", residues)
print("non-residues:", nonresidues)
# extended binary quadratic _residue code
N = p + 1
G = zeros2(N, N)
G[p, :] = 1
for u in range(p):
G[u, p] = 0 if (p - 1) % 8 == 0 else 1
for v in range(p):
if u == v:
i = 0
elif (v - u) % p in residues:
i = 1
else:
i = 0
G[u, v] = i
G = linear_independent(G)
print("G =")
print(shortstr(G))
from qupy.ldpc.css import CSSCode
from qupy.ldpc.gallagher import classical_distance
G = G.astype(numpy.int32)
code = CSSCode(Hx=G, Hz=G)
print(code)
from bruhat.codes import strong_morthogonal
for genus in range(1, 4):
print("genus:", genus, "strong_morthogonal:",
strong_morthogonal(G, genus))
def double(G):
M, N = G.shape
DG = zeros2(M + 1, 2 * N)
DG[1:, 0:N] = G
DG[1:, N:2 * N] = G
DG[0, 0:N] = 1
DG = DG.astype(numpy.int32)
return DG
DG = G
DG = DG.astype(numpy.int32)
print("distance:", classical_distance(DG))
for _ in range(2):
DG = double(DG)
DG = linear_independent(DG)
print(shortstr(DG))
for genus in range(1, 5):
print("genus:", genus, "strong_morthogonal:",
strong_morthogonal(DG, genus))
code = CSSCode(Hx=DG, Hz=DG)
print(code)
def main():
p = argv.get("p", 7)
#assert (p%8) in [1, 7]
# equivalent to "2 (binary!) is a quadratic _residue mod p"
# eg. 7 17 23 31 41 47 71 73 79 89 97
def neginv(i):
if i == 0:
return p
if i == p:
return 0
for j in range(1, p):
if (i * j) % p == 1:
break
else:
assert 0
return (-j) % p
nonresidues = set(range(1, p))
residues = set()
for i in range(1, p):
j = (i * i) % p
if j not in residues:
residues.add(j)
nonresidues.remove(j)
print("residues:", residues)
print("non-residues:", nonresidues)
# extended binary quadratic _residue code
N = p + 1
G = zeros2(N, N)
G[p, :] = 1
for u in range(p):
G[u, p] = 0 if (p - 1) % 8 == 0 else 1
for v in range(p):
if u == v:
i = 0
elif (v - u) % p in residues:
i = 1
else:
i = 0
G[u, v] = i
print("G =")
print(shortstr(G))
GG = dot2(G, G.transpose())
if GG.sum() == 0:
print("self-dual code, p=%d mod 4" % (p % 4))
else:
print("not a self-dual code, p=%d mod 4" % (p % 4))
m = rank(G)
#assert m == N/2
print("F_2 rank =", m)
#print("det:", numpy.linalg.det(G))
H = find_kernel(G)
H = array2(H)
print()
print("H =")
print(shortstr(H))
# -----------------------------------
print()
print("non extended:")
print("G =")
G1 = G[:-1, :-1]
print(shortstr(G1))
#print("det:", numpy.linalg.det(G1.astype(numpy.float)))
m = rank(G1)
print("rank =", m)
#assert m == N/2
H1 = find_kernel(G1)
H1 = array2(H1)
print()
print("H =")
print(shortstr(H1))
GG = dot2(G, G.transpose())
if GG.sum() == 0:
print("self-dual code")
else:
print("not a self-dual code")
i = iter(nonresidues).__next__()
idxs = [(j * i) % p for j in range(p)]
assert len(set(idxs)) == p
NG1 = G1[:, idxs]
print("G~ =")
print(shortstr(NG1))
print("G . G~ =")
print(dot2(G1, NG1.transpose()).sum())
NH1 = find_kernel(NG1)
NH1 = array2(NH1)
print()
print("NH =")
print(shortstr(NH1))
#print(dot2(H1, NH1.transpose()))
print("linear_independent(G):")
print(shortstr(linear_independent(G1)))
print("linear_independent(G~):")
print(shortstr(linear_independent(NG1)))
# -----------------------------------
# code should be fixed by PSL(2, p).
G1 = zeros2(N, N)
for u in range(N):
for v in range(N):
G1[u, v] = G[u, neginv(v)]
#print()
#print(shortstr(G1))
#print()
# still in the codespace:
assert dot2(G1, H.transpose()).sum() == 0
# -----------------------------------
# build PSL(2, p) via action on P(F_p)
basis = list(range(N))
perm = dict((i, (i + 1) % p) for i in range(p))
perm[p] = p # infty
A = Perm(perm, basis)
perm = {}
for u in range(N):
v = neginv(u)
perm[u] = v
B = Perm(perm, basis)
PSL = Group.generate([A, B])
print("|PSL(2,%d)| = %d" % (p, len(PSL)))
print(residues)
count = 0
for g in PSL:
r1 = set(g[r] for r in residues)
if r1 == residues:
count += 1
print("count =", count)
# g = PSL[5]
# print(g.orbits())
# for u in span(G):
# v = array2([u[A[i]] for i in basis])
# if not eq2(u, v):
# continue
# v = array2([u[B[i]] for i in basis])
# if not eq2(u, v):
# continue
# print(u)
if p == 23:
# Conway & Sloane, p274
cycles = [(p, ), list(range(23))]
alpha = Perm.fromcycles(cycles, basis)
cycles = [(p, ), (15, 7, 14, 5, 10, 20, 17, 11, 22, 21, 19), (0, ),
(3, 6, 12, 1, 2, 4, 8, 16, 9, 18, 13)]
beta = Perm.fromcycles(cycles, basis)
cycles = [(p, 0), (15, 3), (7, 13), (14, 18), (5, 9), (10, 16),
(20, 8), (17, 4), (11, 2), (22, 1), (21, 12), (19, 6)]
gamma = Perm.fromcycles(cycles, basis)
cycles = [(p, ), (14, 17, 11, 19, 22), (15, ), (
20,
10,
7,
5,
21,
), (0, ), (18, 4, 2, 6, 1), (3, ), (8, 16, 13, 9, 12)]
delta = Perm.fromcycles(cycles, basis)
G = Group.generate([alpha, beta, gamma]) # PSL(2,23)
assert len(G) == 6072
def main():
# dimension
n = argv.get("n", 3)
def bstr(p):
s = []
for i in range(n):
s.append('1' if p & 1 else '0')
p >>= 1
s = ''.join(reversed(s))
return s
points = []
for i in range(1, 2**n):
points.append(i)
#for p in points:
# print bstr(p)
lines = set()
for p in points:
for q in points:
if p == q:
continue
r = p ^ q
assert r != 0
line = [p, q, r]
line.sort()
lines.add(tuple(line))
assert len(lines) == 7
print "lines:", lines
N = len(points)
bases = []
for p in points:
for q in points:
if p == q:
continue
for r in points:
if p == r or q == r:
continue
base = [p, q, r]
figure = list(base)
figure.sort()
if tuple(figure) in lines:
continue
bases.append(tuple(base))
print "bases:", len(bases)
# configs = set()
# for b0 in bases:
# for b1 in bases:
# for b2 in bases:
# configs.add((b0, b1, b2))
# print "configs:", len(configs)
b0 = bases[0] # pick one...
# b0 = choice(bases)
# b1 = choice(bases)
# b2 = choice(bases)
#
# print b0
# print b1
# print b2
# print
stats = {}
for b1 in bases:
for b2 in bases:
i0 = 0
j0 = 1
k0 = 2
solutions = 0
for i1 in range(3):
if b1[i1] == b0[i0]:
continue
for i2 in range(3):
triple = [b0[i0], b1[i1], b2[i2]]
if len(set(triple)) != 3:
continue
#print "-----", triple
figure = list(triple)
figure.sort()
if tuple(figure) in lines:
continue
# print triple
for j1 in range(3):
if j1 == i1:
continue
for j2 in range(3):
if j2 == i2:
continue
triple = [b0[j0], b1[j1], b2[j2]]
if len(set(triple)) != 3:
continue
#print "-----", triple
figure = list(triple)
figure.sort()
if tuple(figure) in lines:
continue
# print "\t", triple
for k1 in range(3):
if k1 == i1 or k1 == j1:
continue
for k2 in range(3):
if k2 == i2 or k2 == j2:
continue
triple = [b0[k0], b1[k1], b2[k2]]
if len(set(triple)) != 3:
continue
#print "-----", triple
figure = list(triple)
figure.sort()
if tuple(figure) in lines:
continue
# print "\t\t", triple
solutions += 1
#print "solutions:", solutions
stats[solutions] = stats.get(solutions, 0) + 1
print stats
def test():
_seed = argv.get("seed")
if _seed is not None:
seed(_seed)
m, n = 4, 5
A = zeros(m, n)
U = zeros(m, n)
for trial in range(100):
A = rand(m, n)
row_reduce(A, check=True)
for trial in range(100):
for i in range(m):
for j in range(i, n):
a = randint(-3, 3)
if i == j and a == 0:
a = 1
U[i, j] = Fraction(a, randint(1, 3))
V = u_inverse(U, check=True)
for trial in range(100):
L = identity(m)
for i in range(m):
for j in range(i):
L[i, j] = Fraction(randint(-3, 3), randint(1, 3))
V = l_inverse(L, check=True)
for trial in range(100):
A = rand(m, n)
P, L, U = plu_reduce(A, check=True, verbose=False)
#m, n = 2, 3
#while 1:
for i in range(100):
A = rand(m, n)
#A = row_reduce(A, check=True)
if rank(A, check=True) + nullity(A, check=True) == n:
#write('.')
continue
print("FAIL")
print("A:")
print(shortstr(A))
print("row_reduce:")
B = row_reduce(A, verbose=True)
print(shortstr(B))
print("kernel:")
print(shortstr(kernel(A)))
return
A = zeros(3, 4)
A[0, 0] = 1
A[1, 1] = 1
A[2, 2] = 1
#A = numpy.concatenate((A, A))
A = A.concatenate(A)
A = A.transpose()
#print( "A:")
#print( shortstr(A))
K = kernel(A)
#print( "K:")
#print( shortstr(K))
assert len(K) == 3
while 1:
m, n = 3, 4
A = zeros(m, n)
for i in range(m):
for j in range(n):
a = randint(-2, 2)
A[i, j] = Fraction(a, randint(1, 3))
K = kernel(A, check=True)
#print( "kernel: A, K, A*K")
#print( shortstr(A, K, dot(A, K)))
B = dot(A, K.transpose())
#assert numpy.abs(B).sum()==0
assert B.is_zero()
if K.shape[1] > 1:
break
#while 1:
for i in range(100):
m, n = 3, 4
W = rand(m, n, 2, 3)
W = row_reduce(W, truncate=True)
s = Subspace(W)
#print( "-"*79)
#print( s)
#print()
assert s == s
assert Subspace(2 * W) == s
assert Subspace(W[:-1]) != s
ss = s.intersect(s)
#print( ss)
assert ss == s
#print( P)
#print( L)
#print( U)
print("OK")
def main():
p = argv.p
if p is None:
ring = element.Z
else:
ring = element.FiniteField(p)
n = argv.get("n", 3)
assert n%2 == 1
assert n>2
m = n-1
space = vec.Space(m, ring)
hom = vec.Hom(space, space)
J = zeros(m)
for i in range(m):
if i%2==0:
J[i+1, i] = -1
else:
J[i-1, i] = 1
J = from_array(J, hom)
print("J =")
print(J)
make = lambda items : from_array(numpy.array(items), hom)
is_symplectic = lambda A : (A.transpose() * J * A == J)
if 0:
a1 = make([
[1, -1, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
assert is_symplectic(a1)
b1 = make([
[1, 0, 0, 0],
[1, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]])
assert is_symplectic(b1)
a2 = make([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, -1],
[0, 0, 0, 1]])
assert is_symplectic(a2)
b2 = make([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 1, 1]])
assert is_symplectic(b2)
c = make([
[1, 0, 0, 0],
[1, 1, -1, 0],
[0, 0, 1, 0],
[-1, 0, 1, 1]])
assert is_symplectic(c)
gen = [b1, a1, c, a2, b2]
gen = []
I = zeros(m)
for i in range(m):
I[i, i] = 1
A = zeros(m) + I
A[1, 0] = 1
gen.append(A)
for i in range(m//2):
A = zeros(m) + I
A[2*i, 2*i+1] = -1
gen.append(A)
if i+1 < m//2:
A = zeros(m) + I
A[2*i+1, 2*i] = 1
A[2*i+3, 2*i] = -1
A[2*i+1, 2*i+2] = -1
A[2*i+3, 2*i+2] = 1
gen.append(A)
if m//2>1:
A = zeros(m) + I
A[m-1, m-2] = 1
gen.append(A)
gen = [make(A) for A in gen]
print("gen:", len(gen))
for A in gen:
print(A)
assert is_symplectic(A)
for i in range(m):
for j in range(i, m):
a, b = gen[i], gen[j]
if abs(i-j)==1:
assert a*b*a == b*a*b # Yang-Baxter
elif abs(i-j)>1:
assert a*b == b*a
A = zeros(m) + I
A[3, 2] = 1
A = make(A)
assert is_symplectic(A)
gen.append(A)
if argv.p==2 and m==4 or argv.mulclose:
assert p is not None, "not a finite group!"
G = mulclose(gen)
print("|G| =", len(G))
if argv.p==2 and m==4:
assert len(G)==720