def entropy_half_chain_split(state, base, N, basis_A_refs, basis_B_refs):
#generate coefficient matrix
N_A = int(np.floor(N / 2))
N_B = int(N - np.floor(N / 2))
basis_A_refs_unique = np.unique(basis_A_refs)
basis_B_refs_unique = np.unique(basis_B_refs)
# M=np.zeros((np.power(base,N_A),np.power(base,N_B)),dtype=complex)
M = np.zeros((np.size(basis_A_refs_unique), np.size(basis_B_refs_unique)),
dtype=complex)
#coefficients of state form matrix M_ij*state^A_i*state^V_j
for n in range(0, np.size(state, axis=0)):
if np.abs(state[n]) > 1e-4:
i, j = int(basis_A_refs[n]), int(basis_B_refs[n])
i_index, j_index = find_index_bisection(
i, basis_A_refs_unique), find_index_bisection(
j, basis_B_refs_unique)
M[i_index, j_index] = M[i_index, j_index] + state[n]
# print("M generated")
#schmidt decomposition
U, S, V = np.linalg.svd(M)
to_del = []
for n in range(0, np.size(S, axis=0)):
if S[n] == 0:
to_del = np.append(to_del, n)
for n in range(np.size(to_del, axis=0) - 1, -1, -1):
S = np.delete(S, to_del[n])
# print("SVD Done")
#von-neuman entropy
entropy = -np.vdot(np.abs(S)**2, np.log(np.abs(S)**2))
return entropy
def energy_basis(state, H):
#find sym blocks state has non zero overlap in
state_ref = bin_to_int_base_m(state, H.system.base)
state_index = find_index_bisection(state_ref, H.system.basis_refs)
sym_ref = H.syms.sym_data[state_index, 0]
k_refs = H.syms.find_k_ref(sym_ref)
#dict to store state in sym sector basis
z_sym = dict()
eigenvalues = dict()
for n in range(0, np.size(k_refs, axis=0)):
psi = ref_state(state_ref, H.system)
z_sym[n] = psi.sym_basis(k_refs[n], H.syms)
eigenvalues[n] = H.sector.eigvalues(k_refs[n])
#dict to store state from sym sector in energy eigenbasis
z_energy = dict()
for n in range(0, np.size(k_refs, axis=0)):
z_energy[n] = np.zeros(np.size(H.sector.eigvalues(k_refs[n])),
dtype=complex)
#find coefficients by taking overlaps
for m in range(0, np.size(z_energy[n], axis=0)):
z_energy[n][m] = np.vdot(
H.sector.eigvectors(k_refs[n])[:, m], z_sym[n])
#combine all sym sectors
z_init = z_energy[0]
eig_f = eigenvalues[0]
for n in range(1, len(z_energy)):
z_init = np.append(z_init, z_energy[n])
eig_f = np.append(eig_f, eigenvalues[n])
return z_init, eig_f
def bulk_eval(state, t, H, use_syms=None):
if use_syms == None:
z_ref = bin_to_int_base_m(state, H.system.base)
z_index = find_index_bisection(z_ref, H.system.basis_refs)
z_init = H.sector.eigvectors()[z_index, :]
eig_f = H.sector.eigvalues()
else:
z_init, eig_f = energy_basis(state, H)
fidelity_y = np.zeros(np.size(t))
for n in range(0, np.size(t, axis=0)):
evolved_state = time_evolve_state(z_init, eig_f, t[n])
fidelity_y[n] = np.abs(np.vdot(evolved_state, z_init))**2
return fidelity_y
def eval(state, t, H, use_syms=None):
if use_syms == None:
z_ref = bin_to_int_base_m(state, H.system.base)
z_index = find_index_bisection(z_ref, H.system.basis_refs)
z_init = H.sector.eigvectors()[z_index, :]
eig_f = H.sector.eigvalues()
else:
z_init, eig_f = energy_basis(state, H)
evolved_state = time_evolve_state(z_init, eig_f, t)
print(np.abs(np.vdot(z_init, evolved_state))**2)
# if t<0.5:
# return -100
# else:
return np.abs(np.vdot(z_init, evolved_state))**2
def fidelity_erorr(coef):
coef = coef[0]
Ip_total = H_operations.add(Ip, Ip_pert, np.array([1, coef]))
Im_total = H_operations.add(Im, Im_pert, np.array([1, coef]))
Kp_total = H_operations.add(Kp, Kp_pert, np.array([1, coef]))
Km_total = H_operations.add(Km, Km_pert, np.array([1, coef]))
Lp_total = H_operations.add(Lp, Lp_pert, np.array([1, coef]))
Lm_total = H_operations.add(Lm, Lm_pert, np.array([1, coef]))
H = H_operations.add(Ip_total, Im_total, np.array([1j, -1j]))
H = H_operations.add(H, Kp_total, np.array([1, -1j]))
H = H_operations.add(H, Km_total, np.array([1, 1j]))
H = H_operations.add(H, Lp_total, np.array([1, 1j]))
H = H_operations.add(H, Lm_total, np.array([1, -1j]))
H.sector.find_eig(k)
z = zm_state(2, 1, pxp, 1)
block_refs = pxp_syms.find_block_refs(k)
psi = np.zeros(np.size(block_refs))
loc = find_index_bisection(z.ref, block_refs)
psi[loc] = 1
psi_energy = np.dot(np.conj(np.transpose(H.sector.eigvectors(k))), psi)
t = np.arange(0, 20, 0.01)
f = np.zeros(np.size(t))
for n in range(0, np.size(t, axis=0)):
evolved_state = time_evolve_state(psi_energy, H.sector.eigvalues(k),
t[n])
f[n] = np.abs(np.vdot(evolved_state, psi_energy))**2
for n in range(0, np.size(f, axis=0)):
if f[n] < 0.1:
cut = n
break
f0 = np.max(f[cut:])
plt.scatter(H.sector.eigvalues(k), np.log10(np.abs(psi_energy)**2))
plt.title(r"$PCP+\lambda(PPCP+PCPP), N=$" + str(pxp.N))
plt.xlabel(r"$E$")
plt.ylabel(r"$\log(\vert \langle \psi \vert E \rangle \vert^2)$")
plt.show()
plt.plot(t, f)
plt.title(r"$PCP+\lambda(PPCP+PCPP), N=$" + str(pxp.N))
plt.xlabel(r"$t$")
plt.ylabel(r"$\vert \langle \psi(0) \vert \psi(t) \rangle \vert^2$")
plt.show()
return 1 - f0
def bulk_eval(state, H, k_vec=None):
if k_vec is None: #no symmetry, use full basis
z_ref = bin_to_int_base_m(state, H.system.base)
z_index = find_index_bisection(z_ref, H.system.basis_refs)
z_energy = H.sector.eigvectors()[z_index, :]
eigenvalues = H.sector.eigvalues()
else: #symmetry used, just plot the given sym_block
z_ref = bin_to_int_base_m(state, H.system.base)
psi = ref_state(z_ref, H.system)
z_mom = psi.sym_basis(k_vec, H.syms)
# z_mom = z_mom * np.power(np.vdot(z_mom,z_mom),-0.5)
z_energy = np.zeros(np.size(H.sector.eigvalues(k_vec)),
dtype=complex)
for n in range(0, np.size(z_energy, axis=0)):
z_energy[n] = np.vdot(z_mom, H.sector.eigvectors(k_vec)[:, n])
eigenvalues = H.sector.eigvalues(k_vec)
overlap = np.log10(np.abs(z_energy)**2)
return overlap
def plot(state, t, H, use_syms=None):
print("Plotting Fidelity...")
if use_syms == None:
z_ref = bin_to_int_base_m(state, H.system.base)
z_index = find_index_bisection(z_ref, H.system.basis_refs)
z_init = H.sector.eigvectors()[z_index, :]
eig_f = H.sector.eigvalues()
else:
z_init, eig_f = energy_basis(state, H)
fidelity_y = np.zeros(np.size(t))
for n in range(0, np.size(t, axis=0)):
evolved_state = time_evolve_state(z_init, eig_f, t[n])
fidelity_y[n] = np.abs(np.vdot(evolved_state, z_init))**2
plt.xlabel("t")
plt.ylabel(r"$\vert \langle \psi(t) \vert \psi(0) \rangle \vert^2$")
plt.title(str(H.system.base) + " Colour, N=" + str(H.system.N))
plt.plot(t, fidelity_y)
def sym_basis(self,k_vec,sym_data):
#permutations of all array indices for d dimensional arrayk, d=no syms
#for looping through d-dim array
orbit_indices = list(nd_range(0,self.system.N,np.size(sym_data.syms)))
#lowest symmetry equiv state, the reference
# index = self.system.keys[self.ref]
sym_ref = sym_data.sym_data[self.system.keys[self.ref],0]
L = sym_data.sym_data[self.system.keys[self.ref],2:]
allowed_mom = np.zeros(np.size(k_vec))
periods = np.zeros(np.size(sym_data.syms))
for k in range(0,np.size(sym_data.syms,axis=0)):
temp_orbit = sym_data.syms[k].create_orbit(sym_ref)
periods[k] = np.size(temp_orbit)
psi = sym_state(self.ref,k_vec,sym_data,self.system)
temp = psi.prod_basis()
orbit_size = 0
orbit_ref_indices = []
for n in range(0,np.size(temp,axis=0)):
if np.abs(temp[n]) > 1e-5:
orbit_size = orbit_size + 1
orbit_ref_indices = np.append(orbit_ref_indices,n)
U = np.zeros(orbit_size,dtype=complex)
k_refs = sym_data.find_k_ref(sym_ref)
#loop through all sym sectors and keep |a_ref,k1,...kn>=c_n|n> to form U
c,d = 0,0
for m in range(0,np.size(k_refs,axis=0)):
psi = sym_state(self.ref,k_refs[m],sym_data,self.system)
temp = psi.prod_basis()
U_temp = np.zeros(orbit_size,dtype=complex)
for k in range(0,np.size(orbit_ref_indices,axis=0)):
U_temp[k] = temp[int(orbit_ref_indices[k])]
U = np.vstack((U,U_temp))
not_found = 1
for n in range(0,np.size(k_refs,axis=0)):
if (k_refs[n] == k_vec).all() == True:
j_index = n
not_found = 0
break
if not_found == 1:
print("Error: State not in this symmetry sector")
else:
U = np.delete(U,0,axis=0)
#find column index of relevant state
for n in range(0,np.size(orbit_ref_indices,axis=0)):
if orbit_ref_indices[n] == self.key:
i_index = n
#delete equivalent rows
eq_ind=np.arange(0,np.size(k_refs,axis=0)) #track what quant sectors are equiv
for n in range(0,np.size(U,axis=0)):
to_del = []
for m in range(n+1,np.size(U,axis=0)):
if (np.abs(U[m]-U[n])<1e-5).all() == True:
to_del = np.append(to_del,m)
eq_ind[m] = n
elif (np.abs(1j * U[m]-U[n])<1e-5).all() == True:
to_del = np.append(to_del,m)
eq_ind[m] = n
elif (np.abs(-1j * U[m]-U[n])<1e-5).all() == True:
to_del = np.append(to_del,m)
eq_ind[m] = n
elif (np.abs(-1 * U[m]-U[n])<1e-5).all() == True:
to_del = np.append(to_del,m)
eq_ind[m] = n
for m in range(np.size(to_del,axis=0)-1,-1,-1):
U = np.delete(U,to_del[m],axis=0)
#update j_index, deleted eq rows
j_index = eq_ind[j_index]
found=[]
keys=dict()
c = 0
for n in range(0,np.size(eq_ind,axis=0)):
if eq_ind[n] not in found:
keys[eq_ind[n]]=c
c = c+1
found = np.append(found,eq_ind[n])
j_index = keys[j_index]
#inv transformation
U_inv = np.linalg.inv(U)
coef = U_inv[i_index,j_index]
block_references = sym_data.find_block_refs(k_vec)
prod_state = np.zeros(np.size(block_references),dtype=complex)
# ref_index = self.system.keys[sym_ref]
ref_index = find_index_bisection(sym_ref,block_references)
prod_state[ref_index] = coef
return prod_state
def prod_basis(self):
v = np.zeros(np.size(self.system.basis_refs))
index = find_index_bisection(self.ref,self.system.basis_refs)
v[index] = 1
return v
def plot(state, H, k_vec=None, label=None):
print("Plotting eigenstate overlap with given state...")
if k_vec is None: #no symmetry, use full basis
z_ref = bin_to_int_base_m(state, H.system.base)
z_index = find_index_bisection(z_ref, H.system.basis_refs)
z_energy = H.sector.eigvectors()[z_index, :]
eigenvalues = H.sector.eigvalues()
else: #symmetry used, just plot the given sym_block
z_ref = bin_to_int_base_m(state, H.system.base)
psi = ref_state(z_ref, H.system)
z_mom = psi.sym_basis(k_vec, H.syms)
# z_mom = z_mom * np.power(np.vdot(z_mom,z_mom),-0.5)
z_energy = np.zeros(np.size(H.sector.eigvalues(k_vec)),
dtype=complex)
for n in range(0, np.size(z_energy, axis=0)):
z_energy[n] = np.vdot(z_mom, H.sector.eigvectors(k_vec)[:, n])
eigenvalues = H.sector.eigvalues(k_vec)
overlap = np.log10(np.abs(z_energy)**2)
to_del = []
for n in range(0, np.size(overlap, axis=0)):
if overlap[n] < -10:
to_del = np.append(to_del, n)
for n in range(np.size(to_del, axis=0) - 1, -1, -1):
overlap = np.delete(overlap, to_del[n])
eigenvalues = np.delete(eigenvalues, to_del[n])
if label is not None:
fig = plt.figure()
ax = fig.add_subplot(111)
if k_vec is None:
# plt.scatter(eigenvalues,overlap,alpha=0.6)
from scipy.stats import gaussian_kde
x = eigenvalues
y = overlap
plt.scatter(x, y)
# Calculate the point density
# xy = np.vstack([x,y])
# z = gaussian_kde(xy)(xy)
# # Sort the points by density, so that the densest points are plotted last
# idx = z.argsort()
# x, y, z = x[idx], y[idx], z[idx]
# fig, ax = plt.subplots()
# ax.scatter(x, y, c=z, s=50, edgecolor='')
else:
# plt.scatter(eigenvalues,overlap,label=str(k_vec)+r" $\pi /$"+str(H.system.N)+" Symmetry sector")
plt.scatter(eigenvalues, overlap, color='blue')
if label is not None:
A = eigenvalues
B = overlap
for i, j in zip(A, B):
# ax.annotate('%s)' %j, xy=(i,j), xytext=(30,0), textcoords='offset points')
ax.annotate('(%s,' % i, xy=(i, j))
plt.legend()
plt.xlabel("E")
plt.ylabel(r"$\vert \langle \psi_E \vert \psi \rangle \vert^2$")
plt.title(str(H.system.base) + " Colour, N=" + str(H.system.N))
plt.legend()
for n in range(0,np.size(basis_refs,axis=0)):
perm_basis = np.vstack((perm_basis,perm_basis_states[basis_refs[n]]))
perm_basis = np.transpose(np.delete(perm_basis,0,axis=0))
perm_dim = np.size(perm_basis,axis=1)
H = spin_Hamiltonian(pxp,"x",pxp_syms)
H.gen()
H.sector.find_eig()
H_perm = np.dot(np.conj(np.transpose(perm_basis)),np.dot(H.sector.matrix(),perm_basis))
e,u = np.linalg.eigh(H_perm)
#time evolve state in perm basis,
z_ref = perm_keys(int(N/2),0,N)
z_index = find_index_bisection(z_ref,basis_refs)
psi_energy = np.conj(u[z_index,:])
t=np.arange(0,10,0.1)
evolved_states = np.zeros((pxp.dim,np.size(t)),dtype=complex)
for n in range(0,np.size(t,axis=0)):
evolved_state_perm_energy = time_evolve_state(psi_energy,e,t[n])
evolved_state_perm = np.dot(u,evolved_state_perm_energy)
evolved_state_prod = np.dot(perm_basis,evolved_state_perm)
evolved_states[:,n] = evolved_state_prod
#minimize distance of evolved states with tensor tree ansatz
def TT_wf(theta1,phi1,theta2,phi2):
c1_up = 1j * np.exp(-1j * phi1)*np.tan(theta2)
c1_down = np.cos(theta1)
def comP(A, B, relation_object):
#array with unit cell of A/B indices (eg 2n+1,2n+2,2n+3->1,2,3)
A_loc = np.arange(A.loc, A.loc + A.length)
B_loc = np.arange(B.loc, B.loc + B.length)
#find n_vals=[...] such that end of B string touch A string
#RHS indices = B.period*n+B.loc
max_found = 0
counter = 0
while max_found == 0:
#B.period*n+B.loc = (last A site) - counter
n_max = (A_loc[np.size(A_loc) - 1] - B.loc - counter) / B.period
if n_max.is_integer() == True:
max_found = 1
break
else:
counter += 1
min_found = 0
counter = 0
while min_found == 0:
#B.period*n+(last B site) = (first A site) + counter
n_min = (A.loc - B_loc[np.size(B_loc) - 1] + counter) / B.period
if n_min.is_integer() == True:
min_found = 1
break
else:
counter += 1
n_vals = np.arange(n_min, n_max + 1)
#find all overlapping RH terms, store loc in 2d array
rhs_loc = np.zeros((np.size(n_vals), B.length))
for n in range(0, np.size(n_vals, axis=0)):
rhs_loc[n] = np.arange(B.period * n_vals[n] + B.loc,
B.period * n_vals[n] + B.loc + B.length)
#for each rhs loc form "sandwich" of overlapping sites,store each term in nested dictionary
#eg strings like "P(+P)(-P)P = P+-P"
rhs_commutes = dict()
new_coef = np.zeros(np.size(n_vals))
for n in range(0, np.size(rhs_loc, axis=0)):
min_loc = int(np.min(np.append(A_loc, rhs_loc[n])))
max_loc = int(np.max(np.append(A_loc, rhs_loc[n])))
rhs_commutes[n] = dict()
for m in range(min_loc, max_loc + 1):
temp = ''
if m in rhs_loc[n] and m in A_loc:
A_loc_index = find_index_bisection(m, A_loc)
rhs_index = find_index_bisection(m, rhs_loc[n])
temp += A.string[A_loc_index]
temp += B.string[rhs_index]
rhs_commutes[n][m] = temp
elif m in rhs_loc[n]:
rhs_index = find_index_bisection(m, rhs_loc[n])
temp = B.string[rhs_index]
rhs_commutes[n][m] = temp
else:
A_loc_index = find_index_bisection(m, A_loc)
temp = A.string[A_loc_index]
rhs_commutes[n][m] = temp
new_coef[n] = A.coef * B.coef
#replace known products from relation class
simplified_commutes = commuted_string_seq()
for n in range(0, np.size(rhs_loc, axis=0)):
#identify all pairs of producted operators
keys = list(rhs_commutes[n])
paired_keys = []
for m in range(0, np.size(keys, axis=0)):
if len(rhs_commutes[n][keys[m]]) > 1:
paired_keys = np.append(paired_keys, keys[m])
#replace any PP pairs with P
for m in range(0, np.size(paired_keys, axis=0)):
if rhs_commutes[n][paired_keys[m]] == "PP":
rhs_commutes[n][paired_keys[m]] = "P"
#replace any QQ pairs with Q
for m in range(0, np.size(paired_keys, axis=0)):
if rhs_commutes[n][paired_keys[m]] == "QQ":
rhs_commutes[n][paired_keys[m]] = "Q"
#identify remaining pairs
paired_keys = []
for m in range(0, np.size(keys, axis=0)):
if len(rhs_commutes[n][keys[m]]) > 1:
paired_keys = np.append(paired_keys, keys[m])
#if no. paired keys == 1 can do regular commutator
if np.size(paired_keys) == 1:
#desired syntax
# simplified_commutators= relations.commutator(rhs_commutes[n][paired_keys[0]])
simplified_commutators = relation_object.commutator(
rhs_commutes[n][paired_keys[0]])
for u in range(0, simplified_commutators.length):
temp_string_dict = deepcopy(rhs_commutes[n])
temp_string_dict[
paired_keys[0]] = simplified_commutators.entry[u].string
temp_coef = new_coef[n] * simplified_commutators.entry[u].coef
simplified_commutes.update(temp_string_dict, temp_coef)
else:
AB_coef_orig = np.copy(new_coef[n])
BA_coef_orig = np.copy(new_coef[n])
simplified_products_AB = dict()
simplified_products_BA = dict()
for m in range(0, np.size(paired_keys, axis=0)):
simplified_products_AB[m] = relation_object.product(
rhs_commutes[n][paired_keys[m]])
simplified_products_BA[m] = relation_object.product(
rhs_commutes[n][paired_keys[m]][::-1])
index_array_AB = []
for m in range(0, len(simplified_products_AB)):
temp = list(simplified_products_AB[m].entry.keys())
index_array_AB.append(temp)
from itertools import product
indices_AB = np.array(list(product(*index_array_AB)))
index_array_BA = []
for m in range(0, len(simplified_products_BA)):
temp = list(simplified_products_BA[m].entry.keys())
index_array_BA.append(temp)
from itertools import product
indices_BA = np.array(list(product(*index_array_BA)))
if np.size(indices_AB) > 0:
for u in range(0, np.size(indices_AB, axis=0)):
temp_string_dict = deepcopy(rhs_commutes[n])
paired_key_index = 0
temp_coef = AB_coef_orig
for v in range(0, np.size(indices_AB[u], axis=0)):
temp_string_dict[paired_keys[
paired_key_index]] = simplified_products_AB[
v].entry[indices_AB[u][v]].string
temp_coef = temp_coef * simplified_products_AB[
v].entry[indices_AB[u][v]].coef
paired_key_index += 1
simplified_commutes.update(temp_string_dict, temp_coef)
if np.size(indices_BA) > 0:
for u in range(0, np.size(indices_BA, axis=0)):
temp_string_dict = deepcopy(rhs_commutes[n])
paired_key_index = 0
temp_coef = BA_coef_orig
for v in range(0, np.size(indices_BA[u], axis=0)):
temp_string_dict[paired_keys[
paired_key_index]] = simplified_products_BA[
v].entry[indices_BA[u][v]].string
temp_coef = temp_coef * simplified_products_BA[
v].entry[indices_BA[u][v]].coef
paired_key_index += 1
simplified_commutes.update(temp_string_dict, -temp_coef)
rhs_strings = dict()
new_loc = []
new_coef_trimmed = []
c = 0
for n in range(0, simplified_commutes.no_terms):
if np.abs(simplified_commutes.terms[n].coef) > 1e-5:
rhs_strings[c] = simplified_commutes.terms[n].string
new_loc = np.append(new_loc, simplified_commutes.terms[n].loc)
new_coef_trimmed = np.append(new_coef_trimmed,
simplified_commutes.terms[n].coef)
c += 1
#keep non zero terms
keys = list(rhs_strings.keys())
non_zero_strings = dict()
non_zero_coef = dict()
non_zero_loc = []
c = 0
string_seq = dict()
for n in range(0, np.size(keys, axis=0)):
if np.abs(new_coef_trimmed[keys[n]]) > 1e-5:
string_seq[c] = op_string(new_coef_trimmed[keys[n]],
rhs_strings[keys[n]], A.period,
new_loc[n] % A.period)
c += 1
#multiply out variables and orders (all terms will have same variables)
new_variables, new_orders = A.multiply_variables(B)
for n in range(0, len(string_seq)):
string_seq[n].variables = new_variables
string_seq[n].variable_orders = new_orders
string_seq[n].update_hash()
return op_string_seq(string_seq)
def fidelity_erorr(coef,plot=False):
c=0
Ip_total = deepcopy(Ip[0])
for n in range(1,len(Ip)):
Ip_total = H_operations.add(Ip_total,Ip[n],np.array([1,coef[c+n-1]]))
Im_total = deepcopy(Im[0])
for n in range(1,len(Im)):
Im_total = H_operations.add(Im_total,Im[n],np.array([1,coef[c+n-1]]))
c += len(Ip)-1
Kp_total = deepcopy(Kp[0])
for n in range(1,len(Kp)):
Kp_total = H_operations.add(Kp_total,Kp[n],np.array([1,coef[c+n-1]]))
Km_total = deepcopy(Km[0])
for n in range(1,len(Km)):
Km_total = H_operations.add(Km_total,Km[n],np.array([1,coef[c+n-1]]))
c += len(Kp)-1
Lp_total = deepcopy(Lp[0])
for n in range(1,len(Lp)):
Lp_total = H_operations.add(Lp_total,Lp[n],np.array([1,coef[c+n-1]]))
Lm_total = deepcopy(Lm[0])
for n in range(1,len(Lm)):
Lm_total = H_operations.add(Lm_total,Lm[n],np.array([1,coef[c+n-1]]))
H=H_operations.add(Ip_total,Im_total,np.array([1j,-1j]))
H=H_operations.add(H,Kp_total,np.array([1,-1j]))
H=H_operations.add(H,Km_total,np.array([1,1j]))
H=H_operations.add(H,Lp_total,np.array([1,1j]))
H=H_operations.add(H,Lm_total,np.array([1,-1j]))
H.sector.find_eig(k)
z=zm_state(2,1,pxp,1)
block_refs = pxp_syms.find_block_refs(k)
psi = np.zeros(np.size(block_refs))
loc = find_index_bisection(z.ref,block_refs)
psi[loc] = 1
psi_energy = np.dot(np.conj(np.transpose(H.sector.eigvectors(k))),psi)
t=np.arange(0,20,0.01)
f=np.zeros(np.size(t))
for n in range(0,np.size(t,axis=0)):
evolved_state = time_evolve_state(psi_energy,H.sector.eigvalues(k),t[n])
f[n] = np.abs(np.vdot(evolved_state,psi_energy))**2
for n in range(0,np.size(f,axis=0)):
if f[n] < 0.1:
cut = n
break
f0 = np.max(f[cut:])
if plot is True:
plt.scatter(H.sector.eigvalues(k),np.log10(np.abs(psi_energy)**2))
plt.title(r"$PCP+\lambda(PPCP+PCPP), N=$"+str(pxp.N))
plt.xlabel(r"$E$")
plt.ylabel(r"$\log(\vert \langle \psi \vert E \rangle \vert^2)$")
plt.show()
plt.plot(t,f)
plt.title(r"$PCP+\lambda(PPCP+PCPP), N=$"+str(pxp.N))
plt.xlabel(r"$t$")
plt.ylabel(r"$\vert \langle \psi(0) \vert \psi(t) \rangle \vert^2$")
plt.show()
print(coef,f0)
return 1-f0
Hp[2].site_ops[1] = np.array([[0, 0], [1, 0]])
Hp[2].site_ops[2] = np.array([[0, 1], [0, 0]])
Hp[2].site_ops[3] = np.array([[-1, 0], [0, 1]])
Hp[2].site_ops[4] = np.array([[0, 0], [0, 1]])
Hp[2].model = np.array([[1, 3, 3, 2], [2, 3, 3, 1]])
Hp[2].model_coef = np.array([1, 1])
Hp[2].uc_size = np.array([2, 2])
Hp[2].uc_pos = np.array([0, 1])
z = zm_state(2, 1, pxp)
z2 = zm_state(2, 1, pxp, 1)
k = [0, 0]
block_refs = pxp_syms.find_block_refs(k)
if z.ref in block_refs:
neel_loc = find_index_bisection(z.ref, block_refs)
else:
neel_loc = find_index_bisection(z2.ref, block_refs)
for n in range(0, len(Hp)):
Hp[n].gen(k)
psi_mom = np.zeros(np.size(block_refs))
psi_mom[neel_loc] = 1
def fidelity_eval(psi_energy, e, t):
evolved_state = time_evolve_state(psi_energy, e, t)
f = np.abs(np.vdot(evolved_state, psi_energy))**2
return f
