def test_glue():
m = argv.get("m", 9)
n = argv.get("n", 10)
d = argv.get("d", 0)
p = argv.get("p", 0.5)
weight = argv.weight
H1 = rand2(m, n, p, weight)
G1 = find_kernel(H1)
G1t = G1.transpose()
H1t = H1.transpose()
A1 = Chain([G1, H1t])
k1 = len(G1)
print("H1")
print(fstr(H1))
print()
print(fstr(G1))
w = wenum(H1)
print("wenum:", [len(wi) for wi in w])
H2 = rand2(m, n, p, weight)
H2t = H2.transpose()
G2 = find_kernel(H2)
G2t = G2.transpose()
A2 = Chain([G2, H2t])
k2 = len(G2)
print("H2")
print(fstr(H2))
print()
print(fstr(G2))
w = wenum(H2)
print("wenum:", [len(wi) for wi in w])
if k1 != k2:
return
k = k1
I = identity2(k)
B = Chain([I, zeros2(k, 0)])
a = zeros2(n, k)
for i in range(k):
a[i, i] = 1
f1 = Morphism(B, A1, [dot2(G1, a), a, zeros2(m, 0)])
f2 = Morphism(B, A2, [dot2(G2, a), a, zeros2(m, 0)])
a, b, C, _ = chain.pushout(f1, f2)
H = C[1].transpose()
print("H:")
print(fstr(H))
w = wenum(H)
print("wenum:", [len(wi) for wi in w])
def build_random_selfdual(n):
weight = argv.get("weight", 3)
m = argv.get("m", n)
h = argv.get("h", 0)
while 1:
Gx = rand2(m, n, weight=weight)
Gz = Gx.copy()
Hx = Hz = None
Gx = Gx[[i for i in range(m) if Gx[i].sum()], :]
Gx = linear_independent(Gx)
if len(Gx) < m:
write("m")
continue
Gz = Gx.copy()
Hx = find_stabilizers(Gz, Gx)
Hz = find_stabilizers(Gx, Gz)
if len(Hx) == h and len(Hz) == h:
break
write("H(%d,%d)" % (len(Hx), len(Hz)))
print()
return Gx, Gz, Hx, Hz
def glue_morth():
m = argv.get("m", 4)
n = argv.get("n", m + m + 1)
genus = argv.get("genus", 2)
if 0:
H = make_morthogonal(m, n, genus)
elif 0:
H = reed_muller.build(1, 4).G
print(shortstrx(H))
else:
H = find_triorth(m, 1)
assert dot2(H, H.transpose()).sum() == 0
Hx = Hz = H
if 0:
print(classical_distance(Hx))
print(classical_distance(Hz))
i0 = 0
i1 = Hx.shape[1]
Hx = direct_sum(Hx, Hx)
Hz = direct_sum(Hz, Hz)
print(shortstrx(Hx, Hz))
print(strong_morthogonal(Hx, genus))
print(strong_morthogonal(Hz, genus))
print()
code = CSSCode(Hx=Hx, Hz=Hz)
print(code)
if 0:
Hz = glue_self_classical(Hz, [(i0, i1), (i0, i1 + 1)])
print(shortstrx(Hz))
print(strong_morthogonal(Hz, genus))
print()
return
Hx, Hz = glue_self(Hx, Hz, [(i0, i1), (i0, i1 + 1)])
#Hx, Hz = glue_self(Hx, Hz, [(i0, i1)])
print(shortstrx(Hx, Hz))
print(strong_morthogonal(Hx, genus))
print(strong_morthogonal(Hz, genus))
print()
code = CSSCode(Hx=Hx, Hz=Hz)
# Hx, Hz = glue_self(Hx, Hz, [(0, n)])
# print(shortstrx(Hx, Hz))
# print(strong_morthogonal(Hx, genus))
# print(strong_morthogonal(Hz, genus))
# print()
code = CSSCode(Hx=Hx, Hz=Hz)
print(code)
def main():
if argv.ldpc:
# LDPC
l = argv.get("l", 3) # column weight
m = argv.get("m", 4) # row weight
n = argv.get("n", 8) # cols
r = argv.get("r", n * l // m) # rows
d = argv.get("d", 1) # distance
C = make_gallagher(r, n, l, m, d)
print(shortstr(C))
print("rank(C)", rank(C), "kernel(C)", len(find_kernel(C)))
if argv.same:
D = C
else:
D = make_gallagher(r, n, l, m, d)
assert rank(C) == len(C)
assert rank(D) == len(D)
print("rank(D)", rank(D), "kernel(D)", len(find_kernel(D)))
elif argv.torus:
# Torus
C = parse("""
11..
.11.
..11
1..1
""")
D = C
elif argv.hamming:
C = parse("""
...1111
.11..11
1.1.1.1
""")
D = C
elif argv.surf or argv.surface:
# Surface
C = parse("""
11..
.11.
..11
""")
D = C
else:
return
Ct = C.transpose()
Dt = D.transpose()
hypergraph_product(C, Dt)
def render_flow():
m, n = argv.get("m", 3), argv.get("n", 3)
nrows, ncols = argv.get("nrows", 1), argv.get("ncols", 1)
double = argv.double
name = argv.get("name", "output")
cx = Complex()
if argv.torus:
cx.build_torus(m, n)
signature = (1, 2, 1)
elif argv.disc:
cx.build_surface((0, 0), (m + 1, n + 1))
signature = (1, 0, 0)
else:
cx.build_surface((0, 0), (m + 1, n + 1), open_top=True, open_bot=True)
signature = (0, 1, 0)
if argv.showcode:
code = cx.get_code()
print(code)
return
rows = []
row = []
while len(rows) < nrows:
flow = Flow(cx)
flow.build()
dims = [len(flow.get_critical(grade)) for grade in [0, 1, 2]]
print("dims:", dims)
if signature is not None and tuple(dims) != signature:
continue
#flow.render(name="output")
row.append(flow.render(size=1.3, double=double))
if len(row) == ncols:
rows.append(row)
row = []
print(len(row), len(rows))
PAD = 2.0
rows = [boxs.HBox([cvs for cvs in row], pad=PAD) for row in rows]
box = boxs.VBox(rows, pad=PAD)
box.save(name)
print("OK")
def decode(self, p, err_op, verbose=False, **kw):
from qupy.ldpc.metro import metropolis
#print "decode:"
#strop = self.strop
#print strop(err_op)
T = self.get_T(err_op)
all_Lx = list(solve.span(self.Lx))
M0 = argv.get('M0', 10000)
N0 = argv.get("N0", 1)
best_l = None
best_q = -self.n
best_i = None
best_T = None
#print
#print "T:"
#print strop(T)
for j in range(N0):
for i, l_op in enumerate(all_Lx):
#print "l_op:"
#print strop(l_op)
T1 = (T + l_op) % 2
# for h in self.Hx:
# if random()<0.5:
# T1 += h
# T1 %= 2
#q = -self.metropolis(p, T1, M0)
q = -metropolis(p, T1, M0, self.Hx)
#write("(%d)"%q)
#print "T %d:"%i
#print strop(T1)
if q > best_q:
best_l = l_op
best_q = q
best_i = i
best_T = T1
#print "_"*79
#write(":%d "%best_i)
#print "best_T"
#print strop(best_T)
T += best_l
T %= 2
#print "T"
#print strop(T)
return T
def find(self, target=None, stopat=None, idx=None, verbose=False):
Hx = self.Hx
Lx = self.Lx
M0 = argv.get("M0", 1)
target = target or argv.target
if idx is None:
best_i = 0
best_w = Lx[0].sum()
for i in range(1, Lx.shape[0]):
w = Lx[i].sum()
if w < best_w:
best_i = i
best_w = w
i = best_i
else:
i = idx
best_w = Lx[i].sum()
best_T = Lx[i]
write("%s:" % best_w)
H = zeros2(Lx.shape[0] - 1 + Hx.shape[0], self.n)
H[:i] = Lx[:i]
H[i:Lx.shape[0] - 1] = Lx[i + 1:]
H[Lx.shape[0] - 1:] = Hx
graph = Tanner(H)
T1 = Lx[i].copy()
for j in range(M0):
#print "l_op:"
#print strop(l_op)
T1 = best_T.copy()
#for op in Hx:
# if random()<0.5:
# T1 += op
# T1 %= 2
#for op in Lx:
# if random()<0.5:
# T1 += op
# T1 %= 2
if target:
T1 = graph.minimize(T1,
target,
maxsize=argv.maxsize,
verbose=verbose)
break
else:
T1 = graph.localmin(T1, stopat=stopat, verbose=verbose)
w = T1.sum()
if w and w < best_w:
best_T = T1
best_w = w
write("%s:" % w)
if stopat is not None and w <= stopat:
return best_T
return best_T
def test_flow():
seed(3)
m, n = argv.get("m", 3), argv.get("n", 3)
cx = Complex()
if argv.disc:
cx.build_surface((0, 0), (m, n))
k = 0
elif argv.surface:
cx.build_surface((0, 0), (m, n), open_top=True, open_bot=True)
k = 0
elif argv.torus:
cx.build_torus(m, n)
k = 2
else:
cx.build_torus(m, n)
k = 2
#print(cx)
for trial in range(10):
flow = Flow(cx)
flow.build()
if argv.render:
flow.render(name="output")
break
chain = flow.morse_homology(1)
A, B = chain
BA = B * A
for key, v in BA.elements.items():
assert v % 2 == 0
#print(BA.todense())
Hzt = A.todense() % 2
Hz = Hzt.transpose()
Hx = B.todense() % 2
assert dot2(Hx, Hzt).sum() == 0
code = CSSCode(Hx=Hx, Hz=Hz)
#print("k =", code.k)
assert code.k == k, (code.k, k)
def glue_logops():
m = argv.get("m", 4)
n = argv.get("n", m + m + 1)
dist = argv.get("dist", 3)
N = argv.get("N", 2)
M = argv.get("M", N)
p = argv.get("p", 0.03)
weight = argv.weight
codes = []
code = None
for i in range(N):
Hx, Hz = make_quantum(n, m, dist, weight)
#Hx, Hz = make_surface()
print("Hx, Hz:")
print(shortstrx(Hx, Hz))
c = CSSCode(Hx=Hx, Hz=Hz)
codes.append(c)
code = c if code is None else code + c
A, B = codes
code = A + B
print(code)
print("Lx, Lz:")
print(shortstrx(code.Lx, code.Lz))
print("Hx, Hz:")
print(shortstrx(code.Hx, code.Hz))
print()
#Hx = cat((code.Lx, code.Hx))
Hx = code.Hx
Hz = cat((code.Lz, code.Hz))
idxs = list(range(2 * n))
idxs.sort(key=lambda i: (-code.Lz[:, i].sum(), ))
Hx = Hx[:, idxs]
Hz = Hz[:, idxs]
print(shortstrx(Hx, Hz))
i0 = argv.get("i0")
i1 = argv.get("i1")
if i0 is None:
return
# code = code.glue(0, n)
# print(code)
# print(shortstrx(code.Hx, code.Hz))
Hx, Hz = glue1_quantum(Hx, Hz, i0, i1)
print("Hx, Hz:")
print(shortstrx(Hx, Hz))
def build_random(n):
weight = argv.get("weight", 3)
coweight = argv.get("coweight")
p = argv.get("p", 0.3)
m = argv.get("m", n)
mx = argv.get("mx", m)
mz = argv.get("mz", m)
if coweight is not None:
Gx = rand2(n, mx, weight=coweight).transpose()
Gz = rand2(n, mz, weight=coweight).transpose()
else:
Gx = rand2(mx, n, p=p, weight=weight)
Gz = rand2(mz, n, p=p, weight=weight)
Hx = Hz = None
Gx = Gx[[i for i in range(m) if Gx[i].sum()], :]
Gz = Gz[[i for i in range(m) if Gz[i].sum()], :]
li = argv.get("li", True)
if li:
Gx = linear_independent(Gx)
Gz = linear_independent(Gz)
return Gx, Gz, Hx, Hz
def test_ldpc():
n = argv.get("n", 14)
m = argv.get("m", n - 3)
d = argv.get("d", 0)
p = argv.get("p", 0.5)
weight = argv.get("weight", 4)
dist = argv.get("dist", 4)
H1 = make_ldpc(m, n, p, weight, dist)
#print(fstr(H1))
#Gt = find_kernel(H1)
#w = wenum(H1)
#print("wenum:", [len(wi) for wi in w])
H2 = make_ldpc(m, n, p, weight, dist)
#print(fstr(H2))
k = argv.get("k", 3)
pairs = [(i, i) for i in range(k)]
K = glue_pairs(H1, H2, pairs)
#print(fstr(K))
assert rank(K) == len(K)
print(ldpc_str(H1), "+", ldpc_str(H2), "=", ldpc_str(K))
if argv.show:
print(shortstr(K))
def test_borel():
n = argv.get("n", 4)
m = argv.get("m", 1)
q = argv.get("q", 2)
found = 0
for g in borel_sp(n, q):
found += 1
print("found:", found)
return
for cell in Cell.all_cells(n, m):
print(cell)
for v in cell.generate(q):
print(v)
print()
def main():
n = argv.get("n", 8)
k = argv.get("k", 4)
kt = argv.get("kt", 4)
d = argv.get("d", 1) # distance
na = argv.get("na", n)
nb = argv.get("nb", n)
ka = argv.get("ka", k)
kat = argv.get("kat", kt)
kb = argv.get("kb", k)
kbt = argv.get("kbt", kt)
A = random_code(na, ka, kat, d)
B = random_code(nb, kb, kbt, d)
#assert A.shape == (na-ka, na), (A.shape,)
#assert B.shape == (nb-kb, nb), (B.shape,)
print("A, B:")
print(shortstrx(A, B))
if 1:
# A tensor B
kw = hypergraph_product(A, B)
test_puncture(**kw)
else:
# --------------------------------------
#B, Bt = Bt, B
KerA = find_kernel(A).transpose()
ma = na-ka
mb = nb-kb
print("KerA:")
print(shortstrx(KerA))
print()
# print(shortstrx(kron(KerA, identity2(mb))))
print(shortstrx(
kron(identity2(mb), KerA),
kron(B, identity2(na))))
def test_quantum():
m = argv.get("m", 4)
n = argv.get("n", m + m + 1)
dist = argv.get("dist", 3)
N = argv.get("N", 2)
M = argv.get("M", N)
p = argv.get("p", 0.03)
weight = argv.weight
codes = []
code = None
for i in range(N):
Hx, Hz = make_quantum(n, m, dist, weight)
#Hx, Hz = make_surface()
print("Hx, Hz:")
print(shortstrx(Hx, Hz))
c = CSSCode(Hx=Hx, Hz=Hz)
codes.append(c)
code = c if code is None else code + c
for _ in range(2 * M):
print(code)
#code.save("glue.ldpc")
counts, err = score(code, p)
print("err = %.4f" % err)
i0 = numpy.argmin(counts)
i1 = numpy.argmax(counts)
assert i0 != i1
print(counts, i0, i1)
code = code.glue(i0, i1)
code = code.dual()
print(shortstrx(code.Hx, code.Hz))
return
code = CSSCode(Hx=Hx, Hz=Hz)
print(code)
code = code + code
print(shortstrx(code.Hx, code.Hz))
#Hx, Hz = glue1_quantum(code.Hx, code.Hz, 0, 1)
#code = CSSCode(Hx=Hx, Hz=Hz)
code = code.glue(0, n)
print(code)
print(shortstrx(code.Hx, code.Hz))
return
k = argv.get("k", 1)
pairs = [(i, i) for i in range(k)]
H1x, H1z = glue_quantum(Hx, Hz, Hx, Hz, pairs)
assert dot2(H1x, H1z.transpose()).sum() == 0
code = CSSCode(Hx=H1x, Hz=H1z)
print(code)
print(shortstrx(code.Hx, code.Hz))
def build_random_nostabs(n):
m = argv.get("m", n)
mx = argv.get("mx", m)
mz = argv.get("mz", m)
h = argv.get("h", 0)
hx = argv.get("hx", h)
hz = argv.get("hz", h)
while 1:
Gx, Gz, Hx, Hz = build_random(n)
if len(Gx) < mx or len(Gz) < mz:
write("m")
continue
Hx = find_stabilizers(Gz, Gx)
Hz = find_stabilizers(Gx, Gz)
if len(Hx) == hx and len(Hz) == hz:
break
write("H(%d,%d)" % (len(Hx), len(Hz)))
print()
return Gx, Gz, Hx, Hz
def find():
n = argv.get("n", 4)
assert n % 2 == 0, repr(n)
m = argv.get("m", 2)
q = argv.get("q", 2)
A = mk_form(n, q)
count = 0
for cell in Cell.all_cells(n, m):
found = 0
for U in cell.generate(q):
B = numpy.dot(U, numpy.dot(A, U.transpose())) % 2
if B.max():
continue
count += 1
found += 1
print(cell)
print(found)
print()
print(count)
def glue_gcolor():
from qupy.ldpc.gcolor import Lattice
l = argv.get('l', 1)
lattice = Lattice(l)
#code = lattice.build_code()
H = lattice.Hx
print("H:", H.shape)
print(shortstr(H))
m, n = H.shape
H1 = zeros2(m + 1, n + 1)
H1[1:, 1:] = H
H1[0, :] = 1
# print()
# print(shortstr(H1))
# for genus in range(1, 5):
# print(genus, strong_morthogonal(H1, genus))
H = H1
genus = argv.get("genus", 3)
H = H.astype(numpy.int32)
n = H.shape[1]
if argv.scramble:
R = rand2(m, m)
H = dot2(R, H)
print("H:", H.shape)
print(shortstrx(H))
assert dot2(H, H.transpose()).sum() == 0
i0 = argv.get("i0", 0)
i1 = argv.get("i1", i0)
i2 = argv.get("i2", n)
i3 = argv.get("i3", i2 + 1)
# glue i0<-->i2 and i1<-->i3
H2 = direct_sum(H, H)
print(H2.shape)
print(shortstrx(H2))
assert strong_morthogonal(H2, genus)
print()
H3 = glue_self_classical(H2, [(i0, i2), (i1, i3)])
print(H3.shape)
print(shortstrx(H3))
assert strong_morthogonal(H3, genus)
print()
print(shortstr((H2[:m, 1:n] + H3[:m, 1:n]) % 2))
#print(eq2(H2[m+2:, i1+2:], H3[m:, i1:]))
#print(classical_distance(H3))
return H3
def test_isotropic():
n = 3
gen, _ = get_gen(n)
assert len(mulclose_fast(gen)) == 1451520
return
n = argv.get("n", 3)
F = Matrix.symplectic_form(n).A
found = []
for A in all_codes(n, 2 * n):
B = dot2(dot2(A, F), A.transpose())
if B.sum() == 0:
A = Matrix(A)
found.append(A)
#print(A)
found = set(found)
print(len(found))
gen, _ = get_gen(n)
#gen = get_transvect(n)
orbit = set()
A = iter(found).__next__()
bdy = [A]
orbit = set(bdy)
while bdy:
_bdy = []
for A in bdy:
print(A)
for g in gen:
B = A * g
print(B)
print()
B = B.normal_form()
print(B)
print()
assert B in found
if B not in orbit:
_bdy.append(B)
orbit.add(B)
bdy = _bdy
print(len(orbit))
def decode(self, p, err, max_iter=None, verbose=False, **kw):
# if verbose:
# print
# print "RadfordBPDecoder.decode:"
# print shortstr(err)
# syndrome = self.check(err)
# print "syndrome:"
# print shortstr(syndrome)
d = self.d
assert d==2
stem = self.stem
if max_iter is None:
max_iter = argv.get("maxiter", self.n)
try:
os.unlink('%s.out'%stem)
except:
pass
cmd = './decode %s.pchk - %s.out bsc %.4f prprp %d' % (
stem, stem, p, max_iter)
#print(cmd)
#c_in = os.popen(cmd, 'w', 0)
c_in = os.popen(cmd, 'w')
#c_in, c_out = os.popen2(cmd, 'b', 0)
for x in err:
print(x, file=c_in)
c_in.close()
op = open('%s.out'%stem).read()
#op = c_out.read()
#print("[%s]" % repr(op), end="")
op = [int(c) for c in op.strip()]
syndrome = self.check(op)
# if verbose:
# print "result:"
# print shortstr(op)
# print "syndrome:"
# print shortstr(syndrome)
if syndrome.sum() == 0:
return (err + op) % d
def main():
# test that robustness is equiv. to full-rank property
#n, k, kt, d = 8, 4, 0, 1
cw = argv.get("cw", 3) # column weight
rw = argv.get("rw", 4) # row weight
n = argv.get("n", 8) # cols
m = argv.get("m", n * cw // rw) # rows
d = argv.get("d", 1) # distance
rank = argv.get("rank", 0)
print("m =", m)
trials = argv.get("trials", 1000)
while 1:
#H = random_code(n, k, kt, d)
H = make_gallagher(m, n, cw, rw, d)
if len(H) < rank:
continue
G = find_kernel(H)
print()
print("__" * 20)
print("G:%sH:" % (' ' * (n - 1), ))
print(shortstrx(G, H))
print(G.shape, H.shape)
result = get_bipuncture(G, H, trials)
print("get_bipuncture:", result)
robust = result is not None
if robust:
idxs, jdxs = result
build_echelon(G, H, idxs, jdxs)
rhs = has_property(G, trials)
assert robust == rhs, (robust, rhs)
#assert not rhs or robust # rhs ==> robust
#print(robust)
print()
if argv.robust:
assert robust
def write_gap(perms):
name = argv.get("name", "zorbit.gap")
print("open(%r, 'w')"%(name,))
f = open(name, 'w')
f.write("G:=Group(")
for i, perm in enumerate(perms):
#print len(perm)
#print str(perm)
cycles = get_cycles(perm)
if not cycles:
continue
s = ''.join(str(tuple(c)) for c in cycles)
s = s.replace(' ', '')
f.write(s)
if i+1<len(perms):
f.write(",\n ")
f.write(");\n")
f.write("G1:= SmallerDegreePermutationRepresentation(G);;\n");
f.write("Image(G1);\n");
f.close()
def wenum():
l = argv.get("l", 2)
code = Toric2D(l)
n = code.n
Hz = code.Hz
print(shortstr(Hz))
print()
Lz = code.Lz
print(shortstr(Lz))
Opz = numpy.concatenate((Hz, Lz))
x = Poly({(1, 0): 1})
y = Poly({(0, 1): 1})
zero = Poly({}, 2)
polys = {}
for v in numpy.ndindex((2, ) * len(Opz)):
key = str(v)
polys[key] = zero
for v in numpy.ndindex((2, ) * n):
w = sum(v)
key = str(tuple(dot2(Opz, v)))
g = x**w * y**(n - w)
polys[key] = polys[key] + g
for v in numpy.ndindex((2, ) * len(Opz)):
key = str(v)
print(v, polys[key])
f = reduce(add, polys.values())
print(f)
p = 0.05
f = eval(str(f), {"x": (1. - p), "y": p})
print(f)
print((x + y)**n)
def test_random():
"build a small random stabilizer code"
algebra = build_algebra(
"IXZY", "X*X=I Z*Z=I Y*Y=-I X*Z=Y Z*X=-Y X*Y=Z Y*X=-Z Z*Y=-X Y*Z=X")
I, X, Z, Y = algebra.basis
n = argv.get("n", 4)
ops = []
negi = -reduce(matmul, [I] * n)
items = [I, X, Z, Y]
itemss = [[I, X], [I, Z]]
while len(ops) < n - 1:
if argv.css:
items = choice(itemss)
op = [choice(items) for _ in range(n)]
op = reduce(matmul, op)
for op1 in ops:
if op1 * op != op * op1:
break
else:
#print(op)
ops.append(op)
G = mulclose_fast(ops)
if negi in G:
ops = []
for op in ops:
print(op, end=" ")
print()
code = StabilizerCode(algebra, ops)
#G = mulclose_fast(ops)
#for g in G:
# print(g, negi==g)
P = code.get_projector()
print(P.str())
print(P.str("@"))
def glue_classical():
from bruhat.triply_even import build
genus = argv.get("genus", 3)
m = argv.get("dim", 7)
idx = argv.get("idx", 144)
H = build.get(m, idx)
H = H.astype(numpy.int32)
n = H.shape[1]
if argv.scramble:
R = rand2(m, m)
H = dot2(R, H)
print(shortstrx(H))
assert dot2(H, H.transpose()).sum() == 0
i0 = argv.get("i0", 0)
i1 = argv.get("i1", i0)
i2 = argv.get("i2", n)
i3 = argv.get("i3", i2 + 1)
# glue i0<-->i2 and i1<-->i3
#H2 = direct_sum(H, H)
H2 = H
#print(shortstrx(H2))
assert strong_morthogonal(H2, genus)
print()
H3 = glue_self_classical(H2, [(i0, i2), (i1, i3)])
print(shortstrx(H3))
assert strong_morthogonal(H3, genus)
print()
print(shortstr((H2[:m, 1:n] + H3[:m, 1:n]) % 2))
#print(eq2(H2[m+2:, i1+2:], H3[m:, i1:]))
#print(classical_distance(H3))
return H3
def test():
norm = lambda v: (v**2).sum()**0.5
model = CodeModel()
if argv.test:
stabs = model.xstabs + model.zstabs
for A in stabs:
assert commutes(A, model.xlogop)
assert commutes(A, model.zlogop)
for B in stabs:
assert commutes(A, B)
#assert anticommutes(model.xlogop, model.zlogop)
print("OK")
return
if argv.threads:
os.environ['OMP_NUM_THREADS'] = str(argv.threads)
dim = model.A.n
v0 = None
if argv.stabdist:
v0 = numpy.zeros(len(model.A))
v0[0] = 1
k = argv.get("k", 2)
if k == "all":
k = A.n
A = model.A
if argv.perturb:
# # doesn't work very well...
# alpha = 0.0001
# perturb = [alpha * op for op in model.xstabs]
# A = SumOp(2**model.n, A.ops+perturb)
alpha = argv.get("alpha", 1e-4)
def rnd(alpha):
return alpha * (2 * random() - 1.)
ops = []
for i in range(model.n):
ops.append(rnd(alpha) * XOp(model.n, [i]))
ops.append(rnd(alpha) * ZOp(model.n, [i]))
A = SumOp(2**model.n, A.ops + ops)
projs = []
I = IdOp(A.n)
flip = argv.get("flip", 0)
zflip = argv.get("zflip", 0)
if zflip:
stabs = model.zstabs + model.xstabs
flip = zflip
else:
stabs = model.xstabs + model.zstabs
for op in stabs:
if flip:
op = 0.5 * (I - op)
flip -= 1
else:
op = 0.5 * (I + op)
projs.append(op)
if projs:
P = projs[0]
for i in range(1, len(projs)):
P = P * projs[i]
if argv.stabilize:
A = P * A * P
if argv.logop:
P = 0.5 * (I + model.xlogop)
A = P * A * P
if argv.exact:
assert A.n < 2**14
A = A.todense()
vals, vecs = numpy.linalg.eigh(A)
elif argv.power:
v = numpy.random.normal(size=A.n)
v /= norm(v)
sigma = 1.0
while 1:
u = A._matvec(v)
eigval = numpy.dot(v, u)
u = u + sigma * v
r = norm(u)
if r > EPSILON:
u /= r
err = norm(u - v)
print("delta:", err)
print("eig:", eigval)
if err < 1e-4:
break
v = u
else:
A.verbose = True
which = argv.get("which", 'LA')
vals, vecs = la.eigsh(A, k=k, v0=v0, which=which,
maxiter=None) #, tol=1e-8)
#vals, vecs = la.eigs(A, k=k, v0=v0, which='LR', maxiter=None) #, tol=1e-8)
print()
print("vecs.shape:", vecs.shape)
if argv.transversal:
n = model.n
w = cyclotomic(8)
print(w)
T = ROp(n, list(range(n)), w)
print(T.phases)
for i in range(vecs.shape[1]):
v = vecs[:, i]
#v = T._matvec(v)
v = T.phases * v
u = A._matvec(v.real) + 1.j * A._matvec(v.imag)
eigval = numpy.dot(v.conj(), u)
print(numpy.dot(v.conj(), v))
print("eigval:", vals[i], "-->", eigval.real)
# vals go from smallest to highest
show_eigs(vals)
#print "iterations:", model.A.count
if argv.verbose:
for i in range(k):
print(i, "syndrome", model.get_syndrome(vecs[:, i]))
return
idx = argv.get("idx", 0)
k = vecs.shape[1]
v0 = vecs[:, k - 1 - idx]
pos, = numpy.where(v0 > +EPSILON)
neg, = numpy.where(v0 < -EPSILON)
print("pos: %d, neg: %d" % (len(pos), len(neg)))
print("v[0]", v0[0])
print(v0[pos[:10]], v0[neg[:10]])
# v0 = numpy.abs(v0)
#
# count = 0
# idxs = []
# values = []
# for i in range(dim):
# if abs(v0[i]) > EPSILON:
# #write(i)
# idxs.append(i)
# values.append(v0[i])
# print "nnz:", len(idxs)
if argv.plot:
plot(model, v0)
return
propagate = SumOp(2**model.n, model.xops)
syndrome = numpy.zeros(dim)
for op in model.zops:
syndrome += op.phases
idxs = [i for i in range(dim) if v0[i] > EPSILON]
idxs.sort(key=lambda i: -syndrome[i])
value = v0[idxs[0]]
best = []
for idx in idxs:
if v0[idx] >= value - EPSILON:
best.append(idx)
else:
break
print("best:", best)
marked = set(best)
for i in idxs:
for xop in model.xops:
j = xop.perm[i]
if j in marked:
continue
marked.add(j)
continue # <---------
if syndrome[j] > syndrome[i]:
#print "*", i, '->', j, 'and', syndrome[i], syndrome[j]
print(strop(l, i), syndrome[i])
print("->")
print(strop(l, j), syndrome[j])
print(v0[i], "->", v0[j])
print()
for i in idxs:
for xop in model.xops:
j = xop.perm[i]
if syndrome[j] > syndrome[i] and v0[j] < v0[i]:
#print "*", i, '->', j, 'and', syndrome[i], syndrome[j]
print(strop(l, i), syndrome[i])
print("->")
print(strop(l, j), syndrome[j])
print(v0[i], "->", v0[j])
print()
def slepc(Gx, Gz, Hx, Hz, Rx, Rz, Pxt, Qx, Pz, Tx, **kw):
name = argv.get("name", "ex3.tmp.c")
print("slepc: name=%s"%name)
r = len(Rx)
n = 2**r
assert (r<40), "ugh"
#code = Code("body.h")
code = Code()
code.append("#define DIMS (%d)"%n)
code.append("static void matmult(PetscScalar *py, const PetscScalar *px, long nx)")
code.begin()
code.append("assert(DIMS == %d);"%n)
code.append("assert(nx == %d);"%n)
code.append("memset(py, 0, sizeof(PetscScalar)*nx);")
offset = argv.get("offset", None)
mz = len(Gz)
t = None
#excite = argv.excite
#if excite is None:
excite = kw.get("excite") or argv.excite
if excite is not None:
print("excite:", excite)
if type(excite) is tuple:
t = Tx[excite[0]]
for i in range(1, len(excite)):
t = (t + Tx[excite[i]])%2
else:
assert type(excite) in (int, int)
t = Tx[excite]
print("t:", shortstr(t))
Gzt = dot2(Gz, t)
print("Gzt:", shortstr(Gzt))
weights = kw.get("weights")
if weights is not None:
assert len(weights)==len(Gx)
RR = dot2(Gz, Rx.transpose())
PxtQx = dot2(Pxt, Qx)
gxs = [getnum(dot2(gx, PxtQx)) for gx in Gx]
gxs.sort()
uniq_gxs = list(set(gxs))
uniq_gxs.sort()
code.append("long v;")
code.append("int k;")
code.append("struct timeval t0, t1;")
code.append("gettimeofday(&t0, NULL);")
code.append("for(v=0; v<%d; v++)"%n)
code.begin()
code.append("double pxv = px[v];")
if n >= 128:
code.append(r'if((v+1) %% %d == 0)' % (n//128))
code.begin()
code.append("gettimeofday(&t1, NULL);")
code.append("long delta = t1.tv_sec-t0.tv_sec;")
code.append("if(delta>1)")
code.append('{printf("[%lds]", delta);fflush(stdout);}')
code.append('t0 = t1;')
code.end()
code.append("k = 0;")
for i, row in enumerate(RR):
if t is not None and Gzt[i]==1:
code.append("k += (countbits_fast(v&%s)+1) %% 2;" % getnum(row))
else:
code.append("k += countbits_fast(v&%s) %% 2;" % getnum(row))
cutoff = argv.cutoff
if cutoff is not None:
code.append("if(k>%d) continue; // <-------- continue" % cutoff)
else:
code.append("if(k>cutoff) continue; // <-------- continue")
code.append("py[v] += pxv * (%d - 2*k);" % mz)
if weights is None:
for gx in uniq_gxs:
s = '+'.join(['pxv']*gxs.count(gx))
code.append("py[v^%s] += %s;" % (gx, s))
else:
gxs = [getnum(dot2(gx, PxtQx)) for gx in Gx]
for i, gx in enumerate(gxs):
code.append("py[v^%s] += %s*pxv;" % (gx, weights[i]))
code.end()
code.end()
if name is None:
return
s = code.output()
src = open("ex3.c").read()
match = '\n#include "body.h"\n'
assert match in src
src = src.replace(match, s)
assert name and name.endswith(".c")
f = open(name, 'w')
tag = hash(src)
print(("hash(src):", tag))
f.write(src)
f.close()
import socket
host = socket.gethostname()
if host == "bucket":
cmd = "gcc MATCH.c -O3 -o MATCH -I/home/simon/local/petsc/arch-linux2-c-debug/include -I/home/simon/local/petsc/include/petsc/mpiuni -I/home/simon/local/petsc/include -I/home/simon/local/slepc-3.7.1/include -I/home/simon/local/slepc-3.7.1/arch-linux2-c-debug/include/ -L/home/simon/local/petsc/arch-linux2-c-debug/lib -L/home/simon/local/slepc-3.7.1/arch-linux2-c-debug/lib -lpetsc -lslepc"
elif host == "hero":
cmd = "gcc MATCH.c -O3 -o MATCH -I/usr/include/openmpi -I/usr/include/petsc -I/usr/include/slepc -lpetsc -lslepc -lmpi"
else:
cmd = "gcc -O3 MATCH.c -I/suphys/sburton/include/ -o MATCH -lpetsc -L$PETSC_DIR/$PETSC_ARCH/lib -L$SLEPC_DIR/$PETSC_ARCH/lib -lslepc"
cmd = cmd.replace("MATCH.c", name)
stem = name[:-2]
cmd = cmd.replace("MATCH", stem)
rval = os.system(cmd)
assert rval == 0
#print("exec:", hash(open(stem).read()))
nev = argv.get("nev", 1)
cmd = "./%s -eps_nev %d -eps_ncv %d -eps_largest_real"
if argv.plot:
cmd += " -eps_view_vectors binary:evec.bin "
cmd = cmd%(stem, nev, max(2*nev, 4))
eps_tol = argv.get("eps_tol", 1e-4)
if eps_tol is not None:
cmd += " -eps_tol %s "%eps_tol
#cmd += " -eps_type arnoldi -info -eps_monitor -eps_tol 1e-3"
print(cmd)
#rval = os.system(cmd)
#assert rval == 0
f = os.popen(cmd)
s = f.read()
#print(s)
lines = s.split('\n')
vals = []
for line in lines:
line = line.strip()
flds = line.split()
#print("parse", flds)
try:
a, b = flds
a = float(a)
b = float(b)
vals.append(a)
except:
pass
if not argv.plot:
print(("vals:", vals))
return vals
assert argv.plot.endswith(".pdf")
s = open("evec.bin").read()
sz = 8*2**r
if len(s)==sz+8:
s = s[8:]
elif len(s)==sz+16:
s = s[16:]
#elif len(s)==2*(sz+16): # got two vectors
# s = s[16:16+sz] # pick the first vector
elif len(s)%(sz+16) == 0:
count = len(s)/(sz+16)
# s = s[16:16+sz] # pick the first vector
ev_idx = argv.get("ev_idx", 0)
s = s[16+ev_idx*(16+sz):(ev_idx+1)*(16+sz)]
else:
assert 0, "sz=%d but s=%s"%(sz, len(s))
vec0 = numpy.fromstring(s, dtype=">d")
assert len(vec0)==2**r
assert excite is None
print("graphing...")
gz, n = Gz.shape
xdata = []
lookup = {}
GzRxt = dot2(Gz, Rx.transpose())
for i, v in enumerate(genidx((2,)*r)):
v = array2(v)
lookup[v.tobytes()] = i
syndrome = dot2(GzRxt, v)
value = gz - 2*syndrome.sum()
xdata.append(value)
pdata = {}
ndata = {}
my = 20. # mul y
EPSILON = argv.get("EPSILON", 1e-6)
def yfunc(y):
y = log2(abs(y))
y = int(round(my*y))
return y
for i in range(len(vec0)):
x = xdata[i] # integer
y = vec0[i]
if abs(y) < EPSILON:
continue
if y > 0.:
y = yfunc(y)
pdata[x, y] = pdata.get((x, y), 0) + 1
else:
y = yfunc(y)
ndata[x, y] = ndata.get((x, y), 0) + 1
from pyx import graph, canvas, path, trafo, color, deco, text
north = [text.halign.boxcenter, text.valign.top]
northeast = [text.halign.boxright, text.valign.top]
northwest = [text.halign.boxleft, text.valign.top]
south = [text.halign.boxcenter, text.valign.bottom]
southeast = [text.halign.boxright, text.valign.bottom]
southwest = [text.halign.boxleft, text.valign.bottom]
east = [text.halign.boxright, text.valign.middle]
west = [text.halign.boxleft, text.valign.middle]
center = [text.halign.boxcenter, text.valign.middle]
c = canvas.canvas()
sx = 0.4
sy = 1.4
tr = trafo.scale(sx, sy)
green = color.rgb(0.2,0.6,0.2)
brown = color.rgb(0.8,0.2,0.2)
grey = color.rgb(0.4,0.4,0.4)
lgrey = color.rgb(0.8,0.8,0.8)
W = 2*gz
H = log2(EPSILON)
dy = 0.5 * 1.2/my
X0 = -gz
Y0 = 0.
def showp(gx, radius):
v = dot2(gx, PxtQx)
syndrome = dot2(GzRxt, v)
x = gz - 2*syndrome.sum()
i = lookup[v.tobytes()]
#print syndrome, syndrome.sum(), vec0[i]
y = (1./my)*yfunc(vec0[i]) + 0.5*dy
#y = 0.5*dy + log2(abs(vec0[i]))
c.fill(path.circle(-x*sx, y*sy, radius), [lgrey])
showp(zeros2(n), 0.8)
for gx in Gx:
showp(gx, 0.4)
for gx0 in Gx:
for gx1 in Gx:
gx = (gx0+gx1)%2
if gx.sum()==0:
continue
showp(gx, 0.2)
for i in range(0, gz+1):
x, y = X0+2*i, Y0
c.stroke(path.line(x, y, x, y+H), [tr, grey])
if i%2 == 0:
c.text(x*sx, y*sy + 0.2, "%d"%i, south)
c.stroke(path.line(X0, Y0, X0+1.0*W+3.5, Y0), [tr, deco.earrow(size=0.5)])
c.stroke(path.line(X0, Y0, X0, Y0+1.0*H-0.5), [tr, deco.earrow(size=0.5)])
y = 1.0
i = 0
while y > EPSILON:
x = X0*sx
y1 = sy*(1./my)*yfunc(y)
c.stroke(path.line(x, y1, x-0.1, y1))
c.text(x-0.3, y1, "%d"%i, east)
y /= 2.
i -= 1
R = 0.15
for key, value in list(pdata.items()):
x, y = key
y = y/my
x = -x
value = 1 + math.log(value)
r = R*value
#c.stroke(path.circle(x, y, r))
#c.stroke(path.line(x, y, x+r, y), [brown, tr])
c.fill(path.rect(x, y, r, dy), [brown, tr])
for key, value in list(ndata.items()):
x, y = key
y = y/my
x = -x
value = 1 + math.log(value)
r = R*value
#c.stroke(path.circle(x, y, r))
#c.stroke(path.line(x-r, y, x, y), [green, tr])
c.fill(path.rect(x-r, y, r, dy), [green, tr])
c.writePDFfile(argv.plot)
if 0:
print("graph..")
g = graph.graphxy(
width=16,
x=graph.axis.linear(reverse=True),
y=graph.axis.linear())
#y=graph.axis.log(min=0.8*vec0.min(), max=1.2*vec0.max()))
g.plot(graph.data.values(x=xdata, y=ydata))
g.writePDFfile(argv.plot)
def main():
import models
assert not argv.orbiham, "it's called orbigraph now"
if argv.find_ideals:
find_ideals()
return
Gx, Gz, Hx, Hz = models.build()
if argv.chainmap:
do_chainmap(Gx, Gz)
if argv.symmetry:
do_symmetry(Gx, Gz, Hx, Hz)
return
#print shortstrx(Gx, Gz)
if argv.report:
print("Hz:")
for i, h in enumerate(Hz):
print(i, shortstr(h), h.sum())
#print shortstr(find_stabilizers(Gx, Gz))
Lz = find_logops(Gx, Hz)
Lx = find_logops(Gz, Hx)
#print "Lz:", shortstr(Lz)
if Lz.shape[0]*Lz.shape[1]:
print(Lz.shape, Gx.shape)
check_commute(Lz, Gx)
check_commute(Lz, Hx)
Px = get_reductor(Hx) # projector onto complement of rowspan of Hx
Pz = get_reductor(Hz)
Rz = [dot2(Pz, g) for g in Gz]
Rz = array2(Rz)
Rz = row_reduce(Rz, truncate=True)
rz = len(Rz)
n = Gx.shape[1]
print("n =", n)
if len(Lx):
print("Lx Lz:")
print(shortstrx(Lx, Lz))
print("Hx:", len(Hx), "Hz:", len(Hz))
print("Gx:", len(Gx), "Gz:", len(Gz))
Rx = [dot2(Px, g) for g in Gx]
Rx = array2(Rx)
Rx = row_reduce(Rx, truncate=True)
rx = len(Rx)
print("Rx:", rx, "Rz:", rz)
if argv.show:
print(shortstrx(Rx, Rz))
Qx = u_inverse(Rx)
Pxt = Px.transpose()
assert eq2(dot2(Rx, Qx), identity2(rx))
assert eq2(dot2(Rx, Pxt), Rx)
#print shortstr(dot2(Pxt, Qx))
PxtQx = dot2(Pxt, Qx)
lines = [shortstr(dot2(g, PxtQx)) for g in Gx]
lines.sort()
#print "PxtQx:"
#for s in lines:
# print s
#print "RzRxt"
#print shortstr(dot2(Rz, Rx.transpose()))
offset = argv.offset
if len(Hz):
Tx = find_errors(Hz, Lz, Rz)
else:
Tx = zeros2(0, n)
if argv.dense:
dense(**locals())
return
if argv.dense_full:
dense_full(**locals())
return
if argv.show_delta:
show_delta(**locals())
return
if argv.slepc:
slepc(**locals())
return
# if argv.orbigraph:
# from linear import orbigraph
# orbigraph(**locals())
# return
v0 = None
# excite = argv.excite
# if excite is not None:
# v0 = zeros2(n)
# v0[excite] = 1
verts = []
lookup = {}
for i, v in enumerate(span(Rx)): # XXX does not scale well
if v0 is not None:
v = (v+v0)%2
v = dot2(Px, v)
lookup[v.tobytes()] = i
verts.append(v)
print("span:", len(verts))
assert len(lookup) == len(verts)
mz = len(Gz)
n = len(verts)
if argv.lie:
U = []
for i, v in enumerate(verts):
count = dot2(Gz, v).sum()
Pxv = dot2(Px, v)
assert count == dot2(Gz, Pxv).sum()
U.append(mz - 2*count)
uniq = list(set(U))
uniq.sort(reverse=True)
s = ', '.join("%d(%d)"%(val, U.count(val)) for val in uniq)
print(s)
print("sum:", sum(U))
return
if n <= 1024 and argv.solve:
H = numpy.zeros((n, n))
syndromes = []
for i, v in enumerate(verts):
syndromes.append(dot2(Gz, v))
count = dot2(Gz, v).sum()
Pxv = dot2(Px, v)
assert count == dot2(Gz, Pxv).sum()
H[i, i] = mz - 2*count
for g in Gx:
v1 = (g+v)%2
v1 = dot2(Px, v1)
j = lookup[v1.tobytes()]
H[i, j] += 1
if argv.showham:
s = lstr2(H, 0).replace(', ', ' ')
s = s.replace(' 0', ' .')
s = s.replace(', -', '-')
print(s)
vals, vecs = numpy.linalg.eigh(H)
show_eigs(vals)
if argv.show_partition:
beta = argv.get("beta", 1.0)
show_partition(vals, beta)
if argv.orbigraph:
if argv.symplectic:
H1 = build_orbigraph(H, syndromes)
else:
H1 = build_orbigraph(H)
print("orbigraph:")
print(H1)
vals, vecs = numpy.linalg.eig(H1)
show_eigs(vals)
elif argv.sparse:
print("building H", end=' ')
A = {} # adjacency
U = [] # potential
if offset is None:
offset = mz + 1 # make H positive definite
for i, v in enumerate(verts):
if i%1000==0:
write('.')
count = dot2(Gz, v).sum()
#H[i, i] = mz - 2*count
U.append(offset + mz - 2*count)
for g in Gx:
v1 = (g+v)%2
v1 = dot2(Px, v1)
j = lookup[v1.tobytes()]
A[i, j] = A.get((i, j), 0) + 1
print("\nnnz:", len(A))
if argv.lanczos:
vals, vecs = do_lanczos(A, U)
elif argv.orbigraph:
vals, vecs = do_orbigraph(A, U)
else:
return
vals -= offset # offset doesn't change vecs
show_eigs(vals)
elif argv.orbigraph:
assert n<=1024
H = numpy.zeros((n, n))
syndromes = []
for i, v in enumerate(verts):
syndromes.append(dot2(Gz, v))
count = dot2(Gz, v).sum()
Pxv = dot2(Px, v)
assert count == dot2(Gz, Pxv).sum()
H[i, i] = mz - 2*count
for g in Gx:
v1 = (g+v)%2
v1 = dot2(Px, v1)
j = lookup[v1.tobytes()]
H[i, j] += 1
if argv.showham:
s = lstr2(H, 0).replace(', ', ' ')
s = s.replace(' 0', ' .')
s = s.replace(', -', '-')
print(s)
if argv.symplectic:
H1 = build_orbigraph(H, syndromes)
else:
H1 = build_orbigraph(H)
def build(name=""):
if name:
setattr(argv, name, True) # hack this
_seed = argv.get("seed")
if _seed is not None:
numpy.random.seed(_seed)
seed(_seed)
size = argv.get("size", 1)
l = argv.get('l', 4)
li = argv.get('li', l)
lj = argv.get('lj', l)
lk = argv.get('lk', l)
if argv.gcolor2 or (argv.gcolor and size == 1.5):
Gx, Gz, Hx = build_gcolor2()
Hz = Hx.copy()
elif argv.gcolor:
Gx, Gz, Hx = build_gcolor(size)
Hz = Hx.copy()
elif argv.compass:
Gx, Gz, Hx, Hz = build_compass(li, lj)
elif argv.compass3:
Gx, Gz, Hx, Hz = build_compass3(li, lj, lk)
elif argv.hex:
Gx, Gz, Hx, Hz = build_hex(li, lj)
elif argv.hex2:
Gx, Gz, Hx, Hz = build_hex2(li, lj)
elif argv.xy:
Gx, Gz, Hx, Hz = build_xy(l)
elif argv.xy2:
Gx, Gz, Hx, Hz = build_xy2(li, lj)
elif argv.xy21:
Gx, Gz, Hx, Hz = build_xy21(li, lj)
elif argv.xy3:
Gx, Gz, Hx, Hz = build_xy3(li, lj, lk)
elif argv.xy32:
Gx, Gz, Hx, Hz = build_xy32(li, lj, lk)
elif argv.ising:
Gx, Gz, Hx, Hz = build_ising(l)
elif argv.random:
Gx, Gz, Hx, Hz = build_random(l)
elif argv.random_nostabs:
Gx, Gz, Hx, Hz = build_random_nostabs(l)
elif argv.random_selfdual:
Gx, Gz, Hx, Hz = build_random_selfdual(l)
elif argv.pauli:
Gx, Gz, Hx, Hz = build_pauli(l)
elif argv.projective:
n = argv.get('n', 3)
dim = argv.get('dim', 2)
Gx, Gz, Hx, Hz = build_projective(n, dim)
elif argv.test:
Gx, Gz, Hx, Hz = build_test()
else:
name = argv.next()
try:
fn = eval("build_%s" % name)
except NameError:
print("no model found")
raise
Gx, Gz, Hx, Hz = fn()
if Hx is None:
Hx = find_stabilizers(Gz, Gx)
if Hz is None:
Hz = find_stabilizers(Gx, Gz)
if argv.flip:
Gz, Gx = Gx, Gz
Hz, Hx = Hx, Hz
if argv.show:
print("Gx Gz:")
print(shortstrx(Gx, Gz))
if len(Hx):
print("Hx Hz:")
print(shortstrx(Hx, Hz))
return Gx, Gz, Hx, Hz
def test_code(Hxi, Hzi, Hx, Lx, Lz, Lx0, Lx1, LxiHx, **kw):
code = CSSCode(Hx=Hxi, Hz=Hzi)
print(code)
assert rank(intersect(Lx, code.Lx)) == code.k
assert rank(intersect(Lz, code.Lz)) == code.k
verbose = argv.verbose
decoder = get_decoder(argv, argv.decode, code)
if decoder is None:
return
p = argv.get("p", 0.01)
N = argv.get("N", 0)
distance = code.n
count = 0
failcount = 0
nonuniq = 0
logops = []
for i in range(N):
err_op = ra.binomial(1, p, (code.n, ))
err_op = err_op.astype(numpy.int32)
op = decoder.decode(p, err_op, verbose=verbose, argv=argv)
c = 'F'
success = False
if op is not None:
op = (op + err_op) % 2
# Should be a codeword of Hz (kernel of Hz)
assert dot2(code.Hz, op).sum() == 0
write("%d:" % op.sum())
# Are we in the image of Hx ? If so, then success.
success = dot2(code.Lz, op).sum() == 0
if success and op.sum():
nonuniq += 1
c = '.' if success else 'x'
if op.sum() and not success:
distance = min(distance, op.sum())
write("L")
logops.append(op.copy())
else:
failcount += 1
write(c + ' ')
count += success
if N:
print()
print(argv)
print("error rate = %.8f" % (1. - 1. * count / (i + 1)))
print("fail rate = %.8f" % (1. * failcount / (i + 1)))
print("nonuniq = %d" % nonuniq)
print("distance <= %d" % distance)
mx0, mx1 = len(Lx0), len(Lx1)
LxHx = numpy.concatenate((Lx0, Lx1, Hx))
for op in logops:
print(op.sum())
#print(shortstr(op))
#print(op.shape)
#print(op)
K = solve(LxHx.transpose(), op)
K.shape = (1, len(K))
print(shortstrx(K[:, :mx0], K[:, mx0:mx0 + mx1], K[:, mx0 + mx1:]))
def main():
if argv.ldpc:
# LDPC
l = argv.get("l", 3) # column weight
m = argv.get("m", 4) # row weight
n = argv.get("n", 8) # cols
r = argv.get("r", n * l // m) # rows
d = argv.get("d", 1) # distance
print("make_gallagher%s" % ((r, n, l, m, d), ))
C = make_gallagher(r, n, l, m, d)
print(shortstr(C))
print()
print(shortstr(C))
print("rank(C) = ", rank(C), "kernel(C) = ", len(find_kernel(C)))
if argv.same:
D = C
else:
D = make_gallagher(r, n, l, m, d)
assert rank(C) == len(C)
assert rank(D) == len(D)
print("rank(D)", rank(D), "kernel(D)", len(find_kernel(D)))
elif argv.hrand:
#C = random_code(16, 8, 0, 3)
C = random_code(8, 4, 0, 3)
D = random_code(8, 4, 1, 3)
elif argv.hvrand:
#C = random_code(16, 8, 8, 3)
C = random_code(8, 4, 4, 3)
D = random_code(8, 4, 4, 3)
elif argv.hvrandsmall:
#C = random_code(16, 8, 8, 3)
C = random_code(7, 1, 1, 2) # n, k, kt, d
D = random_code(7, 1, 1, 2)
elif argv.samerand:
C = random_code(12, 6, 0, 4)
D = C
elif argv.smallrand:
# make some vertical logops from rank degenerate parity check matrices
C = random_code(8, 4, 0, 3)
D = random_code(6, 3, 0, 2)
elif argv.cookup:
# [12,6,4] example that has no k-bipuncture
C = parse("""
.1..1111....
111.11111111
11.111...11.
1..11...1.11
.11...1...11
..11.11.111.
""")
D = C
R = row_reduce(C)
print(shortstr(R))
elif argv.cookup2:
# [12,6,4] example that has no k-bipuncture
C = parse("""
.11..1.11..1
11...1111...
1....1.11111
..1.1111..1.
111....1.11.
1111.11...11
.1.1.1....1.
1111111.1111
....1..111..
.1..1.111.11
11.11......1
11..1111.1..
""")
D = C
elif argv.pair:
#C = make_gallagher(9, 12, 3, 4, 4) # big
C = make_gallagher(15, 20, 3, 4, 4) # big
D = make_gallagher(6, 8, 3, 4, 1) # small
elif argv.torus:
# Torus
C = parse("""
11..
.11.
..11
1..1
""")
D = C
elif argv.hamming:
C = parse("""
...1111
.11..11
1.1.1.1
111....
""")
D = C
elif argv.surf or argv.surface:
# Surface
C = parse("""
11....
.11...
..11..
...11.
....11
""")
D = parse("""
11..
.11.
..11
""")
elif argv.small:
C = parse("""1111""")
D = parse("""1111""")
else:
print("please specify a code")
return
print("C: shape=%s, rank=%d, dist=%d" %
(C.shape, rank(C), classical_distance(C)))
print("C.t: dist=%d" % (classical_distance(C.transpose()), ))
print(shortstr(C))
print("D: shape=%s, rank=%d, dist=%d" %
(D.shape, rank(D), classical_distance(D)))
print("D.t: dist=%d" % (classical_distance(D.transpose()), ))
print(shortstr(D))
Ct = C.transpose()
Dt = D.transpose()
if argv.dual:
C, Ct = Ct, C
D, Dt = Dt, D
if argv.test_puncture:
test_puncture(C)
return # <--------- return
if argv.test_indep:
kw = hypergraph_product(C, Dt)
test_indep(**kw)
return # <--------- return
if argv.test_code:
kw = hypergraph_product(C, Dt)
test_code(**kw)
return # <--------- return
if argv.test_overlap:
#while 1:
kw = hypergraph_product(C, Dt)
success = test_overlap(**kw)
print("success:", success)
if argv.success:
assert success
#if success:
# break
#else:
# sys.exit(0)
C = shuff22(C)
if argv.same:
D = C
Dt = D.transpose()
else:
Dt = shuff22(Dt)