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",
