Optional Methods

The following methods have default implementations but can be overridden for performance or to provide additional functionality.

Quantum Dimensions

The quantum dimension of a sector is a fundamental invariant that determines the behavior of fusions and braiding. The default implementation extracts the dimension from Fsymbol via the quantum dimension formula.

\[d_a = \left| \frac{1}{(F_{a \bar{a} a}^a)^{1_a}_{_a1} } \right|\]

For many common sectors, however, the dimension is known directly from representation theory. In these cases, it can be beneficial to overload dim to bypass computing F-symbols, either for performance reasons or to enforce tighter output types. For example, dimensions of irreducible representations of groups are always integers.

TensorKitSectors.dim — Function

dim(a::Sector)

Return the (quantum) dimension of the sector a.

source

TensorKitSectors.sqrtdim — Function

sqrtdim(a::Sector)

Return the square root of the (quantum) dimension of sector a.

This is a performance specialization that avoids computing sqrt(1) for sectors with UniqueFusion, preserving the number type (returning 1::Int instead of 1.0::Float64). For other sectors, it is equivalent to sqrt(dim(a)).

source

TensorKitSectors.invsqrtdim — Function

invsqrtdim(a::Sector)

Return the inverse square root of the (quantum) dimension of sector a.

This is a performance specialization that avoids computing inv(sqrt(1)) for sectors with UniqueFusion, preserving the number type (returning 1::Int instead of 1.0::Float64). For other sectors, it is equivalent to inv(sqrt(dim(a))).

source

Frobenius-Schur Indicators

The Frobenius-Schur indicator and phase characterize the self-duality properties of sectors.

\[\kappa_a = \text{sign}\left( (F_{a \bar{a} a}^a)^{1_a}_{_a1} \right)\]

The indicator distinguishes real, complex, and quaternionic representations. The phase is the category-theoretic version that appears in line bending operations.

TensorKitSectors.frobenius_schur_indicator — Function

frobenius_schur_indicator(a::Sector)

Return the Frobenius-Schur indicator of a sector $νₐ ∈ \{1, 0, -1\}$, which distinguishes between real, complex and quaternionic representations.

See also frobenius_schur_phase for the category-theoretic version that appears in the context of line bending.

source

TensorKitSectors.frobenius_schur_phase — Function

frobenius_schur_phase(a::Sector)

Return the Frobenius-Schur phase $κₐ$ of a sector $a$, which is a complex phase that appears in the context of bending lines and is obtained from $F^{a a̅ a}_a$. When a == dual(a), it is restricted to $κₐ ∈ \{1, -1\}$ and coincides with the group-theoretic version frobenius_schur_indicator. When a != dual(a), the value of $κₐ$ can be gauged to be 1, though is not required to be.

source

Scalar Type

Various utility functions exist for determining what number type is used in various parts of the topological data.

TensorKitSectors.fusionscalartype — Function

fusionscalartype(I::Type{<:Sector}) -> Type{<:Number}

Return the scalar type of the topological data associated to fusion of the sector I. In particular, this is the scalar type of Fsymbol.

source

TensorKitSectors.braidingscalartype — Function

braidingscalartype(I::Type{<:Sector}) -> Type{<:Number}

Return the scalar type of the topological data associated to braiding of the sector I. In particular, this is the scalar type of Rsymbol.

source

TensorKitSectors.dimscalartype — Function

dimscalartype(::Type{<:Sector}) -> Type{<:Number}

Return the scalar type of the quantum dimensions associated to sectors of type I. In particular, this is the scalar type of dim.

source

TensorKitSectors.sectorscalartype — Function

sectorscalartype(I::Type{<:Sector}) -> Type{<:Number}

Return the scalar type of the topological data of the sector I. In particular, this is a combination of the scalar type of both the Fsymbol and Rsymbol, and determines the scalar type of the fusiontensor whenever it is defined.

source

Note

While there is a fallback definition that tries to determine the result from computing the functions on the unit sector, it is often a good idea to define this method explicitly to avoid depending on compiler heuristics to constant-fold these calls.

Topological Data Symbols

The Asymbol, Bsymbol and twist are derived from F- and R-symbols but are often occurring combinations. The A-symbol and B-symbol relate different ways of bending strands, while the twist is the topological spin (quantum dimension phase) of a sector.

The A-symbol $A^{ab}_c$ relates splitting and fusion vertices:

\[A^{ab}_c = \sqrt{\frac{d_a d_b}{d_c}} \overline{\kappa_a} (F_{\bar{a} a b}^b)^1_c\]

The B-symbol $B^{ab}_c$ relates splitting and fusion vertices:

\[B^{ab}_c = \sqrt{\frac{d_a d_b}{d_c}} (F_{a b \bar{b}}^a)^c_1\]

The twist $\theta_a$ of a sector is the topological spin phase, computed as the trace of the R-matrix for braiding a sector with itself:

\[\theta_a = \frac{1}{d_a} \sum_{b \in a \otimes a} d_b \text{tr}(R^{aa}_b)\]

TensorKitSectors.Asymbol — Function

Asymbol(a::I, b::I, c::I) where {I <: Sector}

Return the value of $A^{ab}_c$ which appears in transforming a splitting vertex into a fusion vertex using the transformation

a -<-μ-<- c                                                    b -<-ν-<- dual(a)
     ∨       -> √(dim(c) / dim(b)) * Asymbol(a, b, c)[μ, ν]         ∧
     b                                                              c

If FusionStyle(I) is UniqueFusion() or SimpleFusion(), the A-symbol is a number. Otherwise it is a square matrix with row and column size Nsymbol(a, b, c) == Nsymbol(dual(a), c, b).

source

TensorKitSectors.Bsymbol — Function

Bsymbol(a::I, b::I, c::I) where {I <: Sector}

Return the value of $B^{ab}_c$ which appears in transforming a splitting vertex into a fusion vertex using the transformation

a -<-μ-<- c                                                    a -<-ν-<- c
     ∨       -> √(dim(c) / dim(a)) * Bsymbol(a, b, c)[μ, ν]         ∧
     b                                                            dual(b)

If FusionStyle(I) is UniqueFusion() or SimpleFusion(), the B-symbol is a number. Otherwise it is a square matrix with row and column size Nsymbol(a, b, c) == Nsymbol(c, dual(b), a).

source

TensorKitSectors.twist — Function

twist(a::Sector)

Return the twist of a sector a.

source

Fusion Basis

The fusion tensor provides explicit matrix elements for the tensor product of representations. It is a rank-4 array whose components are the Clebsch-Gordan coefficients for fusing sector a and b into c. The fusion tensor is not uniquely determined by topological data alone, instead the topological data can be extracted from it when it is available. However, there is not always a concrete representation of these tensors in terms of simple Array objects, and the exact representation is not important for TensorKit.jl. For this reason, it is optional: TensorKit can work with the topological data alone. Note however that they are still required whenever we want to convert symmetric tensors to and from dense arrays.

TensorKitSectors.fusiontensor — Function

fusiontensor(a::I, b::I, c::I) where {I <: Sector} -> AbstractArray{T, 4}

Return the fusion tensor for the fusion a ⊗ b -> c. The dimensions of the returned array are (dim(a), dim(b), dim(c), Nsymbol(a, b, c)). The components of the fusion tensor are simply the Clebsch-Gordan coefficients, describing the unitary basis change from the tensor product of irreps a and b to the coupled irrep c.

source