Wolfram Language Paclet Repository

Community-contributed installable additions to the Wolfram Language

Primary Navigation

    • Cloud & Deployment
    • Core Language & Structure
    • Data Manipulation & Analysis
    • Engineering Data & Computation
    • External Interfaces & Connections
    • Financial Data & Computation
    • Geographic Data & Computation
    • Geometry
    • Graphs & Networks
    • Higher Mathematical Computation
    • Images
    • Knowledge Representation & Natural Language
    • Machine Learning
    • Notebook Documents & Presentation
    • Scientific and Medical Data & Computation
    • Social, Cultural & Linguistic Data
    • Strings & Text
    • Symbolic & Numeric Computation
    • System Operation & Setup
    • Time-Related Computation
    • User Interface Construction
    • Visualization & Graphics
    • Random Paclet
    • Alphabetical List
  • Using Paclets
    • Get Started
    • Download Definition Notebook
  • Learn More about Wolfram Language

TensorNetworks

Guides

  • TensorNetworks

Tech Notes

  • Building Tensor Networks
  • Contraction Paths and Execution
  • Matrix Product States
  • A Working Tour of the Symmetry Functions
  • Tensor Networks Overview
  • Young Tableaux and Tensor Symmetries

Symbols

  • ActivateTensors
  • BinaryTensorNetwork
  • BinaryTensorNetworkQ
  • CanonicalPath
  • CanonicalPathQ
  • ContractIndices
  • ContractionTree
  • EinsteinSummation
  • GreedyContractionPath
  • HookFactor
  • HookLength
  • HookLengths
  • IndexedMultiply
  • InitializeTensorNetwork
  • MetricTensor
  • MetricTensorQ
  • MPSCanonicalForm
  • MPSCanonicalQ
  • MPSEntanglementEntropy
  • MPSNormalize
  • MPSNorm
  • MPSOverlap
  • MPSSchmidtValues
  • MPSTruncate
  • OptimalContractionPath
  • PartitionQ
  • PathIndexContractions
  • PathQ
  • PathToTreePath
  • RandomTensorNetwork
  • SchurDimension
  • SparseTensorNetwork
  • TableauColumns
  • TableauDimension
  • TableauRows
  • TableauShape
  • TableauSize
  • TableauWeylDimension
  • TensorNetworkAdd
  • TensorNetworkContraction
  • TensorNetworkContractions
  • TensorNetworkContract
  • TensorNetworkData
  • TensorNetworkDelete
  • TensorNetworkFreeIndices
  • TensorNetworkGraphData
  • TensorNetworkGraphQ
  • TensorNetworkIndexDimensions
  • TensorNetworkIndexGraph
  • TensorNetworkIndices
  • TensorNetwork
  • TensorNetworkQ
  • TensorNetworkRemoveCycles
  • TensorNetworkReplaceIndices
  • TensorNetworkSize
  • TensorNetworkTensors
  • TensorNetworkToNetGraph
  • ToTensorNetworkGraph
  • TransposePartition
  • TreePathQ
  • TreePathToPath
  • YoungProject
  • YoungSymmetrize
  • YoungTableau
  • YoungTableauQ
Young Tableaux and Tensor Symmetries
The symmetric group
S
n
acts on a rank-
n
tensor by permuting its slots, and the resulting representation splits into a direct sum of irreducibles labelled by Young tableaux. The
Wolfram`TensorNetworks`Symmetry`
subpackage exposes the combinatorial layer (tableaux, hook lengths, dimensions) together with the projectors that decompose a tensor into its irreducible pieces. This tutorial walks through the data structure, the hook-length formula, and the Young projector on small explicit examples.
In[2]:=
Needs["Wolfram`TensorNetworks`"]
In[3]:=
Needs["Wolfram`TensorNetworks`Symmetry`"]
1. Young Tableaux and Symmetry Classes
A Young diagram of size
n
is a partition of
n
into rows of non-increasing length, drawn as a left-justified array of boxes. Filling those boxes with the slot indices
1,…,n
gives a standard Young tableau, which the paclet stores as
YoungTableau
. Every standard tableau labels an irreducible representation of
S
n
acting on rank-
n
tensors.
Two extremes are familiar. The single-row shape
{n}
corresponds to the fully symmetric tensors, the single-column shape
{1,1,…,1}
to the fully antisymmetric ones, and the mixed shapes label all the intermediate irreps. The constructor accepts either an explicit filling or just a partition (auto-filled left-to-right, top-to-bottom).
In[4]:=
yt=
YoungTableau
[{3,2}]
Out[4]=
YoungTableau
Shape: {3,2}
Dimension: 5

The shape
TableauShape
, total number of boxes
TableauSize
, row and column slot lists
TableauRows
/
TableauColumns
, and validity predicate
YoungTableauQ
read off directly from the data structure.
In[5]:=

TableauShape
[yt],
TableauSize
[yt],
YoungTableauQ
[yt]
Out[5]=
{{3,2},5,True}
2. The Hook-Length Formula
The hook of a cell
(i,j)
is the set of cells lying to its right in row
i
together with the cells below it in column
j
, plus the cell itself. Frame and James' hook-length formula expresses the dimension of the corresponding
S
n
irrep as
d
λ
=
n!
∏
(i,j)
h(i,j)
where
h(i,j)
is the hook length at cell
(i,j)
.
HookLengths
returns all hook lengths arranged in the tableau shape, and
HookLength
picks out a single cell.
In[6]:=

HookLengths
[{3,2}],
HookLength
[yt,{1,1}]
Out[6]=
{{{4,3,1},{2,1}},4}
Multiplying the hook lengths and dividing into
n!
gives
5!
4·3·1·2·1
=5
, which is what
TableauDimension
reports. Internally the paclet does not loop over the
n
cells; it uses the Frobenius determinant form, which is
O(
3
r
)
in the number of rows
r
rather than
O(
2
n
)
in the box count. The reciprocal of the hook product is exposed directly as
HookFactor
, with the identity
TableauDimension[λ]=n!·HookFactor[λ]
.
Two partition-level utilities round out the combinatorics.
PartitionQ
tests whether a list of integers is a partition (positive and non-increasing), and
TransposePartition
conjugates a Young diagram by swapping its rows and columns. The dimensions of conjugate partitions agree, since transposing a diagram turns the symmetrizer into the antisymmetrizer and vice versa.
In[7]:=

TableauDimension
[yt],
HookFactor
[{3,2}],
PartitionQ
[{3,2}],
PartitionQ
[{2,3}],
TransposePartition
[{4,2,1}]
Out[7]=
5,
1
24
,True,False,{3,2,1,1}
3. Projecting Tensors
The Young symmetrizer associated with a tableau
T
is the algebra element
c
T
=
a
T
·
b
T
, where
b
T
symmetrizes the slots in each row of
T
and
a
T
antisymmetrizes the slots in each column. The paclet applies them in exactly that order – rows first, then columns – which is the order that leaves the final column antisymmetry intact.
YoungSymmetrize
evaluates
c
T
[T]
on a tensor whose rank equals the tableau size.
The unnormalized symmetrizer satisfies
2
c
T
=
n!
d
λ
c
T
, so the genuine projector onto the irrep is
P
T
=
d
λ
n!
c
T
. This is what
YoungProject
applies, with the normalization chosen so that
2
P
=P
.
The rank-2 case is the most familiar sanity check: shape
{2}
projects onto the symmetric part
1
2
(T+

T
)
, and shape
{1,1}
onto the antisymmetric part
1
2
(T-

T
)
. A symbolic
2×2
tensor confirms both.
In[8]:=
T={{a,b},{c,d}};​​
YoungProject
T,
YoungTableau
[{2}],
YoungProject
T,
YoungTableau
[{1,1}]
Out[9]=
a,
b+c
2
,
b+c
2
,d,0,
b-c
2
,
1
2
(-b+c),0
At rank three the new feature is the mixed-symmetry irrep
{2,1}
, whose representation is two-dimensional. A rank-3 tensor decomposes into the symmetric piece (shape
{3}
, dimension 1), the antisymmetric piece (shape
{1,1,1}
, dimension 1), and two copies of the mixed irrep (one for each standard filling of
{2,1}
, giving total dimension 2). Projecting twice with
YoungProject[⋯,YoungTableau[{2,1}]]
should be the same as projecting once.
In[10]:=
SeedRandom[42];​​R=Round[10RandomReal[1,{2,2,2}],0.01];​​yt21=
YoungTableau
[{2,1}];​​P1=
YoungProject
[R,yt21];​​P2=
YoungProject
[P1,yt21];​​Max[Abs[Flatten[P1-P2]]]
Out[15]=
0.
The residual is numerically zero, confirming
2
P
=P
. Combining the projectors for all shapes of a given size recovers the original tensor, which is the statement that
S
n
acts completely reducibly on rank-
n
tensors. The combinatorial bookkeeping that controls when each shape contributes – tableau dimensions and hook lengths – is exactly what the earlier sections compute.
RelatedGuides
▪
TensorNetworks
RelatedTechNotes
▪
Tensor Networks Overview
▪
Named Indices and Metrics
""

© 2026 Wolfram. All rights reserved.

  • Legal & Privacy Policy
  • Contact Us
  • WolframAlpha.com
  • WolframCloud.com