def test_multiply_spread(self):
a = rand_tensor([2, 2], inds=['a', 'b'], tags='A')
b = Tensor(a.data, ['b', 'c'], tags='B')
c = Tensor(a.data, ['c', 'd'], tags='C')
tn = (a | b | c)
tn.multiply_(-8j + 1 / 3, spread_over=3)
assert_allclose(tn['A'].data, tn['B'].data)
assert_allclose(tn['B'].data, tn['C'].data)
def test_contract_with_wild_mix(self):
a = Tensor(np.random.randn(2, 3, 4), inds=['-1', 'a', 'foo'],
tags='red')
b = Tensor(np.random.randn(3, 4, 5), inds=['a', 'foo', '42.42'],
tags='blue')
c = a @ b
assert c.shape == (2, 5)
assert c.inds == ('-1', '42.42')
def test_tensor_deep_copy(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2], tags='blue')
b = a.copy(deep=True)
b.add_tag('foo')
assert 'foo' not in a.tags
b.data[:] = b.data / 2
# still reference the same underlying array
assert_allclose(a.data / 2, b.data)
def test_contract_with_out_of_range_inds(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[-1, 100, 2200],
tags='red')
b = Tensor(np.random.randn(3, 4, 5), inds=[100, 2200, -3],
tags='blue')
c = a @ b
assert c.shape == (2, 5)
assert c.inds == (-1, -3)
def test_contract_with_legal_characters(self):
a = Tensor(np.random.randn(2, 3, 4), inds='abc',
tags='red')
b = Tensor(np.random.randn(3, 4, 5), inds='bcd',
tags='blue')
c = a @ b
assert c.shape == (2, 5)
assert c.inds == ('a', 'd')
def test_tensor_construct(self):
x = np.random.randn(2, 3, 4)
a = Tensor(x, inds=[0, 1, 2], tags='blue')
assert_allclose(a.H.data, x.conj())
assert a.size == 24
with pytest.raises(ValueError):
Tensor(x, inds=[0, 2], tags='blue')
def test_tensor_transpose(self):
a = Tensor(np.random.rand(2, 3, 4, 5, 2, 2), 'abcdef', tags={'blue'})
at = a.transpose(*'cdfeba')
assert at.shape == (4, 5, 2, 2, 3, 2)
assert at.inds == ('c', 'd', 'f', 'e', 'b', 'a')
with pytest.raises(ValueError):
a.transpose(*'cdfebz')
def test_tensor_copy(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2], tags='blue')
b = a.copy()
b.tags.add('foo')
assert 'foo' not in a.tags
b.data /= 2
# still reference the same underlying array
assert_allclose(a.data, b.data)
def test_multi_contract(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2], tags='red')
b = Tensor(np.random.randn(3, 4, 5), inds=[1, 2, 3], tags='blue')
c = Tensor(np.random.randn(5, 2, 6), inds=[3, 0, 4], tags='blue')
d = tensor_contract(a, b, c)
assert isinstance(d, Tensor)
assert d.shape == (6, )
assert d.inds == (4, )
assert d.tags == {'red', 'blue'}
def test_multiply_spread_neg_stays_real(self):
a = rand_tensor([2, 2], inds=['a', 'b'], tags='A', dtype='float32')
b = Tensor(a.data, ['b', 'c'], tags='B')
c = Tensor(a.data, ['c', 'd'], tags='C')
tn = (a | b | c)
tn.multiply_(-1000)
assert a.dtype == b.dtype == c.dtype == 'float32'
assert_allclose(abs(tn['A'].data), abs(tn['B'].data))
assert_allclose(abs(tn['B'].data), abs(tn['C'].data))
def test_set_data_in_tensor(self):
a_data = np.random.randn(2, 3, 4)
b_data = np.random.randn(2, 3, 4)
a = Tensor(a_data, inds='abc', tags={'I0'})
b = Tensor(b_data, inds='abc', tags={'I1'})
tn = TensorNetwork((a, b), structure="I{}")
assert_allclose(tn[0].data, a_data)
new_data = np.random.randn(2, 3, 4)
tn[1].modify(data=new_data)
assert_allclose(tn['I1'].data, new_data)
def test_tensor_tensor_arithmetic(self, op, mismatch):
a = Tensor(np.random.rand(2, 3, 4), inds=[0, 1, 2], tags='blue')
b = Tensor(np.random.rand(2, 3, 4), inds=[0, 1, 2], tags='red')
if mismatch:
b.modify(inds=(0, 1, 3))
with pytest.raises(ValueError):
op(a, b)
else:
c = op(a, b)
assert_allclose(c.data, op(a.data, b.data))
def test_fuse(self):
a = Tensor(np.random.rand(2, 3, 4, 5), 'abcd', tags={'blue'})
b = a.fuse({'bra': ['a', 'c'], 'ket': 'bd'})
assert set(b.shape) == {8, 15}
assert set(b.inds) == {'bra', 'ket'}
assert b.tags == {'blue'}
b = a.fuse({'ket': 'bd', 'bra': 'ac'})
assert set(b.shape) == {15, 8}
assert set(b.inds) == {'ket', 'bra'}
assert b.tags == {'blue'}
def test_index_by_site(self):
a_data = np.random.randn(2, 3, 4)
b_data = np.random.randn(2, 3, 4)
a = Tensor(a_data, inds='abc', tags={'I0'})
b = Tensor(b_data, inds='abc', tags={'I1'})
tn = TensorNetwork((a, b), structure="I{}")
assert_allclose(tn[0].data, a_data)
new_data = np.random.randn(2, 3, 4)
tn[1] = Tensor(new_data, inds='abc', tags={'I1', 'red'})
assert_allclose(tn['I1'].data, new_data)
assert 'red' in tn['I1'].tags
def test_contract_some(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2])
b = Tensor(np.random.randn(3, 4, 5), inds=[1, 2, 3])
assert a.shared_bond_size(b) == 12
c = a @ b
assert isinstance(c, Tensor)
assert c.shape == (2, 5)
assert c.inds == (0, 3)
def test_contract_None(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2])
b = Tensor(np.random.randn(3, 4, 5), inds=[3, 4, 5])
c = a @ b
assert c.shape == (2, 3, 4, 3, 4, 5)
assert c.inds == (0, 1, 2, 3, 4, 5)
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2])
b = Tensor(np.random.randn(3, 4, 5), inds=[5, 4, 3])
c = a @ b
assert c.shape == (2, 3, 4, 3, 4, 5)
assert c.inds == (0, 1, 2, 5, 4, 3)
def test_conj_inplace(self):
a_data = np.random.randn(2, 3, 4) + 1.0j * np.random.randn(2, 3, 4)
b_data = np.random.randn(3, 4, 5) + 1.0j * np.random.randn(3, 4, 5)
c_data = np.random.randn(5, 2, 6) + 1.0j * np.random.randn(5, 2, 6)
a = Tensor(a_data, inds=[0, 1, 2], tags={'red', 'I0'})
b = Tensor(b_data, inds=[1, 2, 3], tags={'blue', 'I1'})
c = Tensor(c_data, inds=[3, 0, 4], tags={'blue', 'I2'})
tn = a & b & c
tn.conj_()
for i, arr in enumerate((a_data, b_data, c_data)):
assert_allclose(tn["I{}".format(i)].data, arr.conj())
def test_with_alpha_construct(self):
x = np.random.randn(2, 3, 4)
a = Tensor(x, inds='ijk', tags='blue')
assert_allclose(a.H.data, x.conj())
assert a.size == 24
with pytest.raises(ValueError):
Tensor(x, inds='ij', tags='blue')
x = np.random.randn(2, 3, 4)
a = Tensor(x, inds=['a1', 'b2', 'c3'], tags='blue')
assert_allclose(a.H.data, x.conj())
assert a.size == 24
with pytest.raises(ValueError):
Tensor(x, inds=['ijk'], tags='blue')
def gate_split_mpo_like(TG: qtn.Tensor, up_inds, down_inds):
'''Split a 3-body gate into MPO-like chain.
-TG: qtn.Tensor
Tensor operator to split
-up_inds: ia, ib, ic
(Ordered) upper indices for sites a,b,c
-down_inds: ja, jb, jc
(Ordered) lower indices on sites a, b, c
Returns:
-(T_a, T_b, T_c): sequence of tensors, 1 for each site
#
# ia ib ic ia ib ic
# \│╱ │ │ │
# G = ● ==> ●────●────●
# ╱|\ │ │ │
# ja jb jc ja jb jc
#
'''
ia, ib, ic = up_inds
ja, jb, jc = down_inds
T_a, V = TG.split(left_inds=(ia, ja), method='qr', get='tensors')
T_b, T_c = V.split(left_inds=(ib, jb),
right_inds=(ic, jc),
method='qr',
get='tensors')
return T_a, T_b, T_c
def test_conj(self):
a_data = np.random.randn(2, 3, 4) + 1.0j * np.random.randn(2, 3, 4)
b_data = np.random.randn(3, 4, 5) + 1.0j * np.random.randn(3, 4, 5)
c_data = np.random.randn(5, 2, 6) + 1.0j * np.random.randn(5, 2, 6)
a = Tensor(a_data, inds=[0, 1, 2], tags={'red', '0'})
b = Tensor(b_data, inds=[1, 2, 3], tags={'blue', '1'})
c = Tensor(c_data, inds=[3, 0, 4], tags={'blue', '2'})
tn = a & b & c
new_tn = tn.conj()
for i, arr in enumerate((a_data, b_data, c_data)):
assert_allclose(new_tn[str(i)].data, arr.conj())
# make sure original network unchanged
for i, arr in enumerate((a_data, b_data, c_data)):
assert_allclose(tn[str(i)].data, arr)
def test_diagonal_reduce(self):
A = rand_tensor([2, 2], 'ab', dtype=complex)
B = Tensor([[3j, 0.], [0., 4j]], 'bc')
C = rand_tensor([2, 2], 'ca', dtype=complex)
tn = A & B & C
tn_s = tn.diagonal_reduce()
assert tn.num_indices == 3
assert tn_s.num_indices == 2
assert tn ^ all == pytest.approx(tn_s.contract(all, output_inds=[]))
def test_reindex(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2], tags='red')
b = Tensor(np.random.randn(3, 4, 5), inds=[1, 2, 3], tags='blue')
c = Tensor(np.random.randn(5, 2, 6), inds=[3, 0, 4], tags='green')
a_b_c = (a & b & c)
d = a_b_c.reindex({4: 'foo', 2: 'bar'})
assert a_b_c.outer_inds() == (4, )
assert d.outer_inds() == ('foo', )
assert set(a_b_c.inner_inds()) == {0, 1, 2, 3}
assert set(d.inner_inds()) == {0, 1, 'bar', 3}
assert d.tensors[0].inds == (0, 1, 'bar')
d = a_b_c.reindex_({4: 'foo', 2: 'bar'})
assert a_b_c.outer_inds() == ('foo', )
assert set(d.inner_inds()) == {0, 1, 'bar', 3}
assert d.tensors[0].inds == (0, 1, 'bar')
def test_arithmetic_scalar(self):
x = np.random.randn(2, 3, 4)
a = Tensor(x, inds=[0, 1, 2], tags='blue')
assert_allclose((a + 2).data, x + 2)
assert_allclose((a - 3).data, x - 3)
assert_allclose((a * 4).data, x * 4)
assert_allclose((a / 5).data, x / 5)
assert_allclose((a**2).data, x**2)
assert_allclose((2 + a).data, 2 + x)
assert_allclose((3 - a).data, 3 - x)
assert_allclose((4 * a).data, 4 * x)
assert_allclose((5 / a).data, 5 / x)
assert_allclose((5**a).data, 5**x)
def test_antidiag_gauge(self):
A = rand_tensor([2, 2], 'ab', dtype=complex)
B = Tensor([[0., 3j], [4j, 0.]], 'bc')
C = rand_tensor([2, 2], 'ca', dtype=complex)
tn = A & B & C
assert tn.num_indices == 3
# can't use diagonal reduction yet
assert tn.diagonal_reduce().num_indices == 3
# initial gauge doesn't change indices
tn_a = tn.antidiag_gauge()
assert tn_a.num_indices == 3
# but allows the diagonal reduction
tn_ad = tn_a.diagonal_reduce()
assert tn_ad.num_indices == 2
assert tn ^ all == pytest.approx(tn_ad.contract(all, output_inds=[]))
def test_fuse_leftover(self):
a = Tensor(np.random.rand(2, 3, 4, 5, 2, 2), 'abcdef', tags={'blue'})
b = a.fuse({'bra': 'ac', 'ket': 'bd'})
assert b.shape == (8, 15, 2, 2)
assert b.inds == ('bra', 'ket', 'e', 'f')
assert b.tags == {'blue'}
def test_tensor_conj_inplace(self):
data = np.random.rand(2, 3, 4) + 1.0j * np.random.rand(2, 3, 4)
a = Tensor(data, inds=[0, 1, 2], tags='blue')
a.conj_()
assert_allclose(data.conj(), a.data)
def test_contract_all(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2])
b = Tensor(np.random.randn(3, 4, 2), inds=[1, 2, 0])
c = a @ b
assert isinstance(c, float)
assert not isinstance(c, Tensor)
def test_raise_on_triple_inds(self):
a = Tensor(np.random.randn(2, 3, 4), inds=[0, 1, 2])
b = Tensor(np.random.randn(3, 4, 5), inds=[1, 1, 2])
with pytest.raises(ValueError):
a @ b
def test_singular_values(self, method):
psim = Tensor(np.eye(2) * 2**-0.5, inds='ab')
assert_allclose(psim.H @ psim, 1.0)
assert_allclose(
psim.singular_values('a', method=method)**2, [0.5, 0.5])
def test_entropy(self, method):
psim = Tensor(np.eye(2) * 2**-0.5, inds='ab')
assert_allclose(psim.H @ psim, 1.0)
assert_allclose(psim.entropy('a', method=method)**2, 1)
