GitHub

The Center Construction

Let $\mathcal C$ be a monoidal category. The Drinfeld center of $\mathcal C$ is a category whose objects are tuples $(X,\gamma)$ such that $X \in \mathcal C$ and $\{\gamma_Z \colon X \otimes Z \to Z \otimes X \mid Z \in \mathcal C\}$ is a natural isomorphism such that

\begin{tikzcd} & (Y \otimes X) \otimes Z \ar[r, "a_{Y,X,Z}"] & Y \otimes (X \otimes Z) \ar[dr, "\id_Y \otimes \gamma_X(Z)"] & \\ (X \otimes Y) \otimes Z \ar[ur, "\gamma_X(Y) \otimes \id_Z"] \ar[dr, "a_{X,Y,Z}"] & & & Y \otimes (Z \otimes X) \\ & X \otimes (Y \otimes Z) \ar[r, "\gamma_X(Y \otimes Z)"] & (Y \otimes Z) \otimes X \ar[ur, "a_{Y,Z,X}"] & \end{tikzcd}

commutes for all $Y,Z \in \mathcal C$ and $\gamma_{\mathbb 1} = \mathrm{id}_X$.

Computing the Center

The Drinfeld center can be computed explicitly for many fusion categories using the algorithm described in [6]. Any fusion category implementing the corresponding interface is supported.

Example

I = ising_category()
C = center(I)
simples(C)

# output
5-element Vector{CenterObject}:
 Central object: 𝟙
 Central object: 𝟙
 Central object: 𝟙 ⊕ χ
 Central object: 2⋅χ
 Central object: 4⋅X

Who is familiar with the center of the Ising category will notice that this looks odd. In fact this is because we define the Ising category over the field $\mathbb Q (\sqrt{2})$and not $\mathbb C$. In this case the endomorphism spaces are division algebras of dimension greater than one. 

base_ring(I)

# output
Number field with defining polynomial x^2 - 2
  over rational field
r = endomorphism_ring(C[4])

# output
Matrix algebra of dimension 2 over Number field of degree 2 over QQ
is_simple(r) 

# output 
true

Supported categories

In general all split fusion categories implementing the fusion category interface are supported. As ground fields we support all numberfield types from Oscar, i.e. all subtypes of NumField, the algebraic numbers QQBarField, the complex numbers CalciumField and the arbitrary precision complex ball numbers AcbField.

!!! warning If using AcbField as a grounf field, keep in mind to check the precision and increase it if the behaviour seems unexpected. Performing algebraic operations with numeric types is generally hard and multiple magnitudes of precision can be lost in single operations introducing error.

Centers of the AnyonWiki

Currently we are working at the task to compute all centers of multiplicity free fusion categories up to rank seven. At the moment all centers to rank 5 are available and some of rank six. Access them via 

C = anyonwiki_center(3,1,0,2,1,1,1)

print_multiplication_table(C)

# output
8×8 Matrix{String}:
 "(𝟙, γ)"        "(X2, γ)"       …  "(X2 ⊕ X3, γ)"
 "(X2, γ)"       "(𝟙, γ)"           "(𝟙 ⊕ X3, γ)"
 "(𝟙 ⊕ X2, γ)"   "(𝟙 ⊕ X2, γ)"      "(𝟙 ⊕ X3, γ) ⊕ (X2 ⊕ X3, γ)"
 "(X3, γ1)"      "(X3, γ1)"         "(𝟙 ⊕ X3, γ) ⊕ (X2 ⊕ X3, γ)"
 "(X3, γ2)"      "(X3, γ2)"         "(𝟙 ⊕ X3, γ) ⊕ (X2 ⊕ X3, γ)"
 "(X3, γ3)"      "(X3, γ3)"      …  "(𝟙 ⊕ X3, γ) ⊕ (X2 ⊕ X3, γ)"
 "(𝟙 ⊕ X3, γ)"   "(X2 ⊕ X3, γ)"     "(X2, γ) ⊕ (𝟙 ⊕ X2, γ) ⊕ (X3, γ1) ⊕ (X3, γ2) ⊕ (X3, γ3)"
 "(X2 ⊕ X3, γ)"  "(𝟙 ⊕ X3, γ)"      "(𝟙, γ) ⊕ (𝟙 ⊕ X2, γ) ⊕ (X3, γ1) ⊕ (X3, γ2) ⊕ (X3, γ3)"

F- and R-Symbols

We can export the $F$- and $R$-symbols as Dicts via the methods

TensorCategories.numeric_F_symbols — Function
numeric_F_symbols(C::SixJCategory; precision = 2048)
numeric_F_symbols(C::SixJCategory, e::AbsSimpleNumFieldEmbedding; precision = 2048)

Return a Dictionary of the F-symbols of $C$ evaluated under the embedding $e$.

source
TensorCategories.numeric_R_symbols — Function
numeric_R_symbols(C::SixJCategory; precision = 2048)
numeric_R_symbols(C::SixJCategory, e::AbsSimpleNumFieldEmbedding; precision = 2048)

Return a Dictionary of the R-symbols of $C$ evaluated under the embedding $e$.

source
AbstractAlgebra.is_isomorphic — Method
is_isomorphic(X::CenterObject, Y::CenterObject)

Check if X≃Y. Return (true, m) where mis an isomorphism if true, else return (false,nothing).

source
Base.inv — Method
inv(f::CenterMorphism)

Return the inverse of fif possible.

source
Base.one — Method
one(C::CenterCategory)

Return the one object of C.

source
Base.split — Method
split(C::CenterCategory; absolute = true)

Extend the scalars of the center category C such that it is split semisimple after karoubian closure. If the flag absolute is set false the extension field is chosen to be a relative numberfield that includes the original field as is. The splitting field is not minimal in general and usually chosen to be a cyclotomic extension of the base field.

source
Base.zero — Method
zero(C::CenterCategory)

Return the zero object of C.

source
Hecke.cokernel — Method
cokernel(f::CenterMorphism)

Return a tuple (C,c) where Cis the cokernel object and cis the projection.

source
Hecke.dual — Method
dual(X::CenterObject)

Return the (left) dual object of X.

source
Oscar.morphism — Method
morphism(f::CenterMorphism)

Return the image under the forgetful functor.

source
TensorCategories.add_simple! — Method
add_simple!(C::CenterCategory, S::CenterObject)
add_simple!(C::CenterCategory, S::Vector{CenterObject})

Add the simple object S to the vector of simple objects.

source
TensorCategories.associator — Method
associator(X::CenterObject, Y::CenterObject, Z::CenterObject)

Return the associator isomorphism (X⊗Y)⊗Z → X⊗(Y⊗Z).

source
TensorCategories.induction_generators — Method
induction_generators(C::CenterCategory)

Returns a (not necessarily minimal) set $S$ of simples in $C$ such that every simple of $Z(C)$ is a subquotient of an image of some $s ∈ C$.

source
TensorCategories.adjusted_dual_basis — Method
adjusted_dual_basis(V::AbstractHomSpace, U::AbstractHomSpace, S::Object, W::Object, T::Object)

Compute a dual basis for the spaces Hom(S, W⊗T) and Hom(S̄⊗W, T̄)

source