import numpy as np import time from TNR.Models.isingModel import IsingSpinGlass from TNR.Contractors.mergeContractor import mergeContractor from TNR.Contractors.heuristics import loopHeuristic as heuristic from TNR.Utilities.logger import makeLogger from TNR import config logger = makeLogger(__name__, config.levels['generic']) def isingFreeEnergy(nX, J, k, accuracy): n = IsingSpinGlass(nX, J, k, accuracy) n = mergeContractor(n, accuracy, heuristic, optimize=True, merge=False, plot=False) return n.array[1] / (nX) J = 1 accuracy = 1e-3 size = list(range(4, 10)) k = 1.5 res = [] for s in size:
import numpy as np import operator from TNR.Network.network import Network from TNR.Network.node import Node from TNR.Network.bucket import Bucket from TNR.Network.link import Link from TNR.Tensor.arrayTensor import ArrayTensor from TNR.Utilities.svd import entropy, splitArray import sys sys.setrecursionlimit(10000) from TNR.Utilities.logger import makeLogger from TNR import config logger = makeLogger(__name__, config.levels['treeNetwork']) class TreeNetwork(Network): ''' A treeNetwork is a special case of a Network in which the Network being represented contains no cycles. This allows matrix elements of a treeNetwork to be efficiently evaluated. As the only quantities which matter are the matrix elements, the treeNetwork may refactor itself through singular value decomposition (SVD) to minimize memory use, and so no assumptions should be made about the Nodes in this object, just the external Buckets. Internally all Nodes of a treeNetwork have Tensors of rank at most 3. SVD factoring is used to enforce this.
import numpy as np from numpy.linalg import svd from scipy.linalg.interpolative import svd as svdI from scipy.sparse.linalg import aslinearoperator from scipy.sparse.linalg import LinearOperator from scipy.sparse.linalg import svds from itertools import combinations from TNR.Utilities.arrays import permuteIndices from TNR.Utilities.linalg import adjoint from TNR.Utilities.logger import makeLogger from TNR import config logger = makeLogger(__name__, config.levels['svd']) ################################### # Linear Operator and SVD Functions ################################### def matrixProductLinearOperator(matrix1, matrix2): ''' The reason we implement our own function here is that the dot product associated with the standard LinearOperator class has an extremely slow type-checking stage which has to be performed every time a product is calculated. ''' if matrix1.shape[0] < matrix1.shape[1] or matrix2.shape[1] < matrix2.shape[ 0]: return np.dot(matrix1, matrix2)
from TNR.Tensor.tensor import Tensor from TNR.Tensor.arrayTensor import ArrayTensor from TNR.Network.treeNetwork import TreeNetwork from TNR.Network.node import Node from TNR.Network.link import Link from TNR.Network.bucket import Bucket from TNR.Network.traceMin import traceMin from TNR.Utilities.svd import entropy from TNR.Utilities.graphPlotter import makePlotter counter0 = 0 from TNR.Utilities.logger import makeLogger from TNR import config logger = makeLogger(__name__, config.levels['treeTensor']) class TreeTensor(Tensor): def __init__(self, accuracy): self.accuracy = accuracy self.network = TreeNetwork(accuracy=accuracy) self.externalBuckets = [] self.optimized = set() def addTensor(self, tensor): n = Node(tensor, Buckets=[Bucket() for _ in range(tensor.rank)]) self.network.addNode(n) self.externalBuckets.extend(n.buckets) if tensor.rank > 3: self.network.splitNode(n)
from collections import defaultdict import networkx import numpy as np import operator from collections import Counter from scipy.sparse.csgraph import shortest_path from scipy.sparse import csr_matrix from TNR.Utilities.logger import makeLogger from TNR import config logger = makeLogger(__name__, config.levels['traceMin']) def hortonGraph(adj, s): ''' adj - Adjacency matrix for the original graph s - Set of edges which will cross over between the two copies of the original graph Edges are stored as tuples of indices. ''' adjH = np.zeros((2 * len(adj), 2 * len(adj))) adjH[:len(adj), :len(adj)] = adj adjH[len(adj):, len(adj):] = adj for e in s: i, j = e ip = i + len(adj) jp = j + len(adj) adjH[ip, j] = adj[i, j] adjH[j, ip] = adj[j, i]