Example #1
0
 def test_eigs_sparse_wvecs(self, mat_herm_sparse, backend):
     u, a = mat_herm_sparse
     assert qu.issparse(a)
     lk, vk = qu.eigh(a, k=2, backend=backend)
     assert_allclose(lk, (-3, -1))
     for i, j in zip([3, 0], [0, 1]):
         o = u[:, [i]].H @ vk[:, [j]]
         assert_allclose(abs(o), 1.)
     vk = qu.eigvecsh(a, k=2, backend=backend)
     for i, j in zip([3, 0], [0, 1]):
         o = u[:, [i]].H @ vk[:, [j]]
         assert_allclose(abs(o), 1.)
Example #2
0
 def test_spin_half_double_space(self, sz):
     prj = qu.zspin_projector(5, sz)
     h = qu.ham_heis(5)
     h0 = prj.T @ h @ prj
     v0s = qu.eigvecsh(h0)
     for v0 in v0s.T:
         vf = prj @ v0.T
         prjv = vf @ vf.H
         # Check reconstructed full eigenvectors commute with full ham
         assert_allclose(prjv @ h, h @ prjv, atol=1e-13)
     if sz == 0:
         # Groundstate must be in most symmetric subspace
         gs = qu.groundstate(h)
         gs0 = prj @ v0s[:, 0]
         assert_allclose(qu.expec(gs, gs0), 1.0)
         assert_allclose(qu.expec(h, gs0), qu.expec(h, gs))
Example #3
0
 def test_works(self, sz):
     prj = qu.zspin_projector(4, sz)
     h = qu.ham_heis(4)
     h0 = prj.T @ h @ prj
     v0s = qu.eigvecsh(h0)
     for i in range(v0s.shape[1]):
         v0 = v0s[:, [i]]
         vf = prj @ v0
         prjv = vf @ vf.H
         # Check reconstructed full eigenvectors commute with full ham
         assert_allclose(prjv @ h, h @ prjv, atol=1e-13)
     if sz == 0:
         # Groundstate must be in most symmetric subspace
         gs = qu.groundstate(h)
         gs0 = prj @ v0s[:, [0]]
         assert_allclose(qu.expec(gs, gs0), 1.0)
         assert_allclose(qu.expec(h, gs0), qu.expec(h, gs))
Example #4
0
 def test_eigvecs(self, mat_herm_dense):
     u, a = mat_herm_dense
     v = qu.eigvecsh(a)
     for i, j in zip([3, 0, 1, 2], range(4)):
         o = u[:, [i]].H @ v[:, [j]]
         assert_allclose(abs(o), 1.)
Example #5
0
if dis_flag == 1:
    H_0 = qu.ham_mbl(N,
                     W_i,
                     J_tab,
                     cyclic=False,
                     dh_dist='qp',
                     beta=0.721,
                     seed=seed,
                     sparse=True).real
else:
    H_0 = qu.ham_mbl(N, W_i, J_tab, cyclic=False, seed=seed, sparse=True).real

H_pre = P.T @ H_0 @ P

psi_0 = qu.eigvecsh(H_pre, k=1, which='SA').ravel()

if dis_flag == 1:
    H_1 = qu.ham_mbl(N,
                     W,
                     J_tab,
                     cyclic=False,
                     dh_dist='qp',
                     beta=0.721,
                     seed=seed,
                     sparse=True).real
else:
    H_1 = qu.ham_mbl(N, W, J_tab, cyclic=False, seed=seed, sparse=True).real

H_post = P.T @ H_1 @ P
Example #6
0
 def test_sparse(self):
     a = qu.rand_herm(10, sparse=True, density=0.9)
     vt = qu.eigvecsh(a, sigma=0, k=1)
     assert qu.is_eigenvector(vt, a)
     vf = qu.rand_ket(10)
     assert not qu.is_eigenvector(vf, a)
Example #7
0
 def test_dense_true(self):
     a = qu.rand_herm(10)
     v = qu.eigvecsh(a)
     for i in range(10):
         assert qu.is_eigenvector(v[:, [i]], a)
Example #8
0
def orthog_ks():
    p = qu.rand_rho(3)
    v = qu.eigvecsh(p)
    return (v[:, [0]], v[:, [1]], v[:, [2]])
Example #9
0
def orthog_ks():
    p = qu.rand_rho(3)
    v = qu.eigvecsh(p)
    return (v[:, 0], v[:, 1], v[:, 2])
Example #10
0
### Global parameters ###
N = params.L
W = params.D
J = 1.0
dis_flag = params.Dis_gen
seed = int(1000000 * np.random.random())
int_flag = 1
t_tab = np.logspace(-2, 1.5, 300)

### ETH ---> MBL ###
J_ETH = (J, J, J)

P = qu.zspin_projector(N, sz=0)

H_ETH = P.T @ qu.ham_heis(N, J_ETH, sparse=True, cyclic=False) @ P
Psi_ETH = qu.eigvecsh(H_ETH, k=1, which='SA')

J_evo1 = (0.0, 0.0, 0.0)
H_evo1 = P.T @ qu.ham_mbl(N,
                          W,
                          J_evo1,
                          cyclic=False,
                          dh_dist='qp',
                          beta=0.721,
                          seed=seed,
                          sparse=True).real @ P

compute = {
    'time': lambda t, p: t,
    'losch': lambda t, p: qu.fidelity(Psi_ETH, p)
}