The Wolfram TensorNetworks paclet provides a general framework for Tensor Networks in the Wolfram Language. It integrates the Cotengra library (written in Rust) for high-performance contraction path optimization.

The paclet is available from the Wolfram Paclet Repository: Wolfram/TensorNetworks

You can install the latest development version directly from the cloud:

PacletInstall["https://www.wolframcloud.com/obj/wolframquantumframework/TensorNetworks.paclet"]

To install from the source code locally:

1. Clone the repository.
2. Load the paclet directory:

PacletDirectoryLoad["paclet_path"]
Needs["Wolfram`TensorNetworks`"]

(*generate a TN based on a graph with tensors being generated randomly*)
net = RandomTensorNetwork[StarGraph[5], Method -> "RandomComplex"];

(*contract TN with global indices in TensorContract*)
TensorNetworkContract[net]

(*find a contraction path using Cotengra*)
path = TensorNetworkFindContractionPath[net]

(*given different methods for contraction, perform path-dependent contraction*)
ActivateTensors /@ AssociationMap[
    TensorNetworkContraction[net, path, 
        Method -> #] &, $TensorNetworkContractionMethods]

This section provides comprehensive documentation for all public functions.

Creates a tensor network object with a summary box display.

Creates random tensor networks of various architectures.

Options:

• Method → Automatic — "Complex" for complex-valued tensors
• "Boundary" → "Open" — "Periodic" for periodic boundary conditions

Indices matching existing network indices create new contractions.

Options:

• Method → "Symbolic" — uses symbolic tensor representations

Contracts the tensor network to a single tensor.

Returns an evaluated numerical tensor (not symbolic).

Returns a symbolic contraction expression.

Options:

• Method → "ArrayDot" — contraction method ("ArrayDotTranspose", "ArrayDot", "Dot", "TensorContract", "TableSum")
• "Inactive" → True — returns inactive expressions

List of available contraction methods: "ArrayDotTranspose", "ArrayDot", "Dot", "TensorContract", "TableSum".

Transforms an MPS into canonical form.

Uses tolerance 10⁻¹⁰ for numerical comparison.

The second MPS is conjugated. MPSOverlap[mps, mps] returns the squared norm.

Equivalent to Sqrt[Abs[MPSOverlap[mps, mps]]].

The physical state is preserved; only the overall scale factor changes.

Returns 0 for product states, log(D) for maximally entangled states with bond dimension D. Uses natural logarithm.

Values satisfy ∑ λᵢ² = 1. Number of values equals the bond dimension at that cut.

Result is in left-canonical form. Truncation error depends on discarded singular values.

Contracts tensors according to index specification.

Returns {indices, tensor} where tensor is the joined result.

Converts symbolic tensor expressions to evaluated numerical tensors.

Arguments:

• inputs — list of index lists for each tensor
• output — list of indices for the final result
• sizeDict — Association mapping indices to dimensions

Optional: costMod, temperature, maxNeighbors, seed, simplify, useSSA

Optional: minimize, costCap, searchOuter, simplify, useSSA

(* Matrix Product State: 10 sites, bond dimension 4, physical dimension 2 *)
mps = RandomTensorNetwork["MPS"[10, 4, 2]]

(* Tensor Train: 8 sites, bond dimension 3 *)
tt = RandomTensorNetwork["TT"[8, 3]]

(* Matrix Product Operator: 6 sites, bond dimension 3, physical dimension 2 *)
mpo = RandomTensorNetwork["MPO"[6, 3, 2]]

(* PEPS: 4×4 grid, bond dimension 3, physical dimension 2 *)
peps = RandomTensorNetwork["PEPS"[{4, 4}, 3, 2]]

(* Tree Tensor Network: depth 3, bond dimension 4, branching 2 *)
ttn = RandomTensorNetwork["TTN"[3, 4, 2]]

(* MERA: width 4, bond dimension 4, 2 layers *)
mera = RandomTensorNetwork["MERA"[4, 4, 2]]

(* Create and canonicalize an MPS *)
mps = RandomTensorNetwork["MPS"[10, 4, 2]]
canonical = MPSCanonicalForm[mps, "Left"]

(* Check canonicality *)
MPSCanonicalQ[canonical, "Left"]  (* True *)

(* Compute norm and normalize *)
norm = MPSNorm[mps]
normalized = MPSNormalize[mps]

(* Compute entanglement entropy at site 5 *)
entropy = MPSEntanglementEntropy[normalized, 5]

(* Truncate to smaller bond dimension *)
truncated = MPSTruncate[mps, 2]

(* Matrix multiplication: C = A.B *)
A = RandomReal[1, {3, 4}];
B = RandomReal[1, {4, 5}];
C = EinsteinSummation[{{i, k}, {k, j}} -> {i, j}, {A, B}]

(* Trace: Tr[A] *)
M = RandomReal[1, {4, 4}];
trace = EinsteinSummation[{{i, i}}, {M}]

(* String notation *)
result = EinsteinSummation["ij,jk->ik", {A, B}]