def mf_ops(plaquette, basis): """ Constructs a dict of QuSpin quantum operators for all components of spin on each site of the cluster Input: plaquette (dict): Contains lists of neighbors, from files in the plaquettes folder basis (QuSpin spin_basis_1d object): basis to construct the Hamiltonian in Output: ops (list): Format is [{'x': x_op, 'y': y_op, 'z': z_op}] with one dict for each site in the cluster """ ops = [{} for i in range(plaquette['L'])] for i in range(plaquette['L']): ops[i]['x'] = quantum_operator({'static': [['x', [[1.0, i]]]]}, basis=basis, check_herm=False, check_symm=False, dtype=TYPE) ops[i]['y'] = quantum_operator({'static': [['y', [[1.0, i]]]]}, basis=basis, check_herm=False, check_symm=False, dtype=TYPE) ops[i]['z'] = quantum_operator({'static': [['z', [[1.0, i]]]]}, basis=basis, check_herm=False, check_symm=False, dtype=TYPE) return ops
def dot_test(): M = np.arange(9).reshape((3, 3)).astype(np.complex128) v = np.ones((3, 2)) v_fail_1 = np.ones((4, )) v_fail_2 = np.ones((3, 1, 1)) input_dict = {"J": [M]} op_dict = quantum_operator(input_dict) v_op = op_dict.dot(v) assert (np.linalg.norm(v_op - M.dot(v)) < eps) v_op = op_dict.dot(v, pars={"J": 0.5}) assert (np.linalg.norm(v_op - 0.5 * M.dot(v)) < eps) v_op = op_dict.dot(v, pars={"J": 0.5}, check=False) assert (np.linalg.norm(v_op - 0.5 * M.dot(v)) < eps) try: v_op = op_dict.dot(v_fail_1) Pass = True except: Pass = False assert (not Pass) try: v_op = op_dict.dot(v_fail_2) Pass = True except: Pass = False assert (not Pass)
def inner_hamiltonian(plaquette, interactions, basis, verbose=False, coeffs={ 'inner': {}, 'outer': {} }, every_other=False, checks=False): """ Constructs a QuSpin quantum_operator corresponding to the inner-cluster Hamiltonian (i.e. the cluster Hamiltonian with OBC) Input: plaquette (dict): Contains lists of neighbors, from files in the plaquettes folder interactions (dict): dict of interactions (see example in README.md) basis (QuSpin spin_basis_1d object): basis to construct the Hamiltonian in coeffs (list of #s): Factors to multiply each coupling for each site by. Output: Hi: QuSpin quantum_operator """ terms = [] L = plaquette['L'] neighbors = ['nearest', 'n_nearest', 'n_n_nearest'] bonds = ['x_bonds', 'y_bonds', 'z_bonds'] for n in interactions: if n == 'local': for c_op in interactions[n]: r = get_r(L, coeffs['inner'], n, c_op) couplings = interactions[n][c_op] * r terms += [[c_op, [[couplings[i], i] for i in range(L)]]] elif n in neighbors: for c_op in interactions[n]: coupling = interactions[n][c_op] r_in = get_r(L, coeffs['inner'], n, c_op) for i in range(L): i_neighbors = np.array(plaquette['inner'][n][i]) if every_other: i_neighbors = i_neighbors[i_neighbors < i] terms += [[ c_op, [[coupling * r_in[i, ni], i, ni] for ni in i_neighbors] ]] elif n in bonds: for c_op in interactions[n]: coupling = interactions[n][c_op] terms += [[ c_op, [[coupling, b[0], b[1]] for b in plaquette['inner'][n]] ]] else: raise Exception('Unknown interaction type {}'.format(n)) Hi = quantum_operator({'static': terms}, basis=basis, check_herm=checks, check_symm=checks, dtype=TYPE) return Hi
def eigvalsh_test(): M = np.arange(16).reshape((4, 4)).astype(np.complex128) M = M.T + M input_dict = {"J": [M]} op_dict = quantum_operator(input_dict) E1 = np.linalg.eigvalsh(M) E2 = op_dict.eigvalsh() assert (np.linalg.norm(E1 - E2) / 4.0 < eps) E1 = np.linalg.eigvalsh(0.5 * M) E2 = op_dict.eigvalsh(pars={"J": 0.5}) assert (np.linalg.norm(E1 - E2) / 4.0 < eps)
def eigsh_test(): M = np.arange(16).reshape((4, 4)).astype(np.complex128) M = M.T + M input_dict = {"J": [M]} op_dict = quantum_operator(input_dict) E1, V1 = sp.linalg.eigsh(M, k=2) E2, V2 = op_dict.eigsh(k=2) assert (np.linalg.norm(E1 - E2) / 2.0 < eps) E1, V1 = sp.linalg.eigsh(0.5 * M, k=2) E2, V2 = op_dict.eigsh(k=2, pars={"J": 0.5}) assert (np.linalg.norm(E1 - E2) / 2.0 < eps)
def outer_hamiltonian(plaquette, mean_fields, interactions, basis, verbose=False, coeffs={ 'inner': {}, 'outer': {} }, every_other=False, checks=False): """ Constructs a QuSpin quantum_operator corresponding to the cluster-bath Hamiltonian Input: plaquette (dict): Contains lists of neighbors, from files in the plaquettes folder mean_fields (dict): dict of mean fields (see example in README.md) interactions (dict): dict of interactions (see example in README.md) basis (QuSpin spin_basis_1d object): basis to construct the Hamiltonian in coeffs (list of #s): Factors to multiply each coupling for each site by. Output: Ho: QuSpin quantum_operator """ L = plaquette['L'] terms = [] neighbors = ['nearest', 'n_nearest', 'n_n_nearest'] bonds = ['x_bonds', 'y_bonds', 'z_bonds'] for n in interactions: if n in neighbors: for c_op in interactions[n]: r_out = get_r(L, coeffs['outer'], n, c_op) coupling = interactions[n][c_op] for i in range(L): o_neighbors = np.array(plaquette['outer'][n][i]) if every_other: o_neighbors = o_neighbors[o_neighbors < i] terms += [[ c_op[1], [[ coupling * mean_fields[c_op[0]][ni] * r_out[i, ni], i ] for ni in o_neighbors] ]] elif n in bonds: for c_op in interactions[n]: coupling = interactions[n][c_op] terms += [[ c_op[0], [[coupling * mean_fields[c_op[1]][b[1]], b[0]] for b in plaquette['outer'][n]] ]] terms += [[ c_op[1], [[coupling * mean_fields[c_op[0]][b[0]], b[1]] for b in plaquette['outer'][n]] ]] elif n == 'local': pass else: raise Exception('Unknown interaction type {}'.format(n)) Ho = quantum_operator({'static': terms}, basis=basis, check_herm=checks, check_symm=checks, dtype=TYPE) return Ho
### RUN ### ti = time() # start timing function for each realization sp_basis = spin_basis_1d(L,L//2) int_list, hop_list = hf.coupling_list(L, Jxy, Jz) oplist_static = [["+-",hop_list],["-+",hop_list],["zz",int_list]] Dim = sp_basis.Ns t_i, t_f, t_steps = 0.0, 20.0, 400 t_tab = np.linspace(t_i,t_f,num=t_steps,endpoint=True) operator_dict = dict(H0 = oplist_static) for i in range(L): operator_dict["z"+str(i)] = [["z", [[1.0, i]]]] no_checks={"check_herm":False,"check_pcon":False,"check_symm":False} H_dict = quantum_operator(operator_dict, basis = sp_basis, **no_checks) params_dict = dict(H0=1.0) seed = np.random.randint(0, 100000) np.random.seed(seed) dis_table_1=np.random.rand(L)*2-1.0 for j in range(L): params_dict["z"+str(j)] = w*dis_table_1[j] # create random fields list HAM_1 = H_dict.tohamiltonian(params_dict) # build initial Hamiltonian through H_dict epsilon=params.Epsilon params_dict = dict(H0=1.0) dis_table_2=np.random.rand(L)*2.0-1.0
L = 10 alpha = 2.0 t = (np.arange(L) + 1) % L p = np.arange(L)[::-1] z = -(np.arange(L) + 1) basis = spin_basis_general(L, m=0.0, t=(t, 0), p=(p, 0), z=(z, 0), pauli=False) Jzz_list = [[Jr(r, alpha), i, (i + r) % L] for i in range(L) for r in range(1, L // 2, 1)] Jxy_list = [[Jr(r, alpha) / 2.0, i, (i + r) % L] for i in range(L) for r in range(1, L // 2, 1)] ops = dict(Jxy=[[op, Jxy_list] for op in ["+-", "-+"]], Jzz=[["zz", Jzz_list]], Jd=[np.random.normal(0, 1, size=(basis.Ns, basis.Ns))]) op = quantum_operator(ops, basis=basis, dtype=np.float32, matrix_formats=dict(Jzz="dia", Jxy="csr", Jd="dense")) with tempfile.TemporaryDirectory() as tmpdirname: file = os.path.join(tmpdirname, "test_save.zip") save_zip(file, op, save_basis=True) new_op_1 = load_zip(file) assert (len((op - new_op_1)._quantum_operator) == 0) save_zip(file, op, save_basis=False) new_op_2 = load_zip(file) assert (len((op - new_op_2)._quantum_operator) == 0)
basis_f = spinless_fermion_basis_general(N, Nf=2) basis_2 = tensor_basis(basis_f, basis_f) basis_3 = spinful_fermion_basis_1d(L=N, Nf=(2, 2)) basis_4 = spinful_fermion_basis_general(N, Nf=(2, 2)) basis_dict = dict(tensored_spinless_fermion_basis_1d=basis_1, spinful_fermion_basis_1d=basis_3, tensored_spinless_fermion_basis_general=basis_2, spinful_fermion_basis_general=basis_4) for basis_name, basis in basis_dict.items(): H_U = quantum_operator(operator_dict, basis=basis, dtype=np.float64, check_pcon=False, check_symm=False, check_herm=False) E_quspin = np.zeros(E_paper.shape, ) for j, U in enumerate(np.linspace(0.0, 4.0, 9)): params_dict = dict(H0=1.0, H1=U) H = H_U.tohamiltonian(params_dict) E_quspin[j] = H.eigsh(k=1, which="SA", maxiter=1E4, return_eigenvectors=False) np.testing.assert_allclose(E_quspin, E_paper, atol=1e-13)
def anneal_MF(L, T, sigma=0.01, path=".", n_chains=1): ti = time.time() print "creating basis" basis = spin_basis_1d(L, pauli=True, kblock=0, pblock=1) hx_list = [[-1, i] for i in range(L)] hz_list = [[1, i] for i in range(L)] J_list = [[-1, i, (i + 1) % L] for i in range(L)] M_list = [[1.0 / L**2, i, j] for i in range(L) for j in range(L)] ops_dict = dict(J=[["zz", J_list]], h=[["x", hx_list]]) H0 = quantum_operator(ops_dict, basis=basis, dtype=np.float64) Hz = hamiltonian([["z", hz_list]], [], basis=basis, dtype=np.float64) M2 = hamiltonian([["zz", M_list]], [], basis=basis, dtype=np.float64) def B(t, T): return (1 - t / T)**2 def A(t, T, J0, eta): return (J0 + eta(t)) * (t / T)**2 _, psi0 = H0.eigsh(k=1, which="SA", pars=dict(J=0, h=1)) psi0 = psi0.astype(np.complex128).ravel() y0 = np.hstack([psi0 for i in range(n_chains)]) yout = y0.reshape((n_chains, basis.Ns)).copy() for i in range(3): H_list = [] eta2_list = [] for j in range(n_chains): omega1 = get_samples(1000, omega_max=10) omega2 = get_samples(1000, omega_max=10) eta1 = fourier_noise(0.0, lambda t: 1.0, sigma, omega1) eta2 = fourier_noise(0.0, lambda t: 1.0, sigma, omega2) # if j==0: # pars = dict(J=(A,(T,1.0,eta1)),h=(B,(T,))) # else: # pars = dict(J=(A,(T,sigma,eta1)),h=(B,(T,))) pars = dict(J=(A, (T, 1.0, eta1)), h=(B, (T, ))) H_list.append(H0.tohamiltonian(pars=pars)) eta2_list.append(eta2) f_params = (yout, H_list, Hz.tocsr(), eta2_list, L, T, sigma) psif = evolve(y0.reshape((-1, basis.Ns)), 0, T, SO_MF, f_params=f_params, solver_name="dop853", atol=1.1e-15, rtol=1.1e-15) psif = psif[0] q, m2 = H0.matrix_ele(psif, psif, pars=dict(J=1, h=0), diagonal=True).real + L, M2.expt_value(psif).real line = "{:30.15e} {:30.15e}".format(q, m2) print i + 1, line
from quspin.basis import spin_basis_general from quspin.operators import hamiltonian, quantum_operator import numpy as np import scipy.sparse as sp L = 10 for Nup in [0, 1, 2]: t = (np.arange(L) + 1) % L basis = spin_basis_general(L, Nup=Nup, t=(t, 1)) J_list = [[1.0, i, (i + 1) % L] for i in range(L)] static = [[op, J_list] for op in ["xx", "yy", "zz"]] H = hamiltonian(static, [], basis=basis, dtype=np.complex128) O = quantum_operator(dict(J=static), basis=basis, dtype=np.complex128) ns = 10 pure_sp = sp.random(H.Ns, 1, format="csr") pure_sp_many = sp.random(H.Ns, ns, format="csr") mixed_sp = sp.random(H.Ns, H.Ns, format="csr") pure = np.random.normal(0, 1, size=(H.Ns, )) pure_many = np.random.normal(0, 1, size=(H.Ns, ns)) pure_sq = np.random.normal(0, 1, size=(H.Ns, H.Ns)) mixed = np.random.normal(0, 1, size=(H.Ns, H.Ns)) mixed_many = np.random.normal(0, 1, size=(H.Ns, H.Ns, ns)) times = np.linspace(0, 1, ns)
# ###### create the basis basis = spin_basis_1d(L, pblock=1, pauli=False) # up basis ##### create model # define static (fixed) site-coupling lists J_list = [[J, i, (i + 2) % L] for i in range(L)] # nnn interaction PBC hx_list = [[hx, i] for i in range(L)] # onsite field # create static lists for H0 operator_list_0 = [["zz", J_list], ["x", hx_list]] # define parametric lists for H1 (corresponding to operators the coupling of which will be changed) hz_list = [[1.0, i] for i in range(L)] # onsite field operator_list_1 = [["z", hz_list]] # ###### create operator dictionary for quantum_operator class # add keys for TFI operators tring list and the longitudinal field operator_dict = dict(H0=operator_list_0, H1=operator_list_1) # ###### setting up `quantum_operator` hamiltonian dictionary H = quantum_operator(operator_dict, basis=basis) # print Hamiltonian H = H0 + H1 params_dict = dict( H0=1.0, H1=1.0 ) # dict containing the couplings to operators in keys of operator_dict H_lmbda1 = H.tohamiltonian(params_dict) print(H_lmbda1) # change z-coupling strength: print Hamiltonian H = H0 + 2H1 params_dict = dict( H0=1.0, H1=2.0 ) # dict containing the couplings to operators in keys of operator_dict H_lmbda2 = H.tohamiltonian(params_dict) print(H_lmbda2)
def fx(t, T): # x driving return 1 - np.sin(np.pi * t / (2 * T))**2 ##### construct basis basis = spin_basis_1d(L, S="1/2", pauli=True, kblock=0, pblock=1, zblock=1) # define PBC site-coupling lists for operators x_field = [[-1.0, i] for i in range(L)] J_nn = [[-1.0, i, (i + 1) % L] for i in range(L)] # PBC # static and dynamic lists static = [] operator_dict = dict(Jzz=[["zz", J_nn]], hx=[["x", x_field]]) m2_list = [[1.0 / L**2, i, j] for i in range(L) for j in range(L)] ###### construct Hamiltonian H = quantum_operator(operator_dict, basis=basis, dtype=np.float64) M2 = hamiltonian([["zz", m2_list]], [], dtype=np.float64, basis=basis) ##### calculate ground state at t=0 ##### E0, psi0 = H.eigsh(k=1, which="SA", pars=dict(Jzz=0, hx=1)) psi0 = psi0.reshape((-1, )) ##### evolve state ##### times = np.linspace(0, 1, 101) M2_eq = np.zeros(101) E_eq = np.zeros(101) # calculating ground state expectation values for i, t in enumerate(times): s = fzz(t, 1) [E], psi = H.eigsh(k=1, which="SA",