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)