def test_BlockSparseTensor_zeros(dtype, num_charges):
np.random.seed(10)
Ds = [8, 9, 10, 11]
rank = 4
flows = np.random.choice([True, False], size=rank, replace=True)
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges), flows[n])
for n in range(rank)
]
arr = BlockSparseTensor.zeros(indices, dtype=dtype)
np.testing.assert_allclose(arr.data, 0)
np.testing.assert_allclose(Ds, arr.shape)
np.testing.assert_allclose(arr.flat_flows, flows)
for n in range(4):
assert charge_equal(arr.charges[n][0], indices[n].flat_charges[0])
def test_randn(R, dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
indices = [
Index(
BaseCharge(
np.random.randint(-5, 6, (num_charges, 10)),
charge_types=[U1Charge] * num_charges), False) for _ in range(R)
]
actual = backend.randn(indices, dtype=dtype, seed=10)
np.random.seed(10)
expected = randn(indices, dtype=dtype)
np.testing.assert_allclose(expected.data, actual.data)
assert np.all([
charge_equal(expected._charges[n], actual._charges[n])
for n in range(len(actual._charges))
])
def test_svd_decompositions(dtype, R, R1, num_charges):
np.random.seed(10)
D = 30
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, D)),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
u, s, v, _ = decompositions.svd_decomposition(bs, A, R1)
u_dense, s_dense, v_dense, _ = np_decompositions.svd_decomposition(
np, A.todense(), R1)
res1 = bs.tensordot(bs.tensordot(u, bs.diag(s), 1), v, 1)
res2 = np.tensordot(np.tensordot(u_dense, np.diag(s_dense), 1), v_dense, 1)
np.testing.assert_almost_equal(res1.todense(), res2)
def test_add_sub(op, dtype, num_charges, chargetype):
np.random.seed(10)
indices = [
Index(get_charge(chargetype, num_charges, 10), False) for _ in range(4)
]
order = np.arange(4)
np.random.shuffle(order)
a = BlockSparseTensor.randn(indices, dtype=dtype)
b = BlockSparseTensor.randn([indices[o] for o in order], dtype=dtype)
npb = np.reshape(b.todense(), b.shape)
npa = np.reshape(a.todense(), a.shape)
c = a.transpose(order)
npc = npa.transpose(order)
d = op(c, b)
npd = op(npc, npb)
np.testing.assert_allclose(d.todense(), npd)
def test_rq_decomposition(dtype, R, R1, num_charges):
np.random.seed(10)
D = 30
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, D)),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
r, q = decompositions.rq_decomposition(bs, A, R1)
res = bs.tensordot(r, q, 1)
r_dense, q_dense = np_decompositions.rq_decomposition(np, A.todense(), R1)
res2 = np.tensordot(r_dense, q_dense, 1)
np.testing.assert_almost_equal(res.todense(), res2)
def test_broadcast_left_multiplication_raises():
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
num_charges = 1
Ds = [10, 30, 24]
R = len(Ds)
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (Ds[n], num_charges)),
charge_types=[U1Charge] * num_charges), False)
for n in range(R)
]
tensor1 = ChargeArray.random(indices=indices)
tensor2 = backend.randn(indices)
with pytest.raises(ValueError):
backend.broadcast_left_multiplication(tensor1, tensor2)
def test_random_uniform_seed(dtype, num_charges):
np.random.seed(10)
R = 4
backend = symmetric_backend.SymmetricBackend()
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (10, num_charges)),
charge_types=[U1Charge] * num_charges), False)
for _ in range(R)
]
a = backend.random_uniform(indices, dtype=dtype, seed=10)
b = backend.random_uniform(indices, dtype=dtype, seed=10)
np.testing.assert_allclose(a.data, b.data)
assert np.all([
charge_equal(a._charges[n], b._charges[n])
for n in range(len(a._charges))
])
def test_eigs_cache_exception():
dtype = np.float64
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
D = 16
index = Index(U1Charge.random(D, 0, 0), True)
def mv(vec):
raise ValueError()
init = BlockSparseTensor.random([index], dtype=dtype)
with pytest.raises(ValueError):
backend.eigs(mv, [], init)
cacher = get_cacher()
assert not cacher.do_caching
assert not get_caching_status()
assert cacher.cache == {}
def test_eig_prod(dtype, Ds, num_charges):
np.random.seed(10)
R = len(Ds)
charges = [
BaseCharge(
np.random.randint(-5, 6, (num_charges, Ds[n]), dtype=np.int16),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [False] * R
inds = [Index(charges[n], flows[n]) for n in range(R)]
A = BlockSparseTensor.random(
inds + [i.copy().flip_flow() for i in inds], dtype=dtype)
dims = np.prod(Ds)
A = A.reshape([dims, dims])
E, V = eig(A)
A_ = V @ diag(E) @ inv(V)
np.testing.assert_allclose(A.data, A_.data)
def test_ChargeArray_transpose_data(num_charges):
Ds = np.array([8, 9, 10, 11])
order = [2, 0, 1, 3]
flows = [True, False, True, False]
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges), flows[n])
for n in range(4)
]
arr = ChargeArray.random(indices)
data = np.ascontiguousarray(np.transpose(np.reshape(arr.data, Ds), order))
arr2 = arr.transpose(order).transpose_data()
data3 = np.reshape(arr2.data, Ds[order])
np.testing.assert_allclose(data, data3)
np.testing.assert_allclose(arr2.shape, Ds[order])
np.testing.assert_allclose(arr2._order, [[0], [1], [2], [3]])
np.testing.assert_allclose(arr2.flows, [[True], [True], [False], [False]])
def test_fromdense(num_charges, chargetype):
np.random.seed(10)
Ds = [8, 9, 10, 11]
rank = 4
flows = np.random.choice([True, False], size=rank, replace=True)
charges = [get_charge(chargetype, num_charges, Ds[n]) for n in range(rank)]
fused = fuse_charges(charges, flows)
mask = fused == np.zeros((num_charges, 1))
inds = np.nonzero(mask)[0]
inds2 = np.nonzero(np.logical_not(mask))[0]
indices = [Index(charges[n], flows[n]) for n in range(rank)]
dense = np.random.random_sample(Ds)
arr = BlockSparseTensor.fromdense(indices, dense)
dense_arr = arr.todense()
np.testing.assert_allclose(np.ravel(dense)[inds], arr.data)
np.testing.assert_allclose(np.ravel(dense_arr)[inds2], 0)
def test_item():
t1 = BlockSparseTensor(
data=np.array(1.0),
charges=[],
flows=[],
order=[],
check_consistency=False)
assert t1.item() == 1
Ds = [10, 11, 12, 13]
charges = [U1Charge.random(Ds[n], -5, 5) for n in range(4)]
flows = [True, False, True, False]
inds = [Index(c, flows[n]) for n, c in enumerate(charges)]
t2 = BlockSparseTensor.random(inds, dtype=np.float64)
with pytest.raises(
ValueError,
match="can only convert an array of"
" size 1 to a Python scalar"):
t2.item()
def test_qr_raises():
np.random.seed(10)
dtype = np.float64
num_charges = 1
Ds = [20, 21]
R1 = 1
R = len(Ds)
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
d1 = np.prod(Ds[:R1])
d2 = np.prod(Ds[R1:])
A = A.reshape([d1, d2])
with pytest.raises(ValueError):
qr(A, mode='fake_mode')
def test_broadcast_right_multiplication(dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
Ds = [10, 30, 24]
R = len(Ds)
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (Ds[n], num_charges)),
charge_types=[U1Charge] * num_charges), False)
for n in range(R)
]
tensor1 = backend.randn(indices, dtype=dtype)
tensor2 = ChargeArray.random(indices=[indices[-1].copy().flip_flow()],
dtype=dtype)
t1dense = tensor1.todense()
t2dense = tensor2.todense()
out = backend.broadcast_right_multiplication(tensor1, tensor2)
dense = t1dense * t2dense
np.testing.assert_allclose(out.todense(), dense)
def test_qr_r_mode():
Ds = [10, 11]
dtype = np.float64
np.random.seed(10)
rank = len(Ds)
charges = [
BaseCharge(np.zeros((Ds[n], 1)), charge_types=[U1Charge] * 1)
for n in range(rank)
]
flows = [True] * rank
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(rank)], dtype=dtype)
d1 = np.prod(Ds[:1])
d2 = np.prod(Ds[1:])
A = A.reshape([d1, d2])
R = qr(A, mode='r')
R_np = np.linalg.qr(A.todense(), mode='r')
np.testing.assert_allclose(np.abs(np.diag(R.todense())),
np.abs(np.diag(R_np)))
def test_qr_prod(dtype, Ds, R1, mode, num_charges):
np.random.seed(10)
R = len(Ds)
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
d1 = np.prod(Ds[:R1])
d2 = np.prod(Ds[R1:])
A = A.reshape([d1, d2])
Q, R = qr(A, mode=mode)
A_ = Q @ R
assert A_.dtype == A.dtype
np.testing.assert_allclose(A.data, A_.data)
for n in range(len(A._charges)):
assert charge_equal(A_._charges[n], A._charges[n])
def test_BlockSparseTensor_contiguous_3():
Ds = [10, 11, 12, 13]
charges = [U1Charge.random(Ds[n], -5, 5) for n in range(4)]
flows = [True, False, True, False]
inds = [Index(c, flows[n]) for n, c in enumerate(charges)]
a = BlockSparseTensor.random(inds, dtype=np.float64)
order_a = [0, 3, 1, 2]
a = a.transpose(order_a)
adense = a.todense()
order_b = [0, 2, 1, 3]
b = BlockSparseTensor.random([inds[n] for n in order_b], dtype=np.float64)
b = b.transpose([0, 3, 2, 1])
b.contiguous([0, 2, 1, 3], inplace=True)
bdense = b.todense()
c = a + b
cdense = c.todense()
np.testing.assert_allclose(a.flows, b.flows)
np.testing.assert_allclose(a.flows, b.flows)
np.testing.assert_allclose(adense + bdense, cdense)
def test_broadcast_left_multiplication(dtype, num_charges):
np.random.seed(10)
backend = symmetric_backend.SymmetricBackend()
Ds = [10, 30, 24]
R = len(Ds)
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges), False)
for n in range(R)
]
tensor1 = ChargeArray.random(indices=[indices[0]], dtype=dtype)
tensor2 = backend.randn(indices, dtype=dtype)
t1dense = tensor1.todense()
t2dense = tensor2.todense()
out = backend.broadcast_left_multiplication(tensor1, tensor2)
dense = np.reshape(t1dense, (10, 1, 1)) * t2dense
np.testing.assert_allclose(out.todense(), dense)
def test_svd_singvals(dtype, Ds, R1, num_charges):
np.random.seed(10)
R = len(Ds)
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
d1 = np.prod(Ds[:R1])
d2 = np.prod(Ds[R1:])
A = A.reshape([d1, d2])
_, S1, _ = svd(A, full_matrices=False)
S2 = svd(A, full_matrices=False, compute_uv=False)
np.testing.assert_allclose(S1.data, S2.data)
Sdense = np.linalg.svd(A.todense(), compute_uv=False)
np.testing.assert_allclose(np.sort(Sdense[Sdense > 1E-15]),
np.sort(S2.data[S2.data > 0.0]))
def test_svd_prod(dtype, Ds, R1, num_charges):
np.random.seed(10)
R = len(Ds)
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, Ds[n])),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
A = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
d1 = np.prod(Ds[:R1])
d2 = np.prod(Ds[R1:])
A = A.reshape([d1, d2])
U, S, V = svd(A, full_matrices=False)
A_ = U @ diag(S) @ V
assert A_.dtype == A.dtype
np.testing.assert_allclose(A.data, A_.data)
for n in range(len(A._charges)):
assert charge_equal(A_._charges[n], A._charges[n])
def test_max_singular_values_larger_than_bond_dimension(dtype, num_charges):
np.random.seed(10)
R = 2
D = 30
charges = [
BaseCharge(np.random.randint(-5, 6, (num_charges, D)),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
random_matrix = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
U, S, V = bs.svd(random_matrix, full_matrices=False)
S.data = np.array(range(len(S.data)))
val = U @ bs.diag(S) @ V
_, S2, _, _ = decompositions.svd_decomposition(bs,
val,
1,
max_singular_values=40)
assert S2.shape == S.shape
def test_add_sub_raises(op):
np.random.seed(10)
Ds1 = [3, 4, 5, 6]
Ds2 = [4, 5, 6, 7]
indices1 = [
Index(U1Charge.random(dimension=Ds1[n], minval=-5, maxval=5), False)
for n in range(4)
]
indices2 = [
Index(U1Charge.random(dimension=Ds2[n], minval=-5, maxval=5), False)
for n in range(4)
]
a = BlockSparseTensor.randn(indices1)
b = BlockSparseTensor.randn(indices2)
with pytest.raises(TypeError):
op(a, np.array([1, 2, 3]))
with pytest.raises(ValueError):
op(a, b)
Ds3 = [3, 3, 3, 3]
Ds4 = [9, 9]
indices3 = [
Index(U1Charge.random(dimension=Ds3[n], minval=-5, maxval=5), False)
for n in range(4)
]
indices4 = [
Index(U1Charge.random(dimension=Ds4[n], minval=-5, maxval=5), False)
for n in range(2)
]
c = BlockSparseTensor.randn(indices3).reshape([9, 9])
d = BlockSparseTensor.randn(indices4)
with pytest.raises(ValueError):
op(c, d)
Ds5 = [200, 200]
Ds6 = [200, 200]
indices5 = [
Index(U1Charge.random(dimension=Ds5[n], minval=-5, maxval=5), False)
for n in range(2)
]
indices6 = [
Index(U1Charge.random(dimension=Ds6[n], minval=-5, maxval=5), False)
for n in range(2)
]
e = BlockSparseTensor.randn(indices5)
f = BlockSparseTensor.randn(indices6)
with pytest.raises(ValueError):
op(e, f)
def test_like_init(fun, val, dtype, num_charges):
np.random.seed(10)
Ds = [8, 9, 10, 11]
rank = 4
flows = np.random.choice([True, False], size=rank, replace=True)
indices = [
Index(
BaseCharge(np.random.randint(-5, 6, (Ds[n], num_charges)),
charge_types=[U1Charge] * num_charges), flows[n])
for n in range(rank)
]
arr = randn(indices, dtype=dtype)
arr2 = fun(arr)
assert arr.dtype == arr2.dtype
np.testing.assert_allclose(arr.shape, arr2.shape)
np.testing.assert_allclose(arr.flat_flows, arr2.flat_flows)
for n in range(4):
assert charge_equal(arr.charges[n][0], arr2.charges[n][0])
if val is not None:
np.testing.assert_allclose(arr2.data, val)
def test_eigh_prod(dtype, Ds, num_charges):
np.random.seed(10)
R = len(Ds)
charges = [
BaseCharge(
np.random.randint(-5, 6, (num_charges, Ds[n]), dtype=np.int16),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [False] * R
inds = [Index(charges[n], flows[n]) for n in range(R)]
A = BlockSparseTensor.random(
inds + [i.copy().flip_flow() for i in inds], dtype=dtype)
dims = np.prod(Ds)
A = A.reshape([dims, dims])
B = A + A.T.conj()
E, V = eigh(B)
B_ = V @ diag(E) @ V.conj().T
np.testing.assert_allclose(B.data, B_.data)
for n in range(len(B._charges)):
assert charge_equal(B_._charges[n], B._charges[n])
def test_index_eq():
q1 = U1Charge(np.array([-1, -2, 0, 8, 7]))
q2 = U1Charge(np.array([-1, -2, 0, 8, 7]))
q3 = U1Charge(np.array([-1, 0, 8, 7]))
i1 = Index(charges=q1, flow=False)
i2 = Index(charges=q2, flow=False)
i3 = Index(charges=q3, flow=False)
i4 = Index(charges=[q1, q2], flow=[False, True])
i5 = Index(charges=[q1, q2], flow=[False, True])
i6 = Index(charges=[q1, q2], flow=[False, False])
assert i1 == i2
assert i1 != i3
assert i1 != i4
assert i4 == i5
assert i5 != i6
def test_ChargeArray_arithmetic_raises():
np.random.seed(10)
dtype = np.float64
D = 10
rank = 3
charges = [U1Charge.random(D, -2, 2) for _ in range(rank)]
flows = np.random.choice([True, False], size=rank, replace=True)
inds = [Index(c, f) for c, f in zip(charges, flows)]
T = ChargeArray.random(inds, dtype=dtype)
with pytest.raises(NotImplementedError):
T - T
with pytest.raises(NotImplementedError):
T + T
with pytest.raises(NotImplementedError):
-T
with pytest.raises(NotImplementedError):
T * 5
with pytest.raises(NotImplementedError):
5 * T
with pytest.raises(NotImplementedError):
T / 5
def test_tn_transpose_reshape(): np.random.seed(10) Ds = np.array([8, 9, 10, 11]) flows = [True, False, True, False] indices = [Index(U1Charge.random(-5, 5, Ds[n]), flows[n]) for n in range(4)] arr = BlockSparseTensor.random(indices) arr2 = transpose(arr, [2, 0, 1, 3]) arr3 = reshape(arr2, [80, 99]) np.testing.assert_allclose(arr3.shape, [80, 99]) np.testing.assert_allclose(arr3._order, [[2, 0], [1, 3]]) np.testing.assert_allclose(arr3.flows, [[True, True], [False, False]]) arr4 = transpose(arr3, [1, 0]) np.testing.assert_allclose(arr4.shape, [99, 80]) np.testing.assert_allclose(arr4._order, [[1, 3], [2, 0]]) np.testing.assert_allclose(arr4.flows, [[False, False], [True, True]]) arr5 = reshape(arr4, [9, 11, 10, 8]) np.testing.assert_allclose(arr5.shape, [9, 11, 10, 8]) np.testing.assert_allclose(arr5._order, [[1], [3], [2], [0]]) np.testing.assert_allclose(arr5.flows, [[False], [False], [True], [True]])
def test_tn_reshape(dtype):
np.random.seed(10)
Ds = [8, 9, 10, 11]
indices = [Index(U1Charge.random(-5, 5, Ds[n]), False) for n in range(4)]
arr = BlockSparseTensor.random(indices, dtype=dtype)
arr2 = reshape(arr, [72, 110])
for n in range(2):
for m in range(2):
assert charge_equal(arr2.charges[n][m], indices[n * 2 + m].charges)
np.testing.assert_allclose(arr2.shape, [72, 110])
np.testing.assert_allclose(arr2._order, [[0, 1], [2, 3]])
np.testing.assert_allclose(arr2.flows, [[False, False], [False, False]])
assert arr2.ndim == 2
arr3 = reshape(arr, Ds)
for n in range(4):
assert charge_equal(arr3.charges[n][0], indices[n].charges)
np.testing.assert_allclose(arr3.shape, Ds)
np.testing.assert_allclose(arr3._order, [[0], [1], [2], [3]])
np.testing.assert_allclose(arr3.flows, [[False], [False], [False], [False]])
assert arr3.ndim == 4
def test_create_diag(dtype, num_charges):
np.random.seed(10)
D = 200
index = Index(
BaseCharge(np.random.randint(-2, 3, (num_charges, D)),
charge_types=[U1Charge] * num_charges), False)
arr = ChargeArray.random([index], dtype=dtype)
diagarr = diag(arr)
dense = np.ravel(diagarr.todense())
np.testing.assert_allclose(np.sort(dense[dense != 0.0]),
np.sort(diagarr.data[diagarr.data != 0.0]))
sparse_blocks, charges, block_shapes = _find_diagonal_sparse_blocks(
diagarr.flat_charges, diagarr.flat_flows, 1)
#in range(index._charges[0].unique_charges.shape[1]):
for n, block in enumerate(sparse_blocks):
shape = block_shapes[:, n]
block_diag = np.diag(np.reshape(diagarr.data[block], shape))
np.testing.assert_allclose(
arr.data[np.squeeze(index._charges[0] == charges[n])], block_diag)
def test_max_truncation_error(dtype, num_charges):
np.random.seed(10)
R = 2
D = 30
charges = [
BaseCharge(np.random.randint(-5, 6, (D, num_charges)),
charge_types=[U1Charge] * num_charges) for n in range(R)
]
flows = [True] * R
random_matrix = BlockSparseTensor.random(
[Index(charges[n], flows[n]) for n in range(R)], dtype=dtype)
U, S, V = bs.svd(random_matrix, full_matrices=False)
svals = np.array(range(1, len(S.data) + 1)).astype(np.float64)
S.data = svals[::-1]
val = U @ bs.diag(S) @ V
trunc = 8
mask = np.sqrt(np.cumsum(np.square(svals))) >= trunc
_, S2, _, _ = decompositions.svd(bs, val, 1, max_truncation_error=trunc)
np.testing.assert_allclose(S2.data, svals[mask][::-1])
