def _create_tensor(self, l1: int, l2: int) -> Tensor:
name_list = ["Left", "Right", "Up", "Down"]
if l1 == 0:
name_list.remove("Up")
if l2 == 0:
name_list.remove("Left")
if l1 == self.L1 - 1:
name_list.remove("Down")
if l2 == self.L2 - 1:
name_list.remove("Right")
dimension_list = [2, *[self.D for _ in name_list]]
name_list = ["Phy", *name_list]
result = Tensor(name_list, dimension_list)
result.block()[:] = np.random.rand(*dimension_list)
return result
def __init__(self, node_names, approximate_energy=0):
self.node_number = len(node_names)
self.state_vector = Tensor(node_names,
[2
for _ in range(self.node_number)]).randn()
self.bonds = []
self.energy = 0.
self.approximate_energy = abs(approximate_energy)
class SpinLattice():
def __init__(self, node_names, approximate_energy=0):
self.node_number = len(node_names)
self.state_vector = Tensor(node_names,
[2
for _ in range(self.node_number)]).randn()
self.bonds = []
self.energy = 0.
self.approximate_energy = abs(approximate_energy)
def update(self):
norm_max = float(self.state_vector.norm_max())
self.energy = self.approximate_energy - norm_max
self.state_vector /= norm_max
state_vector_temporary = self.state_vector.same_shape().zero()
for i in self.bonds:
sn1, sn2 = (j for j in i.name if j.name[0] != "_")
this_term = self.state_vector.contract_all_edge(i).edge_rename({
f"_{sn1}":
sn1,
f"_{sn2}":
sn2
})
state_vector_temporary += this_term
self.state_vector *= self.approximate_energy
self.state_vector -= state_vector_temporary # v <- (1-H)v
def observe(self, operator):
names = [i.name for i in operator.name if i.name[0] != "_"]
Ov = self.state_vector.to(complex).contract_all_edge(
operator).edge_rename({f"_{n}": n
for n in names})
vOv = Ov.contract_all_edge(self.state_vector.to(complex))
vv = self.state_vector.contract_all_edge(self.state_vector)
return complex(vOv).real / float(vv)
def set_bond(self, ps, operator):
self.bonds.append(translate(ps, operator))
# print(fuse_leg_A)
# print(fuse_leg_B)
name_list_A = [f"A.{i}" for i in range(rank_A)]
name_list_B = [f"B.{i}" for i in range(rank_B)]
for i in range(rank_fuse):
name_list_A[fuse_leg_A[i]] = f"{i}"
name_list_B[fuse_leg_B[i]] = f"{i}"
dim_A = np.random.randint(1, max_random, rank_A).tolist()
dim_B = np.random.randint(1, max_random, rank_B).tolist()
for i in range(rank_total):
dim_A[total_leg_A[i]] = dim_B[total_leg_B[i]] = np.random.randint(
2, max_random)
A = Tensor(name_list_A, dim_A).test()
B = Tensor(name_list_B, dim_B).test()
C = A.contract(
B, {(f"A.{contract_leg_A[i]}", f"B.{contract_leg_B[i]}")
for i in range(rank_contract)})
# print(repr(A))
# print(repr(B))
# print(repr(C))
a = A.block[{}]
b = B.block[{}]
index_A = [chr(ord('a') + i) for i in range(rank_A)]
index_B = [chr(ord('A') + i) for i in range(rank_B)]
index_C = []
for i in range(rank_total):
index_A[total_leg_A[i]] = index_B[total_leg_B[i]]
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
import numpy as np
from TAT.Tensor import DNo as Tensor
max_random = 8
for _ in range(100):
rank_A = np.random.randint(2, max_random)
rank_B = np.random.randint(2, max_random)
rank_contract = np.random.randint(1, np.min([rank_A, rank_B]))
# print(rank_A, rank_B, rank_contract)
contract_name_A = np.random.choice(range(rank_A), rank_contract, False)
contract_name_B = np.random.choice(range(rank_B), rank_contract, False)
dim_A = np.random.randint(1, max_random, size=rank_A)
dim_B = np.random.randint(1, max_random, size=rank_B)
dim_contract = np.random.randint(1, max_random, size=rank_contract)
dim_A = [j if i not in contract_name_A else dim_contract[contract_name_A.tolist().index(i)] for i, j in enumerate(dim_A)]
dim_B = [j if i not in contract_name_B else dim_contract[contract_name_B.tolist().index(i)] for i, j in enumerate(dim_B)]
A = Tensor([f"A.{i}" for i in range(rank_A)], dim_A).randn()
B = Tensor([f"B.{i}" for i in range(rank_B)], dim_B).randn()
v_t = A.contract(B, {(f"A.{i}", f"B.{j}") for i, j in zip(contract_name_A, contract_name_B)}).block[{}]
v_n = np.tensordot(A.block[{}], B.block[{}], [contract_name_A, contract_name_B])
v_d = v_t - v_n
print(np.max(np.abs(v_d)))
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
import numpy as np
from TAT.Tensor import DNo as Tensor
max_random = 8
for _ in range(1000):
rank_A = np.random.randint(2, max_random)
rank_contract = np.random.randint(1, rank_A)
U_leg = np.random.choice(range(rank_A), rank_contract, False)
dim_A = np.random.randint(1, max_random, size=rank_A)
A = Tensor([f"A.{i}" for i in range(rank_A)], dim_A.tolist()).randn()
U, S, V = A.svd({f"A.{i}" for i in U_leg}, "SVD.U", "SVD.V")
re_A = U.multiple(S, "SVD.U", "U").contract(V, {("SVD.U", "SVD.V")})
diff = re_A - A
UTU = U.contract_all_edge(U.edge_rename({"SVD.U": "new"})).block[{}]
VTV = V.contract_all_edge(V.edge_rename({"SVD.V": "new"})).block[{}]
diff_U = UTU - np.identity(len(UTU))
diff_V = VTV - np.identity(len(VTV))
print(np.max([diff.norm_max(), np.max(np.abs(diff_U)), np.max(np.abs(diff_V))]))
for _ in range(1000):
rank_A = np.random.randint(3, max_random)
rank_trace = np.random.randint(1, rank_A // 2 + 1)
pair_leg = np.random.choice(range(rank_A), [rank_trace, 2], False)
name_list = [f"A.{i}" for i in range(rank_A)]
dim_list = np.random.randint(2, max_random, rank_A)
dim_trace = np.random.randint(2, max_random, rank_trace)
for i, (j, k) in enumerate(pair_leg):
dim_list[j] = dim_trace[i]
dim_list[k] = dim_trace[i]
trace_conf = {(f"A.{i}", f"A.{j}") for i, j in pair_leg}
A = Tensor(name_list, dim_list.tolist()).test()
B = A.trace(trace_conf)
res = A.block[{}]
for i in range(rank_trace):
res = res.trace(0, pair_leg[i, 0], pair_leg[i, 1])
for j in range(i + 1, rank_trace):
if pair_leg[j, 0] > pair_leg[i, 0]:
pair_leg[j, 0] -= 1
if pair_leg[j, 1] > pair_leg[i, 0]:
pair_leg[j, 1] -= 1
if pair_leg[i, 1] > pair_leg[i, 0]:
pair_leg[i, 1] -= 1
if pair_leg[j, 0] > pair_leg[i, 1]:
pair_leg[j, 0] -= 1
if pair_leg[j, 1] > pair_leg[i, 1]: