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 subcube_basis(root_refs, LR, cube_dim): distinct_subcube_basis = dict() for n in range(0, np.size(root_refs, axis=0)): distinct_subcube_basis[n] = ref_state(root_refs[n], pxp).prod_basis() current_state = distinct_subcube_basis[n] Hm, Hp = fsa_ops_from_root(root_refs[n], LR) for m in range(0, cube_dim): next_state = np.dot(Hp, current_state) if (np.abs(next_state) < 1e-5).all() == False: next_state = next_state / np.power( np.vdot(next_state, next_state), 0.5) distinct_subcube_basis[n] = np.vstack( (distinct_subcube_basis[n], next_state)) current_state = next_state distinct_subcube_basis[n] = np.transpose(distinct_subcube_basis[n]) #now combine subcube basis subcube_basis = distinct_subcube_basis[0] for n in range(1, len(distinct_subcube_basis)): subcube_basis = subcube_basis + distinct_subcube_basis[n] #delete any zeros to_del = [] for n in range(0, np.size(subcube_basis, axis=1)): if (np.abs(subcube_basis[:, n]) < 1e-5).all(): to_del = np.append(to_del, n) for n in range(np.size(to_del, axis=0) - 1, -1, -1): subcube_basis = np.delete(subcube_basis, to_del[n], axis=1) for n in range(0, np.size(subcube_basis, axis=1)): subcube_basis[:, n] = subcube_basis[:, n] / np.power( np.vdot(subcube_basis[:, n], subcube_basis[:, n]), 0.5) return subcube_basis
def column_rate(column_index): N_column = np.size(hamming_sectors[column_index]) rate_sum = 0 for ref1 in hamming_sectors[column_index]: for ref2 in hamming_sectors[column_index]: temp = np.dot(V.sector.matrix(), ref_state(ref1, pxp).prod_basis()) int_term1 = np.abs(np.sum(temp)) if ref1 == ref2: rate_sum = rate_sum + (N_column - 1) * int_term1**2 else: # print("HOHo") temp = np.dot(V.sector.matrix(), ref_state(ref2, pxp).prod_basis()) int_term2 = np.abs(np.sum(temp)) rate_sum = rate_sum - int_term1 * int_term2 rate_sum = -2 * rate_sum / N_column**2 return rate_sum
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 subcube_basis_from_sector(sector): root_basis = dict() refs = sector_refs[perm_key(sector, pxp)] for n in range(0, np.size(refs, axis=0)): root_basis[n] = np.zeros(pxp.dim) Hm = Hm_from_ref(refs[n]) Hm = np.conj(np.transpose(Hm)) current_state = ref_state(refs[n], pxp).prod_basis() while (np.abs(current_state) < 1e-5).all() == False: root_basis[n] = np.vstack((root_basis[n], current_state)) current_state = np.dot(Hm, current_state) root_basis[n] = np.transpose(np.delete(root_basis[n], 0, axis=0)) #form superposition from all roots basis = root_basis[0] for n in range(1, len(root_basis)): basis = basis + root_basis[n] #normalize for n in range(0, np.size(basis, axis=1)): basis[:, n] = basis[:, n] / np.power(np.vdot(basis[:, n], basis[:, n]), 0.5) return basis
rc('text', usetex=True) # matplotlib.rcParams['figure.dpi'] = 400 N = 10 J = 1 hx = 1 hz = 1 #init system system = unlocking_System([0, 1], "periodic", 2, N) system.gen_basis() system_syms = model_sym_data(system, [translational(system)]) #create Hamiltonian H = Hamiltonian(system, system_syms) H.site_ops[1] = np.array([[0, 1], [1, 0]]) H.site_ops[2] = np.array([[-1, 0], [0, 1]]) H.model = np.array([[1, 1], [2], [1]]) H.model_coef = np.array([J, hz, hx]) #dynamics following quench from |00000> psi = ref_state(0, system) k = system_syms.find_k_ref(psi.ref) for n in range(0, np.size(k, axis=0)): H.gen(k[n]) H.sector.find_eig(k[n]) print(H.sector.eigvalues(k[n])) eig_overlap(psi, H, k[n]).plot() plt.show() fidelity(psi, H, "use sym").plot(np.arange(0, 20, 0.01), psi) plt.show()
ref_list = perm_sector_refs[perm_key(edge_vertex_sectors[n])] for m in range(0, np.size(ref_list)): index = pxp.keys[ref_list[m]] edge_vertex_projectors[n][index, index] = 1 H = spin_Hamiltonian(pxp, "x") H.gen() #find root states by those which reside in root sector and are not killed by PH, P a projector into edge_vertex_sectors # root_refs = [] root_refs = dict() for n in range(0, np.size(root_sectors, axis=0)): root_refs[perm_key(root_sectors[n])] = [] for m in range( 0, np.size(perm_sector_refs[perm_key(root_sectors[n])], axis=0)): ref = perm_sector_refs[perm_key(root_sectors[n])][m] state = np.dot(H.sector.matrix(), ref_state(ref, pxp).prod_basis()) for j in range(0, len(edge_vertex_projectors)): temp = np.dot(edge_vertex_projectors[j], state) if np.abs(np.sum(temp)) > 1e-5: root_refs[perm_key(root_sectors[n])] = np.append( root_refs[perm_key(root_sectors[n])], ref) break for n in range(0, np.size(root_sectors, axis=0)): print("\n") for m in range(0, np.size(root_refs[perm_key(root_sectors[n])], axis=0)): ref = root_refs[perm_key(root_sectors[n])][m] print(pxp.basis[pxp.keys[ref]], basis_perm_labels[pxp.keys[ref]]) # smaller hypercubes + hamming, for subcube identification sub_cube_systems = dict()
def cube_fsa(root_sector,sublattice_parity,sector_refs,system): refs = sector_refs[perm_key(root_sector,system)] # #find root refs, those with two neighbouring 1->0 from Neel root_refs = [] for n in range(0,np.size(refs,axis=0)): bits = system.basis[system.keys[refs[n]]] for m in range(0,np.size(bits,axis=0)): if m == np.size(bits)-1: mp1 = 0 mp2 = 1 mp3 = 2 elif m == np.size(bits)-2: mp1 = m + 1 mp2 = 0 mp3 = 1 elif m == np.size(bits)-3: mp1 = m + 1 mp2 = m + 2 mp3 = 0 else: mp1 = m + 1 mp2 = m + 2 mp3 = m + 3 if bits[m] == 0 and bits[mp1] == 0 and bits[mp2] == 0 and bits[mp3] == 0: root_refs = np.append(root_refs,refs[n]) break root_bits = np.zeros((np.size(root_refs),system.N)) for n in range(0,np.size(root_refs,axis=0)): root_bits[n] = system.basis[system.keys[root_refs[n]]] fsa_min_bit_loc = np.zeros((np.size(root_bits,axis=0),int(system.N/2)-2)) fsa_plus_bit_loc = np.zeros(np.size(root_bits,axis=0)) for n in range(0,np.size(root_bits,axis=0)): c=0 for m in range(0,np.size(root_bits[n],axis=0)): if root_bits[n,m] == 1: fsa_min_bit_loc[n,c] = m c = c+1 if sublattice_parity == "L": if m % 2 != 0: if m == system.N-1: mp1 = 0 else: mp1 = m + 1 if m == 0: mm1 = system.N-1 else: mm1 = m - 1 if root_bits[n,mm1] == 0 and root_bits[n,m] == 0 and root_bits[n,mp1] == 0: fsa_plus_bit_loc[n] = m elif sublattice_parity == "R": if m % 2 == 0: if m == system.N-1: mp1 = 0 else: mp1 = m + 1 if m == 0: mm1 = system.N-1 else: mm1 = m - 1 if root_bits[n,mm1] == 0 and root_bits[n,m] == 0 and root_bits[n,mp1] == 0: fsa_plus_bit_loc[n] = m fsa_plus = dict() fsa_min = dict() for n in range(0,np.size(fsa_plus_bit_loc,axis=0)): fsa_plus[n] = np.zeros((system.dim,system.dim)) #scan basis + sites for m in range(0,np.size(system.basis_refs,axis=0)): for k in range(0,system.N): #sp if np.abs(k - fsa_plus_bit_loc[n])<1e-5: bits = np.copy(system.basis[m]) if k == system.N-1: kp1 = 0 else: kp1 = k +1 if k == 0: km1 = system.N-1 else: km1 = k - 1 if bits[kp1] == 0 and bits[km1] == 0 and bits[k] == 0: bits[k] = 1 new_ref = bin_to_int_base_m(bits,system.base) fsa_plus[n][m,system.keys[new_ref]] = 1 #sm if k in fsa_min_bit_loc[n]: bits = np.copy(system.basis[m]) if k == system.N-1: kp1 = 0 else: kp1 = k +1 if k == 0: km1 = system.N-1 else: km1 = k - 1 if bits[kp1] == 0 and bits[km1] == 0 and bits[k] == 1: bits[k] = 0 new_ref = bin_to_int_base_m(bits,system.base) fsa_plus[n][m,system.keys[new_ref]] = 1 for n in range(0,len(fsa_plus)): fsa_min[n] = np.conj(np.transpose(fsa_plus[n])) fsa_basis = dict() fsa_dim = int(system.N/2-2) for n in range(0,np.size(root_refs,axis=0)): fsa_basis[n] = ref_state(root_refs[n],system).prod_basis() current_state = fsa_basis[n] for m in range(0,fsa_dim): new_state = np.dot(fsa_min[n],current_state) new_state = new_state / np.power(np.vdot(new_state,new_state),0.5) fsa_basis[n] = np.vstack((fsa_basis[n],new_state)) current_state = new_state fsa_basis[n] = np.transpose(fsa_basis[n]) basis = fsa_basis[0] for n in range(1,len(fsa_basis)): basis = basis + fsa_basis[n] for n in range(0,np.size(basis,axis=1)): basis[:,n] = basis[:,n] / np.power(np.vdot(basis[:,n],basis[:,n]),0.5) return basis
V=30e-1 H.model_coef = np.array([V,1,1]) # H.model = np.array([[0,1]]) # H.model_coef = np.array([1]) k=[0] H.gen(k) H.sector.find_eig(k) block_refs = pxp_syms.find_block_refs(k) block_keys = dict() for n in range(0,np.size(block_refs,axis=0)): block_keys[block_refs[n]] = n neel=zm_state(2,1,pxp,1) pol = ref_state(0,pxp) all_ones = bin_state(np.append([0],np.ones(pxp.N-1)),pxp) neel_trans = np.zeros(np.size(block_refs)) pol_trans = np.zeros(np.size(block_refs)) all_ones_trans = np.zeros(np.size(block_refs)) neel_trans[block_keys[neel.ref]] = 1 pol_trans[block_keys[pol.ref]] = 1 all_ones_trans[block_keys[all_ones.ref]] = 1 neel_trans_energy = np.dot(np.conj(np.transpose(H.sector.eigvectors(k))),neel_trans) pol_trans_energy = np.dot(np.conj(np.transpose(H.sector.eigvectors(k))),pol_trans) all_ones_trans_energy = np.dot(np.conj(np.transpose(H.sector.eigvectors(k))),all_ones_trans) t=np.arange(0,80,0.01)
if system.basis[n][m] != state_bits[m]: h = h + 1 hamming_sectors[int(h)] = np.append(hamming_sectors[int(h)], system.basis_refs[n]) return hamming_sectors #init small hypercube N = 6 pxp = unlocking_System([0], "periodic", 2, N) pxp.gen_basis() pxp_syms = model_sym_data(pxp, [translational(pxp)]) pxp_sub = unlocking_System([0, 1], "open", 2, int(N / 2)) pxp_sub.gen_basis() z = ref_state(np.max(pxp_sub.basis_refs), pxp_sub) hamming_sub = find_hamming_sectors(z.bits, pxp_sub) c1_bits = dict() c2_bits = dict() for n in range(0, len(hamming_sub) - 1): c1_bits[n] = np.zeros((np.size(hamming_sub[n]), pxp.N)) c2_bits[n] = np.zeros((np.size(hamming_sub[n]), pxp.N)) print("\n") for m in range(0, np.size(hamming_sub[n], axis=0)): bits = pxp_sub.basis[pxp_sub.keys[hamming_sub[n][m]]] for i in range(0, np.size(bits, axis=0)): c1_bits[n][m, 2 * i] = bits[i] c2_bits[n][m, 2 * i + 1] = bits[i] print(c1_bits[n])
# print(1,8) # root_refs = find_root_refs(np.array([1,0]),np.array([1,8]),H,sector_refs,from_sector,pxp,refs_found) # if np.size(root_refs)>0: # temp = subcube_basis(root_refs,"Left",9) # refs_found = np.sort(np.unique(np.append(refs_found,non_zero_ref_in_basis(temp)))) # basis = np.hstack((basis,temp)) # print(np.size(root_refs)) #neel cubes L_cube_sectors = np.zeros((int(pxp.N / 2) + 1, 2)) R_cube_sectors = np.zeros((int(pxp.N / 2) + 1, 2)) for n in range(0, int(pxp.N / 2) + 1): L_cube_sectors[n, 0] = int(pxp.N / 2) - n R_cube_sectors[n, 1] = int(pxp.N / 2) - n L_cube_basis = ref_state(sector_refs[perm_key(L_cube_sectors[0], pxp)][0], pxp).prod_basis() R_cube_basis = ref_state(sector_refs[perm_key(R_cube_sectors[0], pxp)][0], pxp).prod_basis() for n in range(1, np.size(L_cube_sectors, axis=0)): refsL = sector_refs[perm_key(L_cube_sectors[n], pxp)] refsR = sector_refs[perm_key(R_cube_sectors[n], pxp)] tempL = np.zeros(pxp.dim) tempR = np.zeros(pxp.dim) for m in range(0, np.size(refsL, axis=0)): tempL[pxp.keys[refsL[m]]] = 1 tempR[pxp.keys[refsR[m]]] = 1 # tempL = tempL / np.power(np.vdot(tempL,tempL),0.5) # tempR = tempR / np.power(np.vdot(tempR,tempR),0.5) L_cube_basis = np.vstack((L_cube_basis, tempL)) R_cube_basis = np.vstack((R_cube_basis, tempR))
rc('text', usetex=True) # matplotlib.rcParams['figure.dpi'] = 400 #init system N = 10 pxp = unlocking_System( [0, 1], "periodic", 2, N, ) pxp.gen_basis() pxp_syms = model_sym_data(pxp, [translational(pxp)]) #create Hamiltonian J = 0.7 h = 1.4 g = 1 H = Hamiltonian(pxp, pxp_syms) H.site_ops[1] = np.array([[0, 1], [1, 0]]) H.site_ops[2] = np.array([[1, 0], [0, -1]]) H.model = np.array([[1, 1], [1], [2]]) H.model_coef = np.array([J, h, g]) H.gen() H.sector.find_eig() z = ref_state(0, pxp) eig_overlap(z, H).plot() plt.show() fidelity(z, H).plot(np.arange(0, 20, 0.01), z) plt.show()
H.gen() Hp = np.zeros((pxp.dim, pxp.dim)) for n in range(0, np.size(pxp.basis, axis=0)): bits = np.copy(pxp.basis[n]) for m in range(0, pxp.N): if bits[m] == 2: new_bits = np.copy(bits) new_bits[m] = 0 new_ref = bin_to_int_base_m(new_bits, pxp.base) Hp[pxp.keys[new_ref], n] += 2 * (-1)**m Hm = np.conj(np.transpose(Hp)) Hx = 1 / 2 * (Hp + Hm) #scarred eigenstates psi = ref_state(0, pxp).prod_basis() from Calculations import gen_fsa_basis fsa_basis = gen_fsa_basis(Hm, psi, pxp.N) H0 = Hamiltonian(pxp) H0.site_ops[1] = x H0.site_ops[2] = y H0.site_ops[3] = z H0.site_ops[4] = z2 H0.model = np.array([[1, 1], [2, 2]]) H0.model_coef = np.array([J, J]) H0.gen() H1 = Hamiltonian(pxp) H1.site_ops[1] = x H1.site_ops[2] = y
def join_states(psi1, psi2, M_basis_map, system, double_system): M_coef = np.zeros((system.dim, system.dim), dtype=complex) for n in range(0, system.dim): for m in range(0, system.dim): M_coef[n, m] = psi1[n] * psi2[m] new_state = half_rep_to_full(M_coef, M_basis_map, system, double_system) return new_state # H_half = spin_Hamiltonian(pxp_half,"x",pxp_half_syms) H_half = clock_Hamiltonian(pxp_half, pxp_half_syms) H_half.gen() # z_even = ref_state(np.max(pxp_half.basis_refs),pxp_half).prod_basis() # z_odd = ref_state(0,pxp_half).prod_basis() z_even = ref_state(np.max(pxp_half.basis_refs), pxp_half) z_odd = ref_state(0, pxp_half) z_even_prod = z_even.prod_basis() z_odd_prod = z_odd.prod_basis() print(z_even.bits) print(z_odd.bits) state_half_rep = np.zeros((pxp_half.dim, pxp_half.dim)) for n in range(0, np.size(state_half_rep, axis=0)): for m in range(0, np.size(state_half_rep, axis=0)): state_half_rep[n, m] = z_even_prod[n] * z_odd_prod[m] #find Hp sublattice operators in sublattice H space from upper tridiagonal of krylov in sublattice H even_krylov_basis = gen_krylov_basis(H_half.sector.matrix(), krylov_half_dim, z_even,
V = 0.05 U0 = np.dot( H0.sector.eigvectors(), np.dot(np.diag(np.exp(-1j * tau * H0.sector.eigvalues())), np.conj(np.transpose(H0.sector.eigvectors())))) U_kick = np.dot( H_kick.sector.eigvectors(), np.dot(np.diag(np.exp(-1j * V * H_kick.sector.eigvalues())), np.conj(np.transpose(H_kick.sector.eigvectors())))) F = np.dot(U_kick, U0) e, u = np.linalg.eig(F) z = zm_state(2, 1, pxp) z1 = ref_state(0, pxp) z2 = ref_state(1, pxp) no_steps = 500 f = np.zeros(no_steps) f1 = np.zeros(no_steps) f2 = np.zeros(no_steps) current_state = z.prod_basis() current_state1 = z1.prod_basis() current_state2 = z2.prod_basis() for n in range(0, no_steps): f[n] = np.abs(np.vdot(current_state, z.prod_basis()))**2 f1[n] = np.abs(np.vdot(current_state1, z1.prod_basis()))**2 f2[n] = np.abs(np.vdot(current_state2, z2.prod_basis()))**2 current_state = np.dot(F, current_state) current_state1 = np.dot(F, current_state1) current_state2 = np.dot(F, current_state2)
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]) plt.scatter(eigenvalues, overlap) plt.xlabel(r"$E$") plt.ylabel(r"$\log(\vert \langle \psi \vert E \rangle \vert^2)$") # plt.title(r"Ising + SU(2) perts, SU(2) Lowest weight overlap, $N=$"+str(pxp.N)) plt.title(r"Ising, SU(2) Lowest weight overlap, $N=$" + str(pxp.N)) plt.show() t = np.arange(0, 20, 0.01) f = np.zeros(np.size(t)) pol = ref_state(0, pxp) pol_energy = np.conj(u[0, :]) f_pol = np.zeros(np.size(t)) f_hw = np.zeros(np.size(t)) psi_HW_energy = np.dot(np.conj(np.transpose(H.sector.eigvectors())), fsa_basis[:, np.size(fsa_basis, axis=1) - 1]) for n in range(0, np.size(t, axis=0)): evolved_state = time_evolve_state(psi_energy, e, t[n]) f[n] = np.abs(np.vdot(psi_energy, evolved_state))**2 f_pol[n] = np.abs(np.vdot(pol_energy, evolved_state))**2 f_hw[n] = np.abs(np.vdot(psi_HW_energy, evolved_state))**2 plt.plot(t, f, label=r"$\vert H_z, LW \rangle$") plt.plot(t, f_pol, label=r"$\vert 000...\rangle$") plt.plot(t, f_hw, label=r"$\vert H_z, HW \rangle$") plt.legend() plt.xlabel(r"$t$")
subcube_root_hamming_refsL[n][m][j] = temp_refL subcube_root_hamming_refsR[n][m][j] = temp_refR subcube_root_hamming_basisL = dict() subcube_root_hamming_basisR = dict() for n in range(0, len(subcube_root_hamming_refsL)): subcube_root_hamming_basisL[n] = np.zeros( (pxp.dim, len(subcube_root_hamming_refsL[n]))) subcube_root_hamming_basisR[n] = np.zeros( (pxp.dim, len(subcube_root_hamming_refsR[n]))) for m in range(0, len(subcube_root_hamming_refsL[n])): tempL = np.zeros(pxp.dim) tempR = np.zeros(pxp.dim) for k in range(0, np.size(subcube_root_hamming_refsL[n][m], axis=0)): tempL = tempL + ref_state(subcube_root_hamming_refsL[n][m][k], pxp).prod_basis() tempR = tempR + ref_state(subcube_root_hamming_refsR[n][m][k], pxp).prod_basis() tempL = tempL / np.power(np.vdot(tempL, tempL), 0.5) tempR = tempR / np.power(np.vdot(tempR, tempR), 0.5) subcube_root_hamming_basisL[n][:, m] = tempL subcube_root_hamming_basisR[n][:, m] = tempR subcube_combined_basisL = subcube_root_hamming_basisL[0] subcube_combined_basisR = subcube_root_hamming_basisR[0] for n in range(1, len(subcube_root_hamming_refsL)): subcube_combined_basisL = subcube_combined_basisL + subcube_root_hamming_basisL[ n] subcube_combined_basisR = subcube_combined_basisR + subcube_root_hamming_basisR[ n]
d = np.size(temp)-1 if d > int(N/2): d = N - d model_coef = np.append(model_coef,J/np.power(d,alpha)) model.append(temp) Hz = Hamiltonian(pxp,pxp_syms) Hz.site_ops[1] = np.array([[-1,0],[0,1]]) Hz.model = model Hz.model_coef = model_coef Hx = Hamiltonian(pxp,pxp_syms) Hx.site_ops[1] = np.array([[0,1],[1,0]]) Hx.model = np.array([[1]]) Hx.model_coef = np.array([-B]) k=[0] z=ref_state(np.max(pxp.basis_refs),pxp) Hz.gen(k) Hx.gen(k) H = H_operations.add(Hz,Hx,np.array([1,1])) H.sector.find_eig(k) overlap = eig_overlap(z,H,k).eval() plt.scatter(H.sector.eigvalues(k),overlap) plt.title(r"$H = -\sum_{i<j}^L \frac{J}{r_{ij}^\alpha} \sigma_i^z \sigma_{i+1}^z - B \sum_i \sigma_i^x$"+"\n"+r"$J=1$, $B=0.27$, $\alpha=2.3$, $k=0$, $N=$"+str(pxp.N)) plt.ylabel(r"$\log(\vert \langle 1111... \vert E \rangle \vert^2)$") plt.xlabel(r"$E$") plt.show()
H.model = np.array([[0,1,0]]) H.model_coef=np.array((1)) H.gen() H.sector.find_eig() z_rydberg = zm_state(2,1,pxp) f_neel_ham = fidelity(z_rydberg,H).eval(t,z_rydberg) # plt.plot(t,f_neel_ham) # plt.show() H_diag = np.diag(np.exp(-1j*tau*H.sector.eigvalues())) exp_H = np.dot(H.sector.eigvectors(),np.dot(np.diag(np.exp(-1j*tau*H.sector.eigvalues())),np.conj(np.transpose(H.sector.eigvectors())))) #evaluate direct overlap of all states states=dict() for n in range(0,np.size(pxp_half.basis_refs,axis=0)): states[n] = ref_state(pxp_half.basis_refs[n],pxp) pbar=ProgressBar() f_ham=dict() f_floquet=dict() evolution_overlap=dict() for state_index in pbar(range(0,len(states))): evolution_overlap[state_index] = np.zeros(np.size(t)) # print(states[state_index].bits) original_state = states[state_index].prod_basis() current_state_ham = original_state current_state_floquet = original_state f_ham[state_index] = np.zeros(np.size(t)) f_floquet[state_index] = np.zeros(np.size(t))
if target_sectorR in mapped_sectorsR: root_refsR[perm_key(root_sectorsR[n])] = np.append( root_refsR[perm_key(root_sectorsR[n])], refsR[m]) else: non_root_refsR[perm_key(root_sectorsR[n])] = np.append( non_root_refsR[perm_key(root_sectorsR[n])], refsR[m]) non_root_basisL = np.zeros(pxp.dim) non_root_basisR = np.zeros(pxp.dim) for n in range(0, np.size(root_sectorsL, axis=0)): refsL = non_root_refsL[perm_key(root_sectorsL[n])] refsR = non_root_refsR[perm_key(root_sectorsR[n])] tempL = np.zeros(pxp.dim) tempR = np.zeros(pxp.dim) for m in range(0, np.size(refsL, axis=0)): tempL = tempL + ref_state(refsL[m], pxp).prod_basis() tempR = tempR + ref_state(refsR[m], pxp).prod_basis() if np.sum(np.abs(tempL)) > 1e-5: tempL = tempL / np.power(np.vdot(tempL, tempL), 0.5) non_root_basisL = np.vstack((non_root_basisL, tempL)) if np.sum(np.abs(tempR)) > 1e-5: tempR = tempR / np.power(np.vdot(tempR, tempL), 0.5) non_root_basisR = np.vstack((non_root_basisR, tempL)) non_root_basisL = np.transpose(np.delete(non_root_basisL, 0, axis=0)) non_root_basisR = np.transpose(np.delete(non_root_basisR, 0, axis=0)) # form subcube basis stemming from root nodes hamming_layer_refsL = dict() hamming_layer_refsR = dict() for n in range(0, np.size(root_sectorsL, axis=0)): print(root_sectorsR[n])
# H.gen(k[n]) # H.sector.find_eig(k[n]) # fidelity(z,H,"use sym").plot(np.arange(0,20,0.01),z) fidelity(z, H).plot(np.arange(0, 20, 0.01), z) plt.show() states = dict() states_energy = dict() f = dict() ent = entropy(pxp) ent_vals = np.zeros(np.size(pxp.basis_refs)) pbar = ProgressBar() print("Plotting fidelity/entropy") for n in pbar(range(0, np.size(pxp.basis_refs, axis=0))): states[n] = ref_state(pxp.basis_refs[n], pxp) states_energy[n] = np.conj(u[pxp.keys[states[n].ref], :]) f[n] = np.zeros(np.size(t)) ent_vals[n] = ent.eval(u[:, n]) for m in range(0, np.size(t, axis=0)): evolved_state = time_evolve_state(states_energy[n], e, t[m]) f[n][m] = np.abs(np.vdot(states_energy[n], evolved_state))**2 plt.plot(t, f[n], alpha=0.6) plt.xlabel(r"$t$") plt.ylabel(r"$\vert \langle n(0) \vert n(t) \rangle \vert^2$") plt.title( r"Hypercube $H=\sum_i X_i$, with $P=$" + str(p) + " chance of removing state from $L/2-1, L/2, L/2+1$ hamming sector. Computational basis fidelities, $N=$" + str(pxp.N))
# linblads[j] = temp def linblad(rho, H, P, coef): temp = -1j * com(H, rho) for n in range(0, len(linblads)): temp = temp + coef * (np.dot(linblads[n], np.dot(rho, linblads[n])) - 0.5 * np.dot(linblads[n], rho) - 0.5 * np.dot(rho, linblads[n])) return temp # return -1j * com(H,rho)+coef*(np.dot(P,np.dot(rho,P))-0.5*np.dot(P,rho)-0.5*np.dot(rho,P)) pbar = ProgressBar() for index in pbar(range(0, np.size(pxp.basis_refs), 2)): z = ref_state(pxp.basis_refs[index], pxp) index = pxp.keys[z.ref] rho = np.zeros((pxp.dim, pxp.dim)) rho[index, index] = 1 #integrate linblad with runge kutta rho delta_t = 0.1 t_max = 10 t = np.arange(0, t_max + delta_t, delta_t) rho_t = dict() rho_t[0] = rho coef = 0.1 f = np.zeros(np.size(t)) f[0] = 1 z_anti = zm_state(2, 1, pxp, 1)
temp_basis = temp_basis + find_subcube_basis(roots[m],1,"Left") for m in range(0,np.size(temp_basis,axis=1)): temp_basis[:,m] = temp_basis[:,m] / np.power(np.vdot(basis[:,m],basis[:,m]),0.5) basis = np.hstack((basis,temp_basis)) roots = find_root_refs(np.array([2,0]),np.array([2,2])) temp_basis = find_subcube_basis(roots[0],2,"Right") for m in range(1,np.size(roots,axis=0)): temp_basis = temp_basis + find_subcube_basis(roots[m],2,"Right") for m in range(0,np.size(temp_basis,axis=1)): temp_basis[:,m] = temp_basis[:,m] / np.power(np.vdot(basis[:,m],basis[:,m]),0.5) basis = np.hstack((basis,temp_basis)) neel_subcube_system = unlocking_System([0,1],"open",2,int(pxp.N/2)) neel_subcube_system.gen_basis() z=ref_state(np.max(neel_subcube_system.basis_refs),neel_subcube_system) neel_hamming = find_hamming_sectors(z.bits,neel_subcube_system) #hypercube from Neel/AntiNeel z0=zm_state(2,1,pxp) z1=zm_state(2,1,pxp,1) cube_dim = int(pxp.N/2) cube_basisL = np.zeros(pxp.dim) cube_basisR = np.zeros(pxp.dim) for n in range(0,len(neel_hamming)): # for n in range(0,2): refs = neel_hamming[n] temp_stateL = np.zeros(pxp.dim) temp_stateR = np.zeros(pxp.dim) one_locL = np.arange(0,pxp.N-1,2) one_locR = np.arange(1,pxp.N,2)
def perm_key(n,m): return bin_to_int_base_m([n,m],int(pxp.N/2)+1) permsectors = dict() for n in range(0,np.size(pxp.basis,axis=0)): bits = pxp.basis[n] aOcc = 0 bOcc = 0 for m in range(0,pxp.N): if bits[m] == 1: if m % 2 == 0: aOcc += 1 else: bOcc += 1 key = perm_key(aOcc,bOcc) if key in list(permsectors.keys()): permsectors[key] += ref_state(pxp.basis_refs[n],pxp).prod_basis() else: permsectors[key] = ref_state(pxp.basis_refs[n],pxp).prod_basis() keys = list(permsectors.keys()) perm_basis = np.zeros((pxp.dim,np.size(keys))) for n in range(0,np.size(keys,axis=0)): perm_basis[:,n] = permsectors[keys[n]] / np.power(np.vdot(permsectors[keys[n]],permsectors[keys[n]]),0.5) # create Hamiltonian H = spin_Hamiltonian(pxp,"x") H.gen() z=zm_state(2,1,pxp,1) H.sector.find_eig() H_perm = np.dot(np.conj(np.transpose(perm_basis)),np.dot(H.sector.matrix(),perm_basis))
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()
h = 0 for m in range(0, pxp.N, 1): if pxp.basis[n][m] != state_bits[m]: h = h + 1 hamming_sectors[int(h)] = np.append(hamming_sectors[int(h)], pxp.basis_refs[n]) return hamming_sectors #init small hypercube pxp = unlocking_System([0, 1], "periodic", 2, 10) pxp.gen_basis() #form hamming rep starting from Neel # z=zm_state(2,1,pxp) z = ref_state(2, pxp) hamming_sectors = find_hamming_sectors(z.bits) for n in range(0, np.size(hamming_sectors[2])): print(pxp.basis[pxp.keys[hamming_sectors[2][n]]]) V = Hamiltonian(pxp) V.site_ops[1] = np.array([[0, 0], [0, 1]]) V.model = np.array([[1]]) V.model_coef = np.array([1]) V.gen() # H0 = spin_Hamiltonian(pxp,"x") # H0.gen()