diff --git a/Tutorials/Centers over non-algebraicall closed fields.ipynb b/Tutorials/Centers over non-algebraicall closed fields.ipynb index eecadb4..1fb7f36 100644 --- a/Tutorials/Centers over non-algebraicall closed fields.ipynb +++ b/Tutorials/Centers over non-algebraicall closed fields.ipynb @@ -13,46 +13,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, { "data": { "text/plain": [ @@ -64,7 +27,7 @@ } ], "source": [ - "using TensorCategories, Oscar\n", + "using TensorCategories, Oscar;\n", "\n", "Qx,x = QQ[:x]\n", "k,_ = number_field(x^2-2, \"√2\")\n", diff --git a/Tutorials/Centers.ipynb b/Tutorials/Centers.ipynb index 441b73e..f93c6ea 100644 --- a/Tutorials/Centers.ipynb +++ b/Tutorials/Centers.ipynb @@ -13,50 +13,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, { "data": { "text/plain": [ - "Category of G-graded vector spaces over Field of algebraic numbers where G is Sym(3)" + "Category of G-graded vector spaces over Rational field where G is Sym(3)" ] }, "metadata": {}, @@ -64,7 +27,7 @@ } ], "source": [ - "using TensorCategories, Oscar\n", + "using TensorCategories, Oscar;\n", "\n", "G = symmetric_group(3)\n", "π’ž = graded_vector_spaces(QQ,G)" diff --git a/Tutorials/Centralizers.ipynb b/Tutorials/Centralizers.ipynb index 1707548..d92bdf6 100644 --- a/Tutorials/Centralizers.ipynb +++ b/Tutorials/Centralizers.ipynb @@ -13,46 +13,9 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", - "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\r" - ] - }, { "data": { "text/plain": [ @@ -76,7 +39,7 @@ } ], "source": [ - "using TensorCategories, Oscar\n", + "using TensorCategories, Oscar;\n", "\n", "G = symmetric_group(3)\n", "\n", diff --git a/Tutorials/TensorCategories.ipynb b/Tutorials/TensorCategories.ipynb new file mode 100644 index 0000000..e578d72 --- /dev/null +++ b/Tutorials/TensorCategories.ipynb @@ -0,0 +1,490 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Fusion Categories in Julia\n", + "\n", + "TensorCategories.jl aims to provide a framework for explicit computations with tensor categories. I.e. we work with constructive models of tensor categories or also finitary categories. Most categories are modelled by providing objects and morphisms in any pleasant form. Most of the time this means morphisms are in some way given by matrices or families of matrices. \n", + "\n", + "## Graded Vector Spaces\n", + "\n", + "A great starting example is the category of $G$-graded vector spaces $\\mathrm{Vec}_G$. The category is modelled by objects given as tuples $V = (g_1,...,g_n)$ where the $g_i \\in G$ are the gradings of the basis vectors. Therefore morphisms are encoded as matrices that obey the grading gifting us composition as matrix multiplication." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Method definition number_of_generators(AbstractAlgebra.PolyRing{T} where T) in module AbstractAlgebra at /Users/maeurer/.julia/packages/AbstractAlgebra/wVuNz/src/Poly.jl:201 overwritten in module Oscar at /Users/maeurer/.julia/packages/Oscar/59YCS/src/Rings/mpoly-affine-algebras.jl:241.\n", + "ERROR: Method overwriting is not permitted during Module precompilation. Use `__precompile__(false)` to opt-out of precompilation.\n" + ] + } + ], + "source": [ + "using TensorCategories, Oscar \n", + "\n", + "G = symmetric_group(3)\n", + "g,s = gens(G)\n", + "\n", + "C = graded_vector_spaces(QQ,G)\n", + "\n", + "simples(C)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `C` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `C` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "(C[g]βŠ•C[s])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `C` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `C` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "(C[2]^2 βŠ• C[3]) βŠ— C[4]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Group Representations\n", + "\n", + "Group representations are another great example. We use the MeatAxe functionality of GAP wrapped in our framework." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `GF` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `GF` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "Rep = representation_category(GF(7), G)\n", + "\n", + "simples(Rep)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `Rep` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `Rep` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "Hom(Rep[2]βŠ—Rep[3], Rep[3])" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `print_multiplication_table` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `print_multiplication_table` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "print_multiplication_table(Rep)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Computing Centers of Fusion Categories in Julia\n", + "\n", + "Here we want to demonstrate how to compute the center of a fusion category by examining the example where $\\mathcal C$ is the category of $G$-graded vector spaces over $\\mathbb Q(\\xi_3)$.\n", + "\n", + "As a simple example we choose the symmetric group on three elements $G = S_3$. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `symmetric_group` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `symmetric_group` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "G = symmetric_group(3)\n", + "K,_ = cyclotomic_field(3)\n", + "π’ž = graded_vector_spaces(K,G)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compute objects in the center we can either do it by simple constructing an instance of the center" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `center` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `center` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "𝒡 = center(π’ž)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This is a surprisingly fast line, because no computations are performed yet. The structure of the center is entirely given by the simple objects so that is what we compute now. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `simples` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `simples` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "S = simples(𝒡)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From here we can examine the category $\\mathcal Z(\\mathcal C)$ in a way that most abstracts approaches do not allow. For example we can examine the half braidings explicitly, since they are given as matrices. Here the half braiding $S_1 \\otimes \\delta_{(1,2,3)} \\to \\delta_{(1,2,3)} \\otimes S_i$." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `S` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `S` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "matrix(half_braiding(S[1])[5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "An other computable constant is the (normalized) $S$-matrix. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `normalized_smatrix` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `normalized_smatrix` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "normalized_smatrix(𝒡)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# The Simple Representations of $Vec_{\\mathbb Z_2}$ and $Vec_{\\mathbb Z_2}^{\\omega}$\n", + "\n", + "Here we want to examine the categorical representation theory $Vec_G^\\omega$ for $G = \\mathbb Z_2$. The finite irreducible semisimple module categories for the trivial 3-cocycle $\\omega$ are $Vec$ and $Vec_G$. We can realize them as internal module categories in $Vec_G$." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `cyclic_group` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `cyclic_group` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "G = cyclic_group(2)\n", + "C = graded_vector_spaces(QQ,G)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's denote the simple objects of $\\mathrm{Vec}_G$ by $\\delta_{1}$ and $\\delta_{-1}$. The $\\mathrm{Vec}_G$-module category $\\mathrm{Vec}_G$ is given by the module category $\\mathrm{Mod}_{\\delta_1}(\\mathrm{Vec}_G)$ where $\\delta_1$ is the unit object considered as an algebra." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `C` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `C` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "A = generic_algebra(C[1])\n", + "\n", + "M = category_of_right_modules(A)\n", + "\n", + "simples(M)\n", + "\n", + "action_matrix(C[2], M)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The realization of the module category structure on $\\mathrm{Vec}$ is more complicated. A finite irreducible semisimple module category corresponds to a simple separable algebra object we need to find such. There are only two candidates for simple separable algebras in $\\mathrm{Vec}_G$ namely $\\delta_{1}$ and $\\delta_{1} + \\delta_{-1}$. We try to solve the system, of quadratic equations describing the algebra condition. Unfortunately the ideal generated by those conditions is of dimension one. But nonetheless we can extract some algebras from it.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `C` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `C` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "algebras = separable_algebra_structures(C[1] βŠ• C[2])\n", + "\n", + "B = algebras[1]\n", + "\n", + "N = category_of_right_modules(B)\n", + "\n", + "simples(N)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## The Simple Modules of $\\mathrm{Vec}_G^\\omega$\n", + "\n", + "We now want to repeat the process for $\\omega$ non-trivial. Then the module category $\\mathrm{Vec}_G$ is constructed similarly since it it still the internal module category over the trivial algebra. Any other irreducible semisimple module category will correspond to a simple separable algebra, i.e. a separable algebra structure on $\\delta_{1}+\\delta_{-1}$. But such an algebra structure does not exist. Note that the method `separable_algebra_structures` only returns an empty array when the system of equations is inconsistent. It will error if there are solutions but none found." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `twisted_graded_vector_spaces` not defined", + "output_type": "error", + "traceback": [ + "UndefVarError: `twisted_graded_vector_spaces` not defined\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ ~/.julia/dev/TensorCategories.jl/Tutorials/TensorCategories.ipynb:1" + ] + } + ], + "source": [ + "D = twisted_graded_vector_spaces(QQ,G)\n", + "\n", + "separable_algebra_structures(D[1]βŠ•D[2], show_dimension = true)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.10.2", + "language": "julia", + "name": "julia-1.10" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.10.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}