Cubic Hecke database

This module contains the class CubicHeckeDataBase which serves as an interface to Ivan Marin’s data files with respect to the cubic Hecke algebras. The data is available via a Python wrapper as a pip installable package database_cubic_hecke. For installation hints please see the documentation there. All data needed for the cubic Hecke algebras on less than four strands is included in this module for demonstration purpose (see for example read_basis(), read_irr() , … generated with the help of create_demo_data()).

In addition to Ivan Marin’s data the package contains a function read_markov() to obtain the coefficients of Markov traces on the cubic Hecke algebras. This data has been precomputed with the help of create_markov_trace_data.py in the database_cubic_hecke repository. Again, for less than four strands, this data is includes here for demonstration purposes.

Furthermore, this module contains the class CubicHeckeFileCache that enables CubicHeckeAlgebra to keep intermediate results of calculations in the file system.

The enum MarkovTraceModuleBasis serves as basis for the submodule of linear forms on the cubic Hecke algebra on at most four strands satisfying the Markov trace condition for its cubic Hecke subalgebras.

To use the database, you need to install the optional database_cubic_hecke package by the Sage command

sage -i database_cubic_hecke

EXAMPLES:

Sage

sage: # optional - database_cubic_hecke
sage: from sage.databases.cubic_hecke_db import CubicHeckeDataBase
sage: cha_db = CubicHeckeDataBase()
sage: cha_db
<sage.databases.cubic_hecke_db.CubicHeckeDataBase object at ...>

Python

>>> from sage.all import *
>>> # optional - database_cubic_hecke
>>> from sage.databases.cubic_hecke_db import CubicHeckeDataBase
>>> cha_db = CubicHeckeDataBase()
>>> cha_db
<sage.databases.cubic_hecke_db.CubicHeckeDataBase object at ...>

AUTHORS:

• Sebastian Oehms (2020-05): initial version

• Sebastian Oehms (2022-03): PyPi version and Markov trace functionality

class sage.databases.cubic_hecke_db.CubicHeckeDataBase

Bases: SageObject

Database interface for CubicHeckeAlgebra

The original data are obtained from Ivan Marin’s web page

The data needed to work with the cubic Hecke algebras on less than 4 strands is completely contained in this module. Data needed for the larger algebras can be installed as an optional Sage package which comes as a pip installable Python wrapper of Ivan Marin’s data. For more information see the corresponding repository.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeDataBase
sage: cha_db = CubicHeckeDataBase()
sage: cha_db._feature
Feature('database_cubic_hecke')

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeDataBase
>>> cha_db = CubicHeckeDataBase()
>>> cha_db._feature
Feature('database_cubic_hecke')

demo_version()

Return whether the cubic Hecke database is installed completely or just the demo version is used.

EXAMPLES:

Sage

sage: from sage.databases.knotinfo_db import KnotInfoDataBase
sage: ki_db = KnotInfoDataBase()
sage: ki_db.demo_version()       # optional - database_knotinfo
False

Python

>>> from sage.all import *
>>> from sage.databases.knotinfo_db import KnotInfoDataBase
>>> ki_db = KnotInfoDataBase()
>>> ki_db.demo_version()       # optional - database_knotinfo
False

read(section, variables=None, nstrands=4)

Access various static data libraries.

INPUT:

• section – instance of enum CubicHeckeDataSection to select the data to be read in

OUTPUT: a dictionary containing the data corresponding to the section

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeDataBase
sage: cha_db = CubicHeckeDataBase()
sage: basis = cha_db.read(cha_db.section.basis, nstrands=3)
sage: len(basis)
24

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeDataBase
>>> cha_db = CubicHeckeDataBase()
>>> basis = cha_db.read(cha_db.section.basis, nstrands=Integer(3))
>>> len(basis)
24

read_matrix_representation(representation_type, gen_ind, nstrands, ring_of_definition)

Return the matrix representations from the database.

INPUT:

• representation_type – an element of RepresentationType specifying the type of the representation

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeDataBase
sage: CHA3 = algebras.CubicHecke(2)
sage: GER = CHA3.extension_ring(generic=True)
sage: cha_db = CHA3._database
sage: rt = CHA3.repr_type
sage: m1 =cha_db.read_matrix_representation(rt.SplitIrredMarin, 1, 3, GER)
sage: len(m1)
7
sage: GBR = CHA3.base_ring(generic=True)
sage: m1rl = cha_db.read_matrix_representation(rt.RegularLeft, 1, 3, GBR)
sage: m1rl[0].dimensions()
(24, 24)

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeDataBase
>>> CHA3 = algebras.CubicHecke(Integer(2))
>>> GER = CHA3.extension_ring(generic=True)
>>> cha_db = CHA3._database
>>> rt = CHA3.repr_type
>>> m1 =cha_db.read_matrix_representation(rt.SplitIrredMarin, Integer(1), Integer(3), GER)
>>> len(m1)
7
>>> GBR = CHA3.base_ring(generic=True)
>>> m1rl = cha_db.read_matrix_representation(rt.RegularLeft, Integer(1), Integer(3), GBR)
>>> m1rl[Integer(0)].dimensions()
(24, 24)

section

alias of CubicHeckeDataSection

version()

Return the current version of the database.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeDataBase
sage: cha_db = CubicHeckeDataBase()
sage: cha_db.version() > '2022.1.1'   # optional - database_cubic_hecke
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeDataBase
>>> cha_db = CubicHeckeDataBase()
>>> cha_db.version() > '2022.1.1'   # optional - database_cubic_hecke
True

class sage.databases.cubic_hecke_db.CubicHeckeDataSection(value)

Bases: Enum

Enum for the different sections of the database.

The following choices are possible:

• basis – list of basis elements

• reg_left_reprs – data for the left regular representation

• reg_right_reprs – data for the right regular representation

• irr_reprs – data for the split irreducible representations

• markov_tr_cfs – data for the coefficients of the formal Markov traces

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeDataBase
sage: cha_db = CubicHeckeDataBase()
sage: cha_db.section
<enum 'CubicHeckeDataSection'>

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeDataBase
>>> cha_db = CubicHeckeDataBase()
>>> cha_db.section
<enum 'CubicHeckeDataSection'>

basis = 'basis'

markov_tr_cfs = 'markov_tr_cfs'

regular_left = 'regular_left'

regular_right = 'regular_right'

split_irred = 'split_irred'

class sage.databases.cubic_hecke_db.CubicHeckeFileCache(num_strands)

Bases: SageObject

A class to cache calculations of CubicHeckeAlgebra in the local file system.

is_empty(section=None)

Return True if the cache of the given section is empty.

INPUT:

• section – an element of CubicHeckeFileCache.section to select the section of the file cache or None (default) meaning all sections

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: cha2_fc = CubicHeckeFileCache(2)
sage: cha2_fc.reset_library()
sage: cha2_fc.is_empty()
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> cha2_fc = CubicHeckeFileCache(Integer(2))
>>> cha2_fc.reset_library()
>>> cha2_fc.is_empty()
True

read(section)

Read data into memory from the file system.

INPUT:

• section – an element of CubicHeckeFileCache.section specifying the section where the corresponding cached data belong to

OUTPUT:

Dictionary containing the data library corresponding to the section of file cache

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: cha2_fc = CubicHeckeFileCache(2)
sage: cha2_fc.reset_library(cha2_fc.section.braid_images)
sage: cha2_fc.read(cha2_fc.section.braid_images)
{}

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> cha2_fc = CubicHeckeFileCache(Integer(2))
>>> cha2_fc.reset_library(cha2_fc.section.braid_images)
>>> cha2_fc.read(cha2_fc.section.braid_images)
{}

read_braid_image(braid_tietze, ring_of_definition)

Return the list of pre calculated braid images from file cache.

INPUT:

• braid_tietze – tuple representing the braid in Tietze form

• ring_of_definition – a CubicHeckeRingOfDefinition

OUTPUT:

A dictionary containing the pre calculated braid image of the given braid.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: CHA2 = algebras.CubicHecke(2)
sage: ring_of_definition = CHA2.base_ring(generic=True)
sage: cha_fc = CubicHeckeFileCache(2)
sage: B2 = BraidGroup(2)
sage: b, = B2.gens(); b2 = b**2
sage: cha_fc.is_empty(CubicHeckeFileCache.section.braid_images)
True
sage: b2_img = CHA2(b2); b2_img
w*c^-1 + u*c + (-v)
sage: cha_fc.write_braid_image(b2.Tietze(), b2_img.to_vector())
sage: cha_fc.read_braid_image(b2.Tietze(), ring_of_definition)
(-v, u, w)

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> ring_of_definition = CHA2.base_ring(generic=True)
>>> cha_fc = CubicHeckeFileCache(Integer(2))
>>> B2 = BraidGroup(Integer(2))
>>> b, = B2.gens(); b2 = b**Integer(2)
>>> cha_fc.is_empty(CubicHeckeFileCache.section.braid_images)
True
>>> b2_img = CHA2(b2); b2_img
w*c^-1 + u*c + (-v)
>>> cha_fc.write_braid_image(b2.Tietze(), b2_img.to_vector())
>>> cha_fc.read_braid_image(b2.Tietze(), ring_of_definition)
(-v, u, w)

read_matrix_representation(representation_type, monomial_tietze, ring_of_definition)

Return the matrix representations of the given monomial (in Tietze form) if it has been stored in the file cache before. INPUT:

• representation_type – an element of RepresentationType specifying the type of the representation

• monomial_tietze – tuple representing the braid in Tietze form

• ring_of_definition – instance of CubicHeckeRingOfDefinition respectively CubicHeckeExtensionRing depending on whether representation_type is split or not

OUTPUT:

Dictionary containing all matrix representations of self of the given representation_type which have been stored in the file cache. Otherwise None is returned.

EXAMPLES:

Sage

sage: CHA2 = algebras.CubicHecke(2)
sage: R = CHA2.base_ring(generic=True)
sage: cha_fc = CHA2._filecache
sage: g, = CHA2.gens(); gt = g.Tietze()
sage: rt = CHA2.repr_type
sage: g.matrix(representation_type=rt.RegularLeft)
[ 0 -v  1]
[ 1  u  0]
[ 0  w  0]
sage: [_] == cha_fc.read_matrix_representation(rt.RegularLeft, gt, R)
True
sage: cha_fc.reset_library(cha_fc.section.matrix_representations)
sage: cha_fc.write(cha_fc.section.matrix_representations)
sage: cha_fc.read_matrix_representation(rt.RegularLeft, gt, R) == None
True

Python

>>> from sage.all import *
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> R = CHA2.base_ring(generic=True)
>>> cha_fc = CHA2._filecache
>>> g, = CHA2.gens(); gt = g.Tietze()
>>> rt = CHA2.repr_type
>>> g.matrix(representation_type=rt.RegularLeft)
[ 0 -v  1]
[ 1  u  0]
[ 0  w  0]
>>> [_] == cha_fc.read_matrix_representation(rt.RegularLeft, gt, R)
True
>>> cha_fc.reset_library(cha_fc.section.matrix_representations)
>>> cha_fc.write(cha_fc.section.matrix_representations)
>>> cha_fc.read_matrix_representation(rt.RegularLeft, gt, R) == None
True

reset_library(section=None)

Reset the file cache corresponding to the specified section.

INPUT:

• section – an element of CubicHeckeFileCache.section to select the section of the file cache or None (default) meaning all sections

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: cha2_fc = CubicHeckeFileCache(2)
sage: cha2_fc.reset_library(cha2_fc.section.braid_images)
sage: cha2_fc.read(cha2_fc.section.braid_images)
{}
sage: cha2_fc.reset_library(cha2_fc.section.matrix_representations)
sage: data_mat = cha2_fc.read(cha2_fc.section.matrix_representations)
sage: len(data_mat.keys())
4

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> cha2_fc = CubicHeckeFileCache(Integer(2))
>>> cha2_fc.reset_library(cha2_fc.section.braid_images)
>>> cha2_fc.read(cha2_fc.section.braid_images)
{}
>>> cha2_fc.reset_library(cha2_fc.section.matrix_representations)
>>> data_mat = cha2_fc.read(cha2_fc.section.matrix_representations)
>>> len(data_mat.keys())
4

class section(value)

Bases: Enum

Enum for the different sections of file cache. The following choices are possible:

• matrix_representations – file cache for representation matrices of basis elements

• braid_images – file cache for images of braids

• basis_extensions – file cache for a dynamical growing basis used in the case of cubic Hecke algebras on more than 4 strands

• markov_trace – file cache for intermediate results of long calculations in order to recover the results already obtained by previous attemps of calculation until the corresponding intermediate step

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: CHA2 = algebras.CubicHecke(2)
sage: cha_fc = CubicHeckeFileCache(CHA2)
sage: cha_fc.section
<enum 'section'>

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> cha_fc = CubicHeckeFileCache(CHA2)
>>> cha_fc.section
<enum 'section'>

basis_extensions = 'basis_extensions'

braid_images = 'braid_images'

filename(nstrands=None)

Return the file name under which the data of this file cache section is stored as an sobj-file.

INPUT:

• nstrands – (optional) Integer; number of strands of the underlying braid group if the data file depends on it

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: CHA2 = algebras.CubicHecke(2)
sage: cha_fc = CubicHeckeFileCache(CHA2)
sage: cha_fc.section.matrix_representations.filename(2)
'matrix_representations_2.sobj'
sage: cha_fc.section.braid_images.filename(2)
'braid_images_2.sobj'

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> cha_fc = CubicHeckeFileCache(CHA2)
>>> cha_fc.section.matrix_representations.filename(Integer(2))
'matrix_representations_2.sobj'
>>> cha_fc.section.braid_images.filename(Integer(2))
'braid_images_2.sobj'

markov_trace = 'markov_trace'

matrix_representations = 'matrix_representations'

update_basis_extensions(new_basis_extensions)

Update the file cache for basis extensions for cubic Hecke algebras on more than 4 strands according to the given new_basis_extensions.

INPUT:

• new_basis_extensions – list of additional (to the static basis) basis elements which should replace the former such list in the file

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: CHA2 = algebras.CubicHecke(2)
sage: cha_fc = CubicHeckeFileCache(2)
sage: cha_fc.is_empty(CubicHeckeFileCache.section.basis_extensions)
True
sage: cha_fc.update_basis_extensions([(1,), (-1,)])
sage: cha_fc.read(CubicHeckeFileCache.section.basis_extensions)
[(1,), (-1,)]
sage: cha_fc.reset_library(CubicHeckeFileCache.section.basis_extensions)
sage: cha_fc.write(CubicHeckeFileCache.section.basis_extensions)
sage: cha_fc.is_empty(CubicHeckeFileCache.section.basis_extensions)
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> cha_fc = CubicHeckeFileCache(Integer(2))
>>> cha_fc.is_empty(CubicHeckeFileCache.section.basis_extensions)
True
>>> cha_fc.update_basis_extensions([(Integer(1),), (-Integer(1),)])
>>> cha_fc.read(CubicHeckeFileCache.section.basis_extensions)
[(1,), (-1,)]
>>> cha_fc.reset_library(CubicHeckeFileCache.section.basis_extensions)
>>> cha_fc.write(CubicHeckeFileCache.section.basis_extensions)
>>> cha_fc.is_empty(CubicHeckeFileCache.section.basis_extensions)
True

write(section=None)

Write data from memory to the file system.

INPUT:

• section – an element of CubicHeckeFileCache.section specifying the section where the corresponding cached data belong to; if omitted, the data of all sections is written to the file system

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: cha2_fc = CubicHeckeFileCache(2)
sage: cha2_fc.reset_library(cha2_fc.section.braid_images)
sage: cha2_fc.write(cha2_fc.section.braid_images)

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> cha2_fc = CubicHeckeFileCache(Integer(2))
>>> cha2_fc.reset_library(cha2_fc.section.braid_images)
>>> cha2_fc.write(cha2_fc.section.braid_images)

write_braid_image(braid_tietze, braid_image_vect)

Write the braid image of the given braid to the file cache.

INPUT:

• braid_tietze – tuple representing the braid in Tietze form

• braid_image_vect – image of the given braid as a vector with respect to the basis of the cubic Hecke algebra

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import CubicHeckeFileCache
sage: CHA2 = algebras.CubicHecke(2)
sage: ring_of_definition = CHA2.base_ring(generic=True)
sage: cha_fc = CubicHeckeFileCache(2)
sage: B2 = BraidGroup(2)
sage: b, = B2.gens(); b3 = b**3
sage: b3_img = CHA2(b3); b3_img
u*w*c^-1 + (u^2-v)*c + (-u*v+w)
sage: cha_fc.write_braid_image(b3.Tietze(), b3_img.to_vector())
sage: cha_fc.read_braid_image(b3.Tietze(), ring_of_definition)
(-u*v + w, u^2 - v, u*w)
sage: cha_fc.reset_library(CubicHeckeFileCache.section.braid_images)
sage: cha_fc.write(CubicHeckeFileCache.section.braid_images)
sage: cha_fc.is_empty(CubicHeckeFileCache.section.braid_images)
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import CubicHeckeFileCache
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> ring_of_definition = CHA2.base_ring(generic=True)
>>> cha_fc = CubicHeckeFileCache(Integer(2))
>>> B2 = BraidGroup(Integer(2))
>>> b, = B2.gens(); b3 = b**Integer(3)
>>> b3_img = CHA2(b3); b3_img
u*w*c^-1 + (u^2-v)*c + (-u*v+w)
>>> cha_fc.write_braid_image(b3.Tietze(), b3_img.to_vector())
>>> cha_fc.read_braid_image(b3.Tietze(), ring_of_definition)
(-u*v + w, u^2 - v, u*w)
>>> cha_fc.reset_library(CubicHeckeFileCache.section.braid_images)
>>> cha_fc.write(CubicHeckeFileCache.section.braid_images)
>>> cha_fc.is_empty(CubicHeckeFileCache.section.braid_images)
True

write_matrix_representation(representation_type, monomial_tietze, matrix_list)

Write the matrix representation of a monomial to the file cache.

INPUT:

• representation_type – an element of RepresentationType specifying the type of the representation

• monomial_tietze – tuple representing the braid in Tietze form

• matrix_list – list of matrices corresponding to the irreducible representations

EXAMPLES:

Sage

sage: CHA2 = algebras.CubicHecke(2)
sage: R = CHA2.base_ring(generic=True)
sage: cha_fc = CHA2._filecache
sage: g, = CHA2.gens(); gi = ~g; git = gi.Tietze()
sage: rt = CHA2.repr_type
sage: m = gi.matrix(representation_type=rt.RegularRight)
sage: cha_fc.read_matrix_representation(rt.RegularRight, git, R)
[
[     0      1 (-u)/w]
[     0      0    1/w]
[     1      0    v/w]
]
sage: CHA2.reset_filecache(cha_fc.section.matrix_representations)
sage: cha_fc.read_matrix_representation(rt.RegularLeft, git, R) == None
True
sage: cha_fc.write_matrix_representation(rt.RegularRight, git, [m])
sage: [m] == cha_fc.read_matrix_representation(rt.RegularRight, git, R)
True

Python

>>> from sage.all import *
>>> CHA2 = algebras.CubicHecke(Integer(2))
>>> R = CHA2.base_ring(generic=True)
>>> cha_fc = CHA2._filecache
>>> g, = CHA2.gens(); gi = ~g; git = gi.Tietze()
>>> rt = CHA2.repr_type
>>> m = gi.matrix(representation_type=rt.RegularRight)
>>> cha_fc.read_matrix_representation(rt.RegularRight, git, R)
[
[     0      1 (-u)/w]
[     0      0    1/w]
[     1      0    v/w]
]
>>> CHA2.reset_filecache(cha_fc.section.matrix_representations)
>>> cha_fc.read_matrix_representation(rt.RegularLeft, git, R) == None
True
>>> cha_fc.write_matrix_representation(rt.RegularRight, git, [m])
>>> [m] == cha_fc.read_matrix_representation(rt.RegularRight, git, R)
True

class sage.databases.cubic_hecke_db.MarkovTraceModuleBasis(value)

Bases: Enum

Enum for the basis elements for the Markov trace module.

The choice of the basis elements doesn’t have a systematically background apart from generating the submodule of maximal rank in the module of linear forms on the cubic Hecke algebra for which the Markov trace condition with respect to its cubic Hecke subalgebras hold. The number of crossings in the corresponding links is chosen as minimal as possible.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.K92.description()
'knot 9_34'

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.K92.description()
'knot 9_34'

K4 = ['knot 4_1', 3, (1, -2, 1, -2), None]

K4U = ['knot 4_1 plus one unlink', 4, (1, -2, 1, -2), [[3, 8, 4, 9], [9, 7, 10, 6], [7, 4, 8, 5], [5, 11, 6, 10], [11, 1, 12, 2], [12, 1, 3, 2]]]

K6 = ['knot 6_1', 4, (1, 1, 2, -1, -3, 2, -3), None]

K7 = ['knot 7_4', 4, (1, 1, 2, -1, 2, 2, 3, -2, 3), None]

K91 = ['knot 9_29', 4, (1, -2, -2, 3, -2, 1, -2, 3, -2), None]

K92 = ['knot 9_34', 4, (-1, 2, -1, 2, -3, 2, -1, 2, -3), None]

U1 = ['one unlink', 1, (), []]

U2 = ['two unlinks', 2, (), [[3, 1, 4, 2], [4, 1, 3, 2]]]

U3 = ['three unlinks', 3, (), [[3, 7, 4, 8], [4, 7, 5, 8], [5, 1, 6, 2], [6, 1, 3, 2]]]

U4 = ['four unlinks', 4, (), [[3, 9, 4, 10], [4, 9, 5, 10], [5, 11, 6, 12], [6, 11, 7, 12], [7, 1, 8, 2], [8, 1, 3, 2]]]

braid_tietze(strands_embed=None)

Return the Tietze representation of the braid corresponding to this basis element.

INPUT:

• strands_embed – (optional) the number of strands of the braid if strands should be added

OUTPUT: a tuple representing the braid in Tietze form

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.U2.braid_tietze()
()
sage: MarkovTraceModuleBasis.U2.braid_tietze(strands_embed=4)
(2, 3)

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.U2.braid_tietze()
()
>>> MarkovTraceModuleBasis.U2.braid_tietze(strands_embed=Integer(4))
(2, 3)

description()

Return a description of the link corresponding to this basis element.

In the case of knots it refers to the naming according to KnotInfo.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.U3.description()
'three unlinks'

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.U3.description()
'three unlinks'

link()

Return the Link that represents this basis element.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.U1.link()
Link with 1 component represented by 0 crossings
sage: MarkovTraceModuleBasis.K4.link()
Link with 1 component represented by 4 crossings

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.U1.link()
Link with 1 component represented by 0 crossings
>>> MarkovTraceModuleBasis.K4.link()
Link with 1 component represented by 4 crossings

links_gould_polynomial()

Return the Links-Gould polynomial of the link that represents this basis element.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.U1.links_gould_polynomial()
1
sage: MarkovTraceModuleBasis.U2.links_gould_polynomial()
0
sage: MarkovTraceModuleBasis.K4.links_gould_polynomial()
2*t0*t1 - 3*t0 - 3*t1 + t0*t1^-1 + 7 + t0^-1*t1
- 3*t1^-1 - 3*t0^-1 + 2*t0^-1*t1^-1

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.U1.links_gould_polynomial()
1
>>> MarkovTraceModuleBasis.U2.links_gould_polynomial()
0
>>> MarkovTraceModuleBasis.K4.links_gould_polynomial()
2*t0*t1 - 3*t0 - 3*t1 + t0*t1^-1 + 7 + t0^-1*t1
- 3*t1^-1 - 3*t0^-1 + 2*t0^-1*t1^-1

regular_homfly_polynomial()

Return the regular variant of the HOMFLY-PT polynomial of the link that represents this basis element.

This is the HOMFLY-PT polynomial renormalized by the writhe factor such that it is an invariant of regular isotopy.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.U1.regular_homfly_polynomial()
1
sage: u2 = MarkovTraceModuleBasis.U2.regular_homfly_polynomial(); u2
-L*M^-1 - L^-1*M^-1
sage: u2**2 == MarkovTraceModuleBasis.U3.regular_homfly_polynomial()
True
sage: u2**3 == MarkovTraceModuleBasis.U4.regular_homfly_polynomial()
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.U1.regular_homfly_polynomial()
1
>>> u2 = MarkovTraceModuleBasis.U2.regular_homfly_polynomial(); u2
-L*M^-1 - L^-1*M^-1
>>> u2**Integer(2) == MarkovTraceModuleBasis.U3.regular_homfly_polynomial()
True
>>> u2**Integer(3) == MarkovTraceModuleBasis.U4.regular_homfly_polynomial()
True

regular_kauffman_polynomial()

Return the regular variant of the Kauffman polynomial of the link that represents this basis element.

This is the Kauffman polynomial renormalized by the writhe factor such that it is an invariant of regular isotopy.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.U1.regular_homfly_polynomial()
1
sage: u2 = MarkovTraceModuleBasis.U2.regular_kauffman_polynomial(); u2
a*z^-1 - 1 + a^-1*z^-1
sage: u2**2 == MarkovTraceModuleBasis.U3.regular_kauffman_polynomial()
True
sage: u2**3 == MarkovTraceModuleBasis.U4.regular_kauffman_polynomial()
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.U1.regular_homfly_polynomial()
1
>>> u2 = MarkovTraceModuleBasis.U2.regular_kauffman_polynomial(); u2
a*z^-1 - 1 + a^-1*z^-1
>>> u2**Integer(2) == MarkovTraceModuleBasis.U3.regular_kauffman_polynomial()
True
>>> u2**Integer(3) == MarkovTraceModuleBasis.U4.regular_kauffman_polynomial()
True

strands()

Return the number of strands of the minimal braid representative of the link corresponding to self.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.K7.strands()
4

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.K7.strands()
4

writhe()

Return the writhe of the link corresponding to this basis element.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
sage: MarkovTraceModuleBasis.K4.writhe()
0
sage: MarkovTraceModuleBasis.K6.writhe()
1

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import MarkovTraceModuleBasis
>>> MarkovTraceModuleBasis.K4.writhe()
0
>>> MarkovTraceModuleBasis.K6.writhe()
1

sage.databases.cubic_hecke_db.create_demo_data(filename='demo_data.py')

Generate code for the functions inserted below to access the small cases of less than 4 strands as demonstration cases.

The code is written to a file with the given name from where it can be copied into this source file (in case a change is needed).

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import create_demo_data
sage: create_demo_data()   # not tested

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import create_demo_data
>>> create_demo_data()   # not tested

sage.databases.cubic_hecke_db.read_basis(num_strands=3)

Return precomputed data of Ivan Marin.

This code was generated by create_demo_data(), please do not edit.

INPUT:

• num_strands – integer; number of strands of the cubic Hecke algebra

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import read_basis
sage: read_basis(2)
[[], [1], [-1]]

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import read_basis
>>> read_basis(Integer(2))
[[], [1], [-1]]

sage.databases.cubic_hecke_db.read_irr(variables, num_strands=3)

Return precomputed data of Ivan Marin.

This code was generated by create_demo_data(), please do not edit.

INPUT:

• variables – tuple containing the indeterminates of the representation

• num_strands – integer; number of strands of the cubic Hecke algebra

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import read_irr
sage: L.<a, b, c, j> = LaurentPolynomialRing(ZZ)
sage: read_irr((a, b, c, j), 2)
([1, 1, 1],
[[{(0, 0): a}], [{(0, 0): c}], [{(0, 0): b}]],
[[{(0, 0): a^-1}], [{(0, 0): c^-1}], [{(0, 0): b^-1}]])

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import read_irr
>>> L = LaurentPolynomialRing(ZZ, names=('a', 'b', 'c', 'j',)); (a, b, c, j,) = L._first_ngens(4)
>>> read_irr((a, b, c, j), Integer(2))
([1, 1, 1],
[[{(0, 0): a}], [{(0, 0): c}], [{(0, 0): b}]],
[[{(0, 0): a^-1}], [{(0, 0): c^-1}], [{(0, 0): b^-1}]])

sage.databases.cubic_hecke_db.read_markov(bas_ele, variables, num_strands=4)

Return precomputed Markov trace coefficients.

This code was generated by create_markov_trace_data.py (from the database_cubic_hecke repository), please do not edit.

INPUT:

• bas_ele – an element of MarkovTraceModuleBasis

• variables – tuple consisting of the variables used in the coefficients

• num_strands – integer (default: 4); the number of strands

OUTPUT:

A list of the coefficients. The i’th member corresponds to the i’th basis element.

EXAMPLES:

Sage

sage: # needs sympy
sage: from sage.databases.cubic_hecke_db import read_markov
sage: from sympy import var
sage: u, v, w, s = var('u, v, w, s')
sage: variables = (u, v, w, s)
sage: read_markov('U2', variables, num_strands=3)
[0, s, 1/s, s, 1/s, 0, 0, 0, 0, -s*v, s, s, -s*u/w, -v/s, 1/s,
 0, 0, 0, 0, 1/s, -u/(s*w), -v/s, 0, 0]

Python

>>> from sage.all import *
>>> # needs sympy
>>> from sage.databases.cubic_hecke_db import read_markov
>>> from sympy import var
>>> u, v, w, s = var('u, v, w, s')
>>> variables = (u, v, w, s)
>>> read_markov('U2', variables, num_strands=Integer(3))
[0, s, 1/s, s, 1/s, 0, 0, 0, 0, -s*v, s, s, -s*u/w, -v/s, 1/s,
 0, 0, 0, 0, 1/s, -u/(s*w), -v/s, 0, 0]

sage.databases.cubic_hecke_db.read_regl(variables, num_strands=3)

Return precomputed data of Ivan Marin.

This code was generated by create_demo_data(), please do not edit.

INPUT:

• variables – tuple containing the indeterminates of the representation

• num_strands – integer; number of strands of the cubic Hecke algebra

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import read_regl
sage: L.<u, v, w> = LaurentPolynomialRing(ZZ)
sage: read_regl((u, v, w), 2)
([3],
[[{(0, 1): -v, (0, 2): 1, (1, 0): 1, (1, 1): u, (2, 1): w}]],
[[{(0, 1): 1, (0, 2): -u*w^-1, (1, 2): w^-1, (2, 0): 1, (2, 2): v*w^-1}]])

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import read_regl
>>> L = LaurentPolynomialRing(ZZ, names=('u', 'v', 'w',)); (u, v, w,) = L._first_ngens(3)
>>> read_regl((u, v, w), Integer(2))
([3],
[[{(0, 1): -v, (0, 2): 1, (1, 0): 1, (1, 1): u, (2, 1): w}]],
[[{(0, 1): 1, (0, 2): -u*w^-1, (1, 2): w^-1, (2, 0): 1, (2, 2): v*w^-1}]])

sage.databases.cubic_hecke_db.read_regr(variables, num_strands=3)

Return precomputed data of Ivan Marin.

This code was generated by create_demo_data(), please do not edit.

INPUT:

• variables – tuple containing the indeterminates of the representation

• num_strands – integer; number of strands of the cubic Hecke algebra

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import read_regr
sage: L.<u, v, w> = LaurentPolynomialRing(ZZ)
sage: read_regr((u, v, w), 2)
([3],
[[{(0, 1): -v, (0, 2): 1, (1, 0): 1, (1, 1): u, (2, 1): w}]],
[[{(0, 1): 1, (0, 2): -u*w^-1, (1, 2): w^-1, (2, 0): 1, (2, 2): v*w^-1}]])

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import read_regr
>>> L = LaurentPolynomialRing(ZZ, names=('u', 'v', 'w',)); (u, v, w,) = L._first_ngens(3)
>>> read_regr((u, v, w), Integer(2))
([3],
[[{(0, 1): -v, (0, 2): 1, (1, 0): 1, (1, 1): u, (2, 1): w}]],
[[{(0, 1): 1, (0, 2): -u*w^-1, (1, 2): w^-1, (2, 0): 1, (2, 2): v*w^-1}]])

sage.databases.cubic_hecke_db.simplify(mat)

Convert a matrix to a dictionary consisting of flat Python objects.

INPUT:

• mat – matrix to be converted into a dict

OUTPUT:

A dict from which mat can be reconstructed via element construction. The values of the dictionary may be dictionaries of tuples of integers or strings.

EXAMPLES:

Sage

sage: from sage.databases.cubic_hecke_db import simplify
sage: import sage.algebras.hecke_algebras.cubic_hecke_base_ring as chbr
sage: ER.<a, b, c> = chbr.CubicHeckeExtensionRing()
sage: mat = matrix(ER, [[2*a, -3], [c, 4*b*~c]]); mat
[     2*a       -3]
[       c 4*b*c^-1]
sage: simplify(mat)
{(0, 0): {(1, 0, 0): {0: 2}},
 (0, 1): {(0, 0, 0): {0: -3}},
 (1, 0): {(0, 0, 1): {0: 1}},
 (1, 1): {(0, 1, -1): {0: 4}}}
sage: mat == matrix(ER, _)
True
sage: F = ER.fraction_field()
sage: matf = mat.change_ring(F)
sage: simplify(matf)
{(0, 0): '2*a', (0, 1): '-3', (1, 0): 'c', (1, 1): '4*b/c'}
sage: matf == matrix(F, _)
True

Python

>>> from sage.all import *
>>> from sage.databases.cubic_hecke_db import simplify
>>> import sage.algebras.hecke_algebras.cubic_hecke_base_ring as chbr
>>> ER = chbr.CubicHeckeExtensionRing(names=('a', 'b', 'c',)); (a, b, c,) = ER._first_ngens(3)
>>> mat = matrix(ER, [[Integer(2)*a, -Integer(3)], [c, Integer(4)*b*~c]]); mat
[     2*a       -3]
[       c 4*b*c^-1]
>>> simplify(mat)
{(0, 0): {(1, 0, 0): {0: 2}},
 (0, 1): {(0, 0, 0): {0: -3}},
 (1, 0): {(0, 0, 1): {0: 1}},
 (1, 1): {(0, 1, -1): {0: 4}}}
>>> mat == matrix(ER, _)
True
>>> F = ER.fraction_field()
>>> matf = mat.change_ring(F)
>>> simplify(matf)
{(0, 0): '2*a', (0, 1): '-3', (1, 0): 'c', (1, 1): '4*b/c'}
>>> matf == matrix(F, _)
True