def run_trials(size=6, prob=0.1, n_steps = 5000, n_trials = 1000, verbose=True):
successes = failures = 0
if verbose: print("Size: {}, Prob: {}, n_steps: {}, n_trials: {}".format(size,
prob, n_steps, n_trials))
for i in range(n_trials):
s_orig = st.UniformToricState(2 * size, prob)
if verbose: print("Run number: {}".format(i+1))
s_orig.generate_errors()
if verbose: print("Errors: {}".format(s_orig.qubits()))
synd = s_orig.syndrome()
if verbose: print("Syndrome: {}".format(synd))
s = st.UniformToricState.from_syndrome(2 *size, prob, synd)
conj_class = st.UniformToricState.compare(s, s_orig)
if verbose: print("Class: {}".format(conj_class))
# 16 conjugacy classes, reorder so the right one is first
conj_classes = [conj_class ^ i for i in range(16)]
paths = [ch.path(s.copy().change_class(c)) for c in conj_classes]
accum_paths = [ch.average_err(p) for p in paths ]
chunked_paths = [ch.in_jumps_of(1000, p) for p in accum_paths]
ps = ch.path_set(*chunked_paths)
# take two steps, so that the average is found
# over the second half of the chain
for res in ps:
totals = [n for (n, prop, count) in res]
changes = [prop for (n, prop, count) in res]
n = res[0][2]
if verbose: print("n: {}, totals: {}, changes: {}".format(n, totals, changes))
if n >= n_steps:
break
if np.argmin(totals) == 0:
successes +=1
if verbose: print("Result: 1")
else:
failures +=1
if verbose: print("Result: 0")
if verbose: print("\n")
if verbose: print("Size: {}, Prob: {}, n_steps: {}, n_trials: {}".format(size,
prob, n_steps, n_trials))
if verbose: print("Total successes: {}".format(successes))
if verbose: print("Total failures: {}".format(failures))
if verbose: print("Total proportion: {}".format(successes*1.0/(successes + failures)))
return (successes, failures)
def run_trials(size=6, prob=0.1, n_steps=5000, n_trials=1000, verbose=True):
successes = failures = 0
for i in range(n_trials):
s_orig = st.UniformToricState(size, prob)
s_orig.generate_errors()
synd = s_orig.syndrome()
# assume that logical horizontal/vertical errors
# are independent ??, so that the overall threshold
# is just the threshold for correcting one sort
# of error
vert_z = s_orig.VERT_Z
vert_x = s_orig.VERT_X
# forget the original error confic
s = st.UniformToricState.from_syndrome(size, prob, synd)
conj_class = st.UniformToricState.compare(s, s_orig)
# project onto the vertical error classes
vert_class = conj_class & (vert_z + vert_x)
p1 = ch.path(s.copy().change_class(vert_class)) # the right one
p2 = ch.path(s.copy().change_class(vert_z ^ vert_class)) # with
p3 = ch.path(s.copy().change_class(vert_x ^ vert_class)) # with
p4 = ch.path(s.copy().change_class((vert_x + vert_z)
^ vert_class)) # with
paths = [p1, p2, p3, p4]
ps = ch.path_set(
*[ch.in_jumps_of(n_steps / 2, ch.average_err(p)) for p in paths])
# take two steps, so that the average is found
# over the second half of the chain
ps.next()
res = ps.next()
totals = [n for (n, prop, count) in res]
if np.argmin(totals) == 0:
successes += 1
if verbose:
print("success")
else:
failures += 1
if verbose:
print("fail")
return (successes, failures)
def run_trials(size=6, prob=0.1, n_steps = 5000, n_trials = 1000, verbose=True):
successes = failures = 0
for i in range(n_trials):
s_orig = st.UniformToricState(size, prob)
s_orig.generate_errors()
synd = s_orig.syndrome()
# assume that logical horizontal/vertical errors
# are independent ??, so that the overall threshold
# is just the threshold for correcting one sort
# of error
vert_z = s_orig.VERT_Z
vert_x = s_orig.VERT_X
# forget the original error confic
s = st.UniformToricState.from_syndrome(size, prob, synd)
conj_class = st.UniformToricState.compare(s, s_orig)
# project onto the vertical error classes
vert_class = conj_class & (vert_z + vert_x)
p1 = ch.path(s.copy().change_class(vert_class)) # the right one
p2 = ch.path(s.copy().change_class(vert_z ^ vert_class)) # with
p3 = ch.path(s.copy().change_class(vert_x ^ vert_class)) # with
p4 = ch.path(s.copy().change_class((vert_x + vert_z) ^ vert_class)) # with
paths = [p1, p2, p3, p4]
ps = ch.path_set(*[ch.in_jumps_of(n_steps/2, ch.average_err(p)) for p in paths])
# take two steps, so that the average is found
# over the second half of the chain
ps.next()
res = ps.next()
totals = [n for (n, prop, count) in res]
if np.argmin(totals) == 0:
successes +=1
if verbose:
print("success")
else:
failures +=1
if verbose:
print("fail")
return (successes, failures)
def go(prob):
hor_z = st.ToricLattice.HOR_Z
vert_z = st.ToricLattice.VERT_Z
s_orig = st.ZUniformToricState(6, prob)
s_orig.generate_errors()
synd = s_orig.syndrome()
s = st.ZUniformToricState.from_syndrome(6, prob, synd)
sv = s.copy().change_class(vert_z)
sh = s.copy().change_class(hor_z)
shv = s.copy().change_class(hor_z + vert_z)
p = ch.path(s)
pv = ch.path(sv)
ph = ch.path(sh)
phv = ch.path(shv)
paths = [p, pv, ph, phv]
i, v, h, vh = ccs.lookup_hist(cc.to_n(s))
av_i = cc.ConjugacyClasses.hist_row_av_n(i, prob)
av_v = cc.ConjugacyClasses.hist_row_av_n(v, prob)
av_h = cc.ConjugacyClasses.hist_row_av_n(h, prob)
av_vh = cc.ConjugacyClasses.hist_row_av_n(vh, prob)
n_steps = 1000
ps = ch.path_set(*[ch.n_jumps(ch.average_err(p), n_steps) for p in paths])
for a in ps:
avs = [b[0] * 1.0 / b[2] for b in a]
calculated = [av_i, av_v, av_h, av_vh]
print("Average: {:7.2f} {:7.2f} {:7.2f} {:7.2f}".format(*avs))
diff = [avs[i] - calculated[i] for i in range(4)]
print("Comp to theory: {:7.2f} {:7.2f} {:7.2f} {:7.2f}".format(*diff))
def go(prob):
hor_z = st.ToricLattice.HOR_Z
vert_z = st.ToricLattice.VERT_Z
s_orig = st.ZUniformToricState(6, prob)
s_orig.generate_errors()
synd = s_orig.syndrome()
s = st.ZUniformToricState.from_syndrome(6, prob, synd)
sv = s.copy().change_class(vert_z)
sh = s.copy().change_class(hor_z)
shv = s.copy().change_class(hor_z + vert_z)
p = ch.path(s)
pv = ch.path(sv)
ph = ch.path(sh)
phv = ch.path(shv)
paths = [p, pv, ph, phv]
i, v, h, vh = ccs.lookup_hist(cc.to_n(s))
av_i = cc.ConjugacyClasses.hist_row_av_n(i, prob)
av_v = cc.ConjugacyClasses.hist_row_av_n(v, prob)
av_h = cc.ConjugacyClasses.hist_row_av_n(h, prob)
av_vh = cc.ConjugacyClasses.hist_row_av_n(vh, prob)
n_steps = 1000
ps = ch.path_set(*[ch.n_jumps(ch.average_err(p), n_steps) for p in paths])
for a in ps:
avs = [b[0]*1.0/b[2] for b in a]
calculated = [av_i, av_v, av_h, av_vh]
print("Average: {:7.2f} {:7.2f} {:7.2f} {:7.2f}".format(*avs))
diff = [avs[i] - calculated[i] for i in range(4)]
print("Comp to theory: {:7.2f} {:7.2f} {:7.2f} {:7.2f}".format(*diff))
