idx0 = int(0.5*(1-frac)*len(data))
idx1 = int(0.5*(1+frac)*len(data))
return p-data[idx0], data[idx1]-p
def XXX_squeeze2(N, p, frac=None):
assert 0.<=p<=1.
var = math.sqrt(p*(1.-p)/N)
print("squeeze2:", N, p, "=", var)
return max(0., p-var), min(1., p+var)
name = argv.next()
s = open(name).read()
lines = s.split("\n")
rows = {}
attrs = None
for line in lines:
line = line.strip()
if not line and not attrs:
pass
elif not line:
assert name != "Icosa", "not implemented" # represented as a perm group... :P
gap = Gap()
PROMPT = "gap> "
gap.expect(PROMPT)
gap.send("G:=SmallGroup(%d, %d);" % (i,j))
s = gap.expect(PROMPT)
gap.send("Elements(G);")
s = gap.expect(PROMPT)
els = parse_els(s)
print(els)
gap.send("IrreducibleRepresentations(G);")
s = gap.expect(PROMPT)
irreps = parse_irreps(s, els)
main(argv.next())
A = parse(s)
assert A*P == P*A
A = parse('HHHHH')
assert A*P != P*A
A = parse('SSSSS')
assert A*P != P*A
# steane code ----------------
code = StabilizerCode("XXXXIII XXIIXXI XIXIXIX ZZZZIII ZZIIZZI ZIZIZIZ")
P = code.get_projector()
for s in 'XZSH':
s = s*code.n
A = parse(s)
assert A*P == P*A
print("OK")
if __name__ == "__main__":
name = argv.next() or "test"
fn = eval(name)
fn()
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
# l=3 toric code
s = "y**18 + 9*x**4 * y**14 + 24*x**6 * y**12 + \
99*x**8 * y**10 + 72*x**10 * y**8 + 51*x**12 * y**6"
# l=4 toric code
s = "1*x**0*y**32 + 16*x**4*y**28 + 32*x**6*y**26 + \
212*x**8*y**24 + 864*x**10*y**22 + 3344*x**12*y**20 + \
6784*x**14*y**18 + 10262*x**16*y**16 + 6784*x**18*y**14 + \
3344*x**20*y**12 + 864*x**22*y**10 + 212*x**24*y**8 + \
32*x**26*y**6 + 16*x**28*y**4 + 1*x**32*y**0"
p = eval(s, {"x": x, "y": y})
print(p)
p = eval(s, {"x": x + y, "y": x - y})
p = p / 32768.
print(p)
if __name__ == "__main__":
_seed = argv.seed
if _seed is not None:
seed(_seed)
numpy.random.seed(_seed)
fn = argv.next() or "main"
fn = eval(fn)
fn()
fold = In
for i, j in enumerate(perm):
if i < j:
fold *= make_cz(i, j, code.n)
elif i==j:
fold *= make_op(S, i, code.n)
print("fold")
#lhs = fold * code.get_projector()
lhs = fold * code.Pz * code.Px
print("lhs")
rhs = code1.Pz * (code1.Px * fold)
print("rhs")
print(lhs == rhs)
if argv.pause:
print("done...")
while 1:
sleep(1)
if __name__ == "__main__":
name = argv.next() or "main"
fn = eval(name)
fn()
print("OK")
orbits = []
while remain:
i = iter(remain).__next__()
remain.remove(i)
orbit = [i]
for perm in perms:
j = perm[i]
if j in remain:
remain.remove(j)
orbit.append(j)
orbits.append(orbit)
orbits.sort(key=len)
print("%d orbits:" % len(orbits))
for orbit in orbits:
print("size =", len(orbit))
for idx in orbit:
space = spaces[idx]
U = space.U
if q == 2:
U = row_reduce(U)
#print(U)
if __name__ == "__main__":
fn = argv.next()
if fn is not None:
fn = eval(fn)
fn()
def build_code(pauli, name=None):
I = pauli.I
X = pauli.X
Y = pauli.Y
Z = pauli.Z
def mk_stab(s):
s = s.replace(".", "I")
sx = s.replace("1", "X")
sz = s.replace("1", "Z")
code = StabilizerCode(pauli, sx+sz)
return code
if name is None:
name = argv.next()
if name=="two":
code = StabilizerCode(pauli, "XX ZZ")
elif name=="four":
code = StabilizerCode(pauli, "XXII ZZII IIXX IIZZ")
elif name=="five":
code = StabilizerCode(pauli, "XZZXI IXZZX XIXZZ ZXIXZ")
op = (I@I@I@I@I+I@X@Z@Z@X-I@Z@Y@Y@Z-I@Y@X@X@Y
+X@I@X@Z@Z-X@X@Y@I@Y+X@Z@Z@X@I-X@Y@I@Y@X
-Z@I@Z@Y@Y+Z@X@I@X@Z+Z@Z@X@I@X-Z@Y@Y@Z@I
-Y@I@Y@X@X-Y@X@X@Y@I-Y@Z@I@Z@Y-Y@Y@Z@I@Z)
assert op == code.get_projector()
elif name=="seven":
code = StabilizerCode(pauli, "XZZXIII IXZZXII IIXZZXI IIIXZZX XIIIXZZ ZXIIIXZ")
elif name=="steane":
code = StabilizerCode(pauli, "XXXXIII XXIIXXI XIXIXIX ZZZZIII ZZIIZZI ZIZIZIZ")
elif name=="eight":
code = StabilizerCode(pauli, "XXXXXXXX ZZZZIIII IIIIZZZZ ZIZIZIZI ZZIIZZII")
#code = StabilizerCode(pauli,
# "XXXXXXXX ZZZZIIII IIIIZZZZ ZIZIZIZI ZZIIZZII ZZIIIIII ZIIIZIII ZIZIIIII") # True
#code = StabilizerCode(pauli, "XXXXXXXX ZZZZZZZZ IIZIIZZZ IZZIIZZI ZIIZZZII") # False
elif name=="rm":
code = build_rm(pauli)
elif name=="color":
code = build_color(pauli)
elif name=="toric":
s = """
XX.XX...
X...XX.X
.XXX..X.
ZZZ..Z..
Z.ZZ...Z
.Z..ZZZ.
""".replace(".", "I")
code = StabilizerCode(pauli, s)
elif name=="B11":
s = """
.XXXX......
...XXXX....
.....XXXX..
.......XXXX
X.X.X.X.X.X
.ZZZZ......
...ZZZZ....
.....ZZZZ..
.......ZZZZ
Z.Z.Z.Z.Z.Z
""".replace(".", "I")
code = StabilizerCode(pauli, s)
return code
