def test_basis(get_test_dimensions) -> None:
"""Testing orthonormality of basis vectors."""
for dim in get_test_dimensions:
pairs = [(i, j) for i in range(dim) for j in range(dim)]
for (i, j) in pairs:
vi = basis(dim, i)
vj = basis(dim, j)
almost_equal(vi.T @ vj, 1 if i == j else 0)
def lindbladian_population(U_dict: dict, lvl: int, gate: str):
U = U_dict[gate]
lvls = int(np.sqrt(U.shape[0]))
psi_0 = tf.constant(basis(lvls, 0), dtype=tf.complex128)
dv_0 = tf_dm_to_vec(tf_state_to_dm(psi_0))
dv_actual = tf.matmul(U, dv_0)
return populations(dv_actual, lindbladian=True)[lvl]
def initialise(self, drift_H, lindbladian=False, init_temp=None):
"""
Prepare the initial state of the system. At the moment finite temperature requires open system dynamics.
Parameters
----------
drift_H : tf.Tensor
Drift Hamiltonian.
lindbladian : boolean
Whether to include open system dynamics. Required for Temperature > 0.
init_temp : Quantity
Temperature of the device.
Returns
-------
tf.Tensor
State or density vector
"""
if init_temp is None:
init_temp = tf.cast(self.params["init_temp"].get_value(),
dtype=tf.complex128)
diag = tf.linalg.diag_part(drift_H)
dim = len(diag)
if abs(init_temp) > np.finfo(
float).eps: # this checks that it's not zero
# TODO Deal with dressed basis for thermal state
freq_diff = diag - diag[0]
beta = 1 / (init_temp * constants.kb)
det_bal = tf.exp(-constants.hbar * freq_diff * beta)
norm_bal = det_bal / tf.reduce_sum(det_bal)
dm = tf.linalg.diag(norm_bal)
if lindbladian:
return tf_utils.tf_dm_to_vec(dm)
else:
raise Warning(
"C3:WARNING: We still need to do Von Neumann right.")
else:
state = tf.constant(qt_utils.basis(dim, 0),
shape=[dim, 1],
dtype=tf.complex128)
if lindbladian:
return tf_utils.tf_dm_to_vec(tf_utils.tf_state_to_dm(state))
else:
return state
def orbit_infid(
U_dict,
RB_number: int = 30,
RB_length: int = 20,
lindbladian=False,
shots: int = None,
seqs=None,
noise=None
):
if not seqs:
seqs = single_length_RB(RB_number=RB_number, RB_length=RB_length)
Us = evaluate_sequences(U_dict, seqs)
infids = []
for U in Us:
dim = int(U.shape[0])
psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
psi_actual = tf.matmul(U, psi_init)
pop0 = tf_abs(psi_actual[0])**2
p1 = 1 - pop0
if shots:
vals = tf.keras.backend.random_binomial(
[shots],
p=p1,
dtype=tf.float64,
)
# if noise:
# vals = vals + (np.random.randn(shots) * noise)
infid = tf.reduce_mean(vals)
else:
infid = p1
# if noise:
# infid = infid + (np.random.randn() * noise)
if noise:
infid = infid + (np.random.randn() * noise)
infids.append(infid)
return tf_ave(infids)
def leakage_RB(
U_dict,
min_length: int = 5,
max_length: int = 500,
num_lengths: int = 20,
num_seqs: int = 30,
logspace=False,
lindbladian=False
):
# print('Performing leakage RB fit experiment.')
gate = list(U_dict.keys())[0]
U = U_dict[gate]
dim = int(U.shape[0])
psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
if logspace:
lengths = np.rint(
np.logspace(
np.log10(min_length),
np.log10(max_length),
num=num_lengths
)
).astype(int)
else:
lengths = np.rint(
np.linspace(
min_length,
max_length,
num=num_lengths
)
).astype(int)
comp_surv = []
surv_prob = []
for L in lengths:
seqs = single_length_RB(num_seqs, L)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
pop_comps = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]))
pop_comps.append(float(pops[0])+float(pops[1]))
surv_prob.append(pop0s)
comp_surv.append(pop_comps)
def RB_leakage(len, r_leak, A_leak, B_leak):
return A_leak + B_leak * r_leak**(len)
bounds = (0, 1)
init_guess = [0.9, 0.5, 0.5]
fitted = False
while not fitted:
try:
comp_means = np.mean(comp_surv, axis=1)
comp_stds = np.std(comp_surv, axis=1) / np.sqrt(len(comp_surv[0]))
solution, cov = curve_fit(RB_leakage,
lengths,
comp_means,
sigma=comp_stds,
bounds=bounds,
p0=init_guess)
r_leak, A_leak, B_leak = solution
fitted = True
except Exception as message:
print(message)
if logspace:
new_lengths = np.rint(
np.logspace(
np.log10(max_length + min_length),
np.log10(max_length * 2),
num=num_lengths
)
).astype(int)
else:
new_lengths = np.rint(
np.linspace(
max_length + min_length,
max_length*2,
num=num_lengths
)
).astype(int)
max_length = max_length * 2
for L in new_lengths:
seqs = single_length_RB(num_seqs, L)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
pop_comps = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]))
pop_comps.append(float(pops[0]))
surv_prob.append(pop0s)
comp_surv.append(pop_comps)
lengths = np.append(lengths, new_lengths)
def RB_surv(len, r, A, C):
return A + B_leak * r_leak**(len) + C * r**(len)
bounds = (0, 1)
init_guess = [0.9, 0.5, 0.5]
fitted = False
while not fitted:
try:
surv_means = np.mean(surv_prob, axis=1)
surv_stds = np.std(surv_prob, axis=1) / np.sqrt(len(surv_prob[0]))
solution, cov = curve_fit(RB_surv,
lengths,
surv_means,
sigma=surv_stds,
bounds=bounds,
p0=init_guess)
r, A, C = solution
fitted = True
except Exception as message:
print(message)
if logspace:
new_lengths = np.rint(
np.logspace(
np.log10(max_length + min_length),
np.log10(max_length * 2),
num=num_lengths
)
).astype(int)
else:
new_lengths = np.rint(
np.linspace(
max_length + min_length,
max_length*2,
num=num_lengths
)
).astype(int)
max_length = max_length * 2
for L in new_lengths:
seqs = single_length_RB(num_seqs, L)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
pop_comps = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]))
pop_comps.append(float(pops[0]))
surv_prob.append(pop0s)
comp_surv.append(pop_comps)
lengths = np.append(lengths, new_lengths)
leakage = (1-A_leak)*(1-r_leak)
seepage = A_leak*(1-r_leak)
fid = 0.5*(r+1-leakage)
epc = 1 - fid
return epc, leakage, seepage, r_leak, A_leak, B_leak, r, A, C
def RB(
U_dict,
min_length: int = 5,
max_length: int = 500,
num_lengths: int = 20,
num_seqs: int = 30,
logspace=False,
lindbladian=False,
padding=""
):
# print('Performing RB fit experiment.')
gate = list(U_dict.keys())[0]
U = U_dict[gate]
dim = int(U.shape[0])
psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
if logspace:
lengths = np.rint(
np.logspace(
np.log10(min_length),
np.log10(max_length),
num=num_lengths
)
).astype(int)
else:
lengths = np.rint(
np.linspace(
min_length,
max_length,
num=num_lengths
)
).astype(int)
surv_prob = []
for L in lengths:
seqs = single_length_RB(num_seqs, L, padding)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]+pops[1]))
surv_prob.append(pop0s)
def RB_fit(len, r, A, B):
return A * r**(len) + B
bounds = (0, 1)
init_guess = [0.9, 0.5, 0.5]
fitted = False
while not fitted:
try:
means = np.mean(surv_prob, axis=1)
stds = np.std(surv_prob, axis=1) / np.sqrt(len(surv_prob[0]))
solution, cov = curve_fit(RB_fit,
lengths,
means,
sigma=stds,
bounds=bounds,
p0=init_guess)
r, A, B = solution
fitted = True
except Exception as message:
print(message)
if logspace:
new_lengths = np.rint(
np.logspace(
np.log10(max_length + min_length),
np.log10(max_length * 2),
num=num_lengths
)
).astype(int)
else:
new_lengths = np.rint(
np.linspace(
max_length + min_length,
max_length*2,
num=num_lengths
)
).astype(int)
max_length = max_length * 2
for L in new_lengths:
seqs = single_length_RB(num_seqs, L, padding)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]+pops[1]))
surv_prob.append(pop0s)
lengths = np.append(lengths, new_lengths)
epc = 0.5 * (1 - r)
print("epc:", epc)
epg = 1 - ((1-epc)**(1/4))
print("epg:", epg)
# print('example seq: ', seqs[0])
fig, ax = plt.subplots()
ax.plot(lengths,
surv_prob,
marker='o',
color='red',
linestyle='None')
ax.errorbar(lengths,
means,
yerr=stds,
color='blue',
marker='x',
linestyle='None')
plt.title('RB results')
plt.ylabel('Population in 0')
plt.xlabel('\# Cliffords')
plt.ylim(0, 1)
plt.xlim(0, lengths[-1])
fitted = RB_fit(lengths, r, A, B)
ax.plot(lengths, fitted)
plt.text(0.1, 0.1,
'r={:.4f}, A={:.3f}, B={:.3f}'.format(r, A, B),
size=16,
transform=ax.transAxes)
plt.show()
# return epc, r, A, B, fig, ax
return epg
def population(U_dict: dict, lvl: int, gate: str):
U = U_dict[gate]
lvls = U.shape[0]
psi_0 = tf.constant(basis(lvls, 0), dtype=tf.complex128)
psi_actual = tf.matmul(U, psi_0)
return populations(psi_actual, lindbladian=False)[lvl]
def RB(
U_dict,
min_length: int = 5,
max_length: int = 500,
num_lengths: int = 20,
num_seqs: int = 30,
logspace=False,
lindbladian=False,
padding="",
):
gate = list(U_dict.keys())[0]
U = U_dict[gate]
dim = int(U.shape[0])
psi_init = tf.constant(basis(dim, 0), dtype=tf.complex128)
if logspace:
lengths = np.rint(
np.logspace(np.log10(min_length),
np.log10(max_length),
num=num_lengths)).astype(int)
else:
lengths = np.rint(np.linspace(min_length, max_length,
num=num_lengths)).astype(int)
surv_prob = []
for L in lengths:
seqs = single_length_RB(num_seqs, L, padding)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]))
surv_prob.append(pop0s)
def RB_fit(len, r, A, B):
return A * r**(len) + B
bounds = (0, 1)
init_guess = [0.9, 0.5, 0.5]
fitted = False
while not fitted:
try:
means = np.mean(surv_prob, axis=1)
stds = np.std(surv_prob, axis=1) / np.sqrt(len(surv_prob[0]))
solution, cov = curve_fit(RB_fit,
lengths,
means,
sigma=stds,
bounds=bounds,
p0=init_guess)
r, A, B = solution
fitted = True
except Exception as message:
print(message)
if logspace:
new_lengths = np.rint(
np.logspace(
np.log10(max_length + min_length),
np.log10(max_length * 2),
num=num_lengths,
)).astype(int)
else:
new_lengths = np.rint(
np.linspace(max_length + min_length,
max_length * 2,
num=num_lengths)).astype(int)
max_length = max_length * 2
for L in new_lengths:
seqs = single_length_RB(num_seqs, L, padding)
Us = evaluate_sequences(U_dict, seqs)
pop0s = []
for U in Us:
pops = populations(tf.matmul(U, psi_init), lindbladian)
pop0s.append(float(pops[0]))
surv_prob.append(pop0s)
lengths = np.append(lengths, new_lengths)
epc = 0.5 * (1 - r)
epg = 1 - ((1 - epc)**(1 / 4)) # TODO: adjust to be mean length of
return epg
