Cubic Hecke Algebras¶
We consider the factors of the group algebra of the Artin braid groups such that the images \(s_i\) of the braid generators satisfy a cubic equation:
Here \(u, v, w\) are elements in an arbitrary integral domain and \(i\) is a
positive integer less than \(n\), the number of the braid group’s strands.
By the analogue to the Iwahori Hecke algebras (see
IwahoriHeckeAlgebra), in which the
braid generators satisfy a quadratic relation these algebras have been called
cubic Hecke algebras. The relations inherited from the braid group are:
The algebra epimorphism from the braid group algebra over the same base ring is realized inside the element constructor of the present class, for example in the case of the 3 strand cubic Hecke algebra:
sage: CHA3 = algebras.CubicHecke(3)
sage: BG3 = CHA3.braid_group()
sage: braid = BG3((1,2,-1,2,2,-1)); braid
c0*c1*c0^-1*c1^2*c0^-1
sage: braid_image = CHA3(braid); braid_image
u*c1*c0^-1*c1 + u*v*c0*c1^-1*c0^-1 - u^2*c0^-1*c1
+ ((u^2*v-v^2)/w)*c0*c1*c0^-1 + ((u^2-v)/w)*c0*c1*c0
- ((u^3-u*v)/w)*c0*c1 - (u*v-w)*c1^-1
>>> from sage.all import *
>>> CHA3 = algebras.CubicHecke(Integer(3))
>>> BG3 = CHA3.braid_group()
>>> braid = BG3((Integer(1),Integer(2),-Integer(1),Integer(2),Integer(2),-Integer(1))); braid
c0*c1*c0^-1*c1^2*c0^-1
>>> braid_image = CHA3(braid); braid_image
u*c1*c0^-1*c1 + u*v*c0*c1^-1*c0^-1 - u^2*c0^-1*c1
+ ((u^2*v-v^2)/w)*c0*c1*c0^-1 + ((u^2-v)/w)*c0*c1*c0
- ((u^3-u*v)/w)*c0*c1 - (u*v-w)*c1^-1
If the ring elements \(u, v, w\) (which will be called the cubic equation
parameters in the sequel) are taken to be \(u = v = 0, w = 1\) the cubic Hecke
algebra specializes to the group algebra of the cubic braid group, which is
the factor group of the Artin braid group under setting the generators order
to be three. These groups can be obtained by
CubicHeckeAlgebra.cubic_braid_group().
It is well known, that these algebras are free of finite rank as long as the number of braid generators is less than six and infinite dimensional else wise. In the former (non trivial) cases they are also known as cyclotomic Hecke algebras corresponding to the complex reflection groups having Shepard-Todd number \(4\), \(25\) and \(32\).
Since the Broué, Malle, Rouquiere conjecture has been proved (for references of these cases see [Mar2012]) there exists a finite free basis of the cubic Hecke algebra which is in bijection to the cubic braid group and compatible with the specialization to the cubic braid group algebra as explained above.
For the algebras corresponding to braid groups of less than five strands such a basis has been calculated by Ivan Marin. This one is used here. In the case of 5 strands such a basis is not available, right now. Instead the elements of the cubic braid group class themselves are used as basis elements. This is also the case when the cubic braid group is infinite, even though it is not known if these elements span all of the cubic Hecke algebra.
Accordingly, be aware that the module embedding of the group algebra of the cubicbraid groups is known to be an isomorphism of free modules only in the cases of less than five strands.
EXAMPLES:
Consider the obstruction b of the triple quadratic algebra from Section 2.6
of [Mar2018]. We verify that the third power of it is a scalar multiple
of itself (explicitly 2*w^2 times the Schur element of the three
dimensional irreducible representation):
sage: CHA3 = algebras.CubicHecke(3)
sage: c1, c2 = CHA3.gens()
sage: b = c1^2*c2 - c2*c1^2 - c1*c2^2 + c2^2*c1; b
w*c0^-1*c1 - w*c0*c1^-1 - w*c1*c0^-1 + w*c1^-1*c0
sage: b2 = b*b
sage: b3 = b2*b
sage: BR = CHA3.base_ring()
sage: ER = CHA3.extension_ring()
sage: u, v, w = BR.gens()
sage: f = BR(b3.coefficients()[0]/w)
sage: try:
....: sh = CHA3.schur_element(CHA3.irred_repr.W3_111)
....: except NotImplementedError: # for the case GAP3 / CHEVIE not available
....: sh = ER(f/(2*w^2))
sage: ER(f/(2*w^2)) == sh
True
sage: b3 == f*b
True
>>> from sage.all import *
>>> CHA3 = algebras.CubicHecke(Integer(3))
>>> c1, c2 = CHA3.gens()
>>> b = c1**Integer(2)*c2 - c2*c1**Integer(2) - c1*c2**Integer(2) + c2**Integer(2)*c1; b
w*c0^-1*c1 - w*c0*c1^-1 - w*c1*c0^-1 + w*c1^-1*c0
>>> b2 = b*b
>>> b3 = b2*b
>>> BR = CHA3.base_ring()
>>> ER = CHA3.extension_ring()
>>> u, v, w = BR.gens()
>>> f = BR(b3.coefficients()[Integer(0)]/w)
>>> try:
... sh = CHA3.schur_element(CHA3.irred_repr.W3_111)
... except NotImplementedError: # for the case GAP3 / CHEVIE not available
... sh = ER(f/(Integer(2)*w**Integer(2)))
>>> ER(f/(Integer(2)*w**Integer(2))) == sh
True
>>> b3 == f*b
True
Defining the cubic Hecke algebra on 6 strands will need some seconds for initializing. However, you can do calculations inside the infinite algebra as well:
sage: # optional - database_cubic_hecke
sage: CHA6 = algebras.CubicHecke(6)
sage: CHA6.inject_variables()
Defining c0, c1, c2, c3, c4
sage: s = c0*c1*c2*c3*c4; s
c0*c1*c2*c3*c4
sage: s^2
(c0*c1*c2*c3*c4)^2
sage: t = CHA6.an_element() * c4; t
(-w)*c0*c1^-1*c4 + v*c0*c2^-1*c4 + u*c2*c1*c4 + ((-v*w+u)/w)*c4
>>> from sage.all import *
>>> # optional - database_cubic_hecke
>>> CHA6 = algebras.CubicHecke(Integer(6))
>>> CHA6.inject_variables()
Defining c0, c1, c2, c3, c4
>>> s = c0*c1*c2*c3*c4; s
c0*c1*c2*c3*c4
>>> s**Integer(2)
(c0*c1*c2*c3*c4)^2
>>> t = CHA6.an_element() * c4; t
(-w)*c0*c1^-1*c4 + v*c0*c2^-1*c4 + u*c2*c1*c4 + ((-v*w+u)/w)*c4
REFERENCES:
AUTHORS:
Sebastian Oehms May 2020: initial version
- class sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeAlgebra(names, cubic_equation_parameters=None, cubic_equation_roots=None)[source]¶
Bases:
CombinatorialFreeModuleReturn the Cubic-Hecke algebra with respect to the Artin braid group on \(n\) strands.
This is a quotient of the group algebra of the Artin braid group, such that the images \(s_i\) (\(1 \leq i < n\)) of the braid generators satisfy a cubic equation (see
cubic_hecke_algebrafor more information, in a session typesage.algebras.hecke_algebras.cubic_hecke_algebra?):\[s_i^3 = u s_i^2 - v s_i + w.\]The base ring of this algebra can be specified by giving optional keywords described below. If no keywords are given, the base ring will be a
CubicHeckeRingOfDefinition, which is constructed as the polynomial ring in \(u, v, w\) over the integers localized at \(w\). This ring will be called the ring of definition or sometimes for short generic base ring. However note, that in this context the word generic should not remind in a generic point of the corresponding scheme.In addition to the base ring, another ring containing the roots (\(a\), \(b\) and \(c\)) of the cubic equation will be needed to handle the split irreducible representations. This ring will be called the extension ring. Generically, the extension ring will be a
CubicHeckeExtensionRing, which is constructed as the Laurent polynomial ring in \(a, b\) and \(c\) over the integers adjoined with a primitive third root of unity. A special form of this generic extension ring is constructed as aSplittingAlgebrafor the roots of the cubic equation and a primitive third root of unity over the ring of definition. This ring will be called the default extension ring.This class uses a static and a dynamic data library. The first one is defined as instance of
CubicHeckeDataBaseand contains the complete basis for the algebras with less than 5 strands and various types of representation matrices of the generators. These data have been calculated by Ivan Marin and have been imported from his corresponding web page.Note that just the data for the cubic Hecke algebras on less than four strands is available in Sage by default. To deal with four strands and more you need to install the optional package database_cubic_hecke by typing
sage -i database_cubic_hecke(first time installation) orsage -f database_cubic_hecke(reinstallation) respectivesage -i -c database_cubic_hecke(for running all test in concern)sage -f -c database_cubic_hecke
This will add a Python wrapper around Ivan Marin’s data to the Sage library. For more installation hints see the documentation of this wrapper.
Furthermore, representation matrices can be obtained from the
CHEVIEpackage ofGAP3via theGAP3interface ifGAP3is installed inside Sage. For more information on how to obtain representation matrices to elements of this class, see the documentation of the element classCubicHeckeElementor its methodmatrix():algebras.CubicHecke.Element?oralgebras.CubicHecke.Element.matrix?The second library is created as instance of
CubicHeckeFileCacheand used while working with the class to achieve a better performance. This file cache contains images of braids and representation matrices of basis elements from former calculations. A refresh of the file cache can be done using thereset_filecache().INPUT:
names– string containing the names of the generators as images of the braid group generatorscubic_equation_parameters– tuple(u, v, w)of three elements in an integral domain used as coefficients in the cubic equation. If this argument is given the base ring will be set to the common parent ofu, v, w. In addition a conversion map from the generic base ring is supplied. This keyword can also be used to change the variable names of the generic base ring (see example 3 below)cubic_equation_roots– tuple(a, b, c)of three elements in an integral domain which stand for the roots of the cubic equation. If this argument is given the extension ring will be set to the common parent ofa, b, c. In addition a conversion map from the generic extension ring and the generic base ring is supplied. This keyword can also be used to change the variable names of the generic extension ring (see example 3 below)
EXAMPLES:
Cubic Hecke algebra over the ring of definition:
sage: CHA3 = algebras.CubicHecke('s1, s2'); CHA3 Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) with cubic equation: h^3 - u*h^2 + v*h - w = 0 sage: CHA3.gens() (s1, s2) sage: GER = CHA3.extension_ring(generic=True); GER Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring sage: ER = CHA3.extension_ring(); ER Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - u*h^2 + v*h - w with roots [a, b, -b - a + u] over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke('s1, s2'); CHA3 Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) with cubic equation: h^3 - u*h^2 + v*h - w = 0 >>> CHA3.gens() (s1, s2) >>> GER = CHA3.extension_ring(generic=True); GER Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring >>> ER = CHA3.extension_ring(); ER Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - u*h^2 + v*h - w with roots [a, b, -b - a + u] over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
Element construction:
sage: ele = CHA3.an_element(); ele -w*s1*s2^-1 + v*s1 + u*s2 - ((v*w-u)/w) sage: ele2 = ele**2; ele2 w^2*(s1^-1*s2)^2 - u*w^2*s1^-1*s2*s1^-1 - v*w*s2*s1^-1*s2 - v*w^2*s1^-1*s2^-1 + u*w*s1*s2*s1^-1*s2 - u*w*s1^-1*s2*s1 - (u*v*w-2*v*w+2*u)*s1*s2^-1 + u*v*w*s2*s1^-1 + u*v*s2*s1 + v^2*w*s1^-1 - u^2*w*s1*s2*s1^-1 + ((u*v^2*w-2*v^2*w-u*w^2+2*u*v)/w)*s1 + u*v*s1*s2 + (u^2*w+v^2*w)*s2^-1 + ((u^3*w-2*u*v*w+2*u^2)/w)*s2 - ((u^2*v*w^2+v^3*w^2-v^2*w^2+2*u*v*w-u^2)/w^2) sage: B3 = CHA3.braid_group() sage: braid = B3((2,-1, 2, 1)); braid s2*s1^-1*s2*s1 sage: ele3 = CHA3(braid); ele3 s1*s2*s1^-1*s2 + u*s1^-1*s2*s1 - v*s1*s2^-1 + v*s2^-1*s1 - u*s1*s2*s1^-1 sage: ele3t = CHA3((2,-1, 2, 1)) sage: ele3 == ele3t True sage: CHA4 = algebras.CubicHecke(4) # optional database_cubic_hecke sage: ele4 = CHA4(ele3); ele4 # optional database_cubic_hecke c0*c1*c0^-1*c1 + u*c0^-1*c1*c0 + (-v)*c0*c1^-1 + v*c1^-1*c0 + (-u)*c0*c1*c0^-1
>>> from sage.all import * >>> ele = CHA3.an_element(); ele -w*s1*s2^-1 + v*s1 + u*s2 - ((v*w-u)/w) >>> ele2 = ele**Integer(2); ele2 w^2*(s1^-1*s2)^2 - u*w^2*s1^-1*s2*s1^-1 - v*w*s2*s1^-1*s2 - v*w^2*s1^-1*s2^-1 + u*w*s1*s2*s1^-1*s2 - u*w*s1^-1*s2*s1 - (u*v*w-2*v*w+2*u)*s1*s2^-1 + u*v*w*s2*s1^-1 + u*v*s2*s1 + v^2*w*s1^-1 - u^2*w*s1*s2*s1^-1 + ((u*v^2*w-2*v^2*w-u*w^2+2*u*v)/w)*s1 + u*v*s1*s2 + (u^2*w+v^2*w)*s2^-1 + ((u^3*w-2*u*v*w+2*u^2)/w)*s2 - ((u^2*v*w^2+v^3*w^2-v^2*w^2+2*u*v*w-u^2)/w^2) >>> B3 = CHA3.braid_group() >>> braid = B3((Integer(2),-Integer(1), Integer(2), Integer(1))); braid s2*s1^-1*s2*s1 >>> ele3 = CHA3(braid); ele3 s1*s2*s1^-1*s2 + u*s1^-1*s2*s1 - v*s1*s2^-1 + v*s2^-1*s1 - u*s1*s2*s1^-1 >>> ele3t = CHA3((Integer(2),-Integer(1), Integer(2), Integer(1))) >>> ele3 == ele3t True >>> CHA4 = algebras.CubicHecke(Integer(4)) # optional database_cubic_hecke >>> ele4 = CHA4(ele3); ele4 # optional database_cubic_hecke c0*c1*c0^-1*c1 + u*c0^-1*c1*c0 + (-v)*c0*c1^-1 + v*c1^-1*c0 + (-u)*c0*c1*c0^-1
Cubic Hecke algebra over the ring of definition using different variable names:
sage: algebras.CubicHecke(3, cubic_equation_parameters='u, v, w', cubic_equation_roots='p, q, r') Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) with cubic equation: h^3 - u*h^2 + v*h - w = 0 sage: _.extension_ring() Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - u*h^2 + v*h - w with roots [p, q, -q - p + u] over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
>>> from sage.all import * >>> algebras.CubicHecke(Integer(3), cubic_equation_parameters='u, v, w', cubic_equation_roots='p, q, r') Cubic Hecke algebra on 3 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) with cubic equation: h^3 - u*h^2 + v*h - w = 0 >>> _.extension_ring() Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - u*h^2 + v*h - w with roots [p, q, -q - p + u] over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
Cubic Hecke algebra over a special base ring with respect to a special cubic equation:
sage: algebras.CubicHecke('s1, s2', cubic_equation_parameters=(QQ(1),3,1)) Cubic Hecke algebra on 3 strands over Rational Field with cubic equation: h^3 - h^2 + 3*h - 1 = 0 sage: CHA3 = _ sage: ER = CHA3.extension_ring(); ER Number Field in T with defining polynomial T^12 + 4*T^11 + 51*T^10 + 154*T^9 + 855*T^8 + 1880*T^7 + 5805*T^6 + 8798*T^5 + 15312*T^4 + 14212*T^3 + 13224*T^2 + 5776*T + 1444 sage: CHA3.cubic_equation_roots()[0] -4321/1337904*T^11 - 4181/445968*T^10 - 4064/27873*T^9 - 51725/167238*T^8 - 2693189/1337904*T^7 - 1272907/445968*T^6 - 704251/74328*T^5 - 591488/83619*T^4 - 642145/83619*T^3 + 252521/111492*T^2 + 45685/5868*T + 55187/17604 sage: F = GF(25,'u') sage: algebras.CubicHecke('s1, s2', cubic_equation_parameters=(F(1), F.gen(), F(3))) Cubic Hecke algebra on 3 strands over Finite Field in u of size 5^2 with cubic equation: h^3 + 4*h^2 + u*h + 2 = 0 sage: CHA3 = _ sage: ER = CHA3.extension_ring(); ER Finite Field in S of size 5^4 sage: CHA3.cubic_equation_roots() [2*S^3 + 2*S^2 + 2*S + 1, 2*S^3 + 3*S^2 + 3*S + 2, S^3 + 3]
>>> from sage.all import * >>> algebras.CubicHecke('s1, s2', cubic_equation_parameters=(QQ(Integer(1)),Integer(3),Integer(1))) Cubic Hecke algebra on 3 strands over Rational Field with cubic equation: h^3 - h^2 + 3*h - 1 = 0 >>> CHA3 = _ >>> ER = CHA3.extension_ring(); ER Number Field in T with defining polynomial T^12 + 4*T^11 + 51*T^10 + 154*T^9 + 855*T^8 + 1880*T^7 + 5805*T^6 + 8798*T^5 + 15312*T^4 + 14212*T^3 + 13224*T^2 + 5776*T + 1444 >>> CHA3.cubic_equation_roots()[Integer(0)] -4321/1337904*T^11 - 4181/445968*T^10 - 4064/27873*T^9 - 51725/167238*T^8 - 2693189/1337904*T^7 - 1272907/445968*T^6 - 704251/74328*T^5 - 591488/83619*T^4 - 642145/83619*T^3 + 252521/111492*T^2 + 45685/5868*T + 55187/17604 >>> F = GF(Integer(25),'u') >>> algebras.CubicHecke('s1, s2', cubic_equation_parameters=(F(Integer(1)), F.gen(), F(Integer(3)))) Cubic Hecke algebra on 3 strands over Finite Field in u of size 5^2 with cubic equation: h^3 + 4*h^2 + u*h + 2 = 0 >>> CHA3 = _ >>> ER = CHA3.extension_ring(); ER Finite Field in S of size 5^4 >>> CHA3.cubic_equation_roots() [2*S^3 + 2*S^2 + 2*S + 1, 2*S^3 + 3*S^2 + 3*S + 2, S^3 + 3]
Cubic Hecke algebra over a special extension ring with respect to special roots of the cubic equation:
sage: UCF = UniversalCyclotomicField() sage: e3=UCF.gen(3); e5=UCF.gen(5) sage: algebras.CubicHecke('s1, s2', cubic_equation_roots=(1, e5, e3)) Cubic Hecke algebra on 3 strands over Universal Cyclotomic Field with cubic equation: h^3 + (-E(15) - E(15)^4 - E(15)^7 + E(15)^8)*h^2 + (-E(15)^2 - E(15)^8 - E(15)^11 - E(15)^13 - E(15)^14)*h - E(15)^8 = 0
>>> from sage.all import * >>> UCF = UniversalCyclotomicField() >>> e3=UCF.gen(Integer(3)); e5=UCF.gen(Integer(5)) >>> algebras.CubicHecke('s1, s2', cubic_equation_roots=(Integer(1), e5, e3)) Cubic Hecke algebra on 3 strands over Universal Cyclotomic Field with cubic equation: h^3 + (-E(15) - E(15)^4 - E(15)^7 + E(15)^8)*h^2 + (-E(15)^2 - E(15)^8 - E(15)^11 - E(15)^13 - E(15)^14)*h - E(15)^8 = 0
- Element[source]¶
alias of
CubicHeckeElement
- algebra_generators()[source]¶
Return the algebra generators of
self.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.algebra_generators() Finite family {c: c}
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.algebra_generators() Finite family {c: c}
- base_ring(generic=False)[source]¶
Return the base ring of
self.INPUT:
generic– boolean (default:False); ifTruethe ring of definition (here often called the generic base ring) is returned
EXAMMPLES:
sage: CHA2 = algebras.CubicHecke(2, cubic_equation_roots=(3, 4, 5)) sage: CHA2.base_ring() Integer Ring localized at (2, 3, 5) sage: CHA2.base_ring(generic=True) Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA2.base_ring() Integer Ring localized at (2, 3, 5) >>> CHA2.base_ring(generic=True) Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
- braid_group()[source]¶
Return the braid group attached to
self.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.braid_group() Braid group on 2 strands
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.braid_group() Braid group on 2 strands
- braid_group_algebra()[source]¶
Return the group algebra of braid group attached to
selfover the base ring ofself.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.braid_group_algebra() Algebra of Braid group on 2 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.braid_group_algebra() Algebra of Braid group on 2 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
- characters(irr=None, original=True)[source]¶
Return the irreducible characters of
self.By default the values are given in the generic extension ring. Setting the keyword
originaltoFalseyou can obtain the values in the (non generic) extension ring (compare the same keyword forCubicHeckeElement.matrix()).INPUT:
irr– (optional) instance ofAbsIrreducibeRepselecting the irreducible representation corresponding to the character; if not given a list of all characters is returnedoriginal– boolean (default:True); see description above
OUTPUT:
Function or list of Functions from the element class of
selfto the (generic or non generic) extension ring depending on the given keyword arguments.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ch = CHA3.characters() sage: e = CHA3.an_element() sage: ch[0](e) a^2*b + a^2*c + a^2 - b*c + b^-1*c^-1 + a^-1*c^-1 + a^-1*b^-1 sage: _.parent() Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring sage: ch_w3_100 = CHA3.characters(irr=CHA3.irred_repr.W3_100) sage: ch_w3_100(e) == ch[0](e) True sage: ch_x = CHA3.characters(original=False) sage: ch_x[0](e) (u + v)*a + (-v*w - w^2 + u)/w sage: _.parent() Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - u*h^2 + v*h - w with roots [a, b, -b - a + u] over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ch = CHA3.characters() >>> e = CHA3.an_element() >>> ch[Integer(0)](e) a^2*b + a^2*c + a^2 - b*c + b^-1*c^-1 + a^-1*c^-1 + a^-1*b^-1 >>> _.parent() Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring >>> ch_w3_100 = CHA3.characters(irr=CHA3.irred_repr.W3_100) >>> ch_w3_100(e) == ch[Integer(0)](e) True >>> ch_x = CHA3.characters(original=False) >>> ch_x[Integer(0)](e) (u + v)*a + (-v*w - w^2 + u)/w >>> _.parent() Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Splitting Algebra of h^3 - u*h^2 + v*h - w with roots [a, b, -b - a + u] over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
- chevie()[source]¶
Return the
GAP3-CHEVIErealization of the corresponding cyclotomic Hecke algebra in the finite-dimensional case.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) # optional gap3 sage: CHA3.chevie() # optional gap3 Hecke(G4,[[a,b,c]])
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) # optional gap3 >>> CHA3.chevie() # optional gap3 Hecke(G4,[[a,b,c]])
- cubic_braid_group()[source]¶
Return the cubic braid group attached to
self.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.cubic_braid_group() Cubic Braid group on 2 strands
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.cubic_braid_group() Cubic Braid group on 2 strands
- cubic_braid_group_algebra()[source]¶
Return the group algebra of cubic braid group attached to
selfover the base ring ofself.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.cubic_braid_group_algebra() Algebra of Cubic Braid group on 2 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.cubic_braid_group_algebra() Algebra of Cubic Braid group on 2 strands over Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,)
- cubic_equation(var='h', as_coefficients=False, generic=False)[source]¶
Return the cubic equation attached to
self.INPUT:
var– string (default:'h'); setting the indeterminate of the equationas_coefficients– boolean (default:False); if set toTruethe list of coefficients is returnedgeneric– boolean (default:False); if set toTruethe cubic equation will be given over the generic base ring
OUTPUT:
A polynomial over the base ring (resp. generic base ring if
genericis set to True). In caseas_coefficientsis set toTruea list of them is returned.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2, cubic_equation_roots=(E(3), ~E(3), 1)) sage: CHA2.cubic_equation() h^3 - 1 sage: CHA2.cubic_equation(generic=True) h^3 - u*h^2 + v*h - w sage: CHA2.cubic_equation(as_coefficients=True, generic=True) [-w, v, -u, 1] sage: CHA2.cubic_equation(as_coefficients=True) [-1, 0, 0, 1]
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2), cubic_equation_roots=(E(Integer(3)), ~E(Integer(3)), Integer(1))) >>> CHA2.cubic_equation() h^3 - 1 >>> CHA2.cubic_equation(generic=True) h^3 - u*h^2 + v*h - w >>> CHA2.cubic_equation(as_coefficients=True, generic=True) [-w, v, -u, 1] >>> CHA2.cubic_equation(as_coefficients=True) [-1, 0, 0, 1]
- cubic_equation_parameters(generic=False)[source]¶
Return the coefficients of the underlying cubic equation.
INPUT:
generic– boolean (default:False); if set toTruethe coefficients are returned as elements of the generic base ring
OUTPUT: a triple consisting of the coefficients
EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2, cubic_equation_roots=(3, 4, 5)) sage: CHA2.cubic_equation() h^3 - 12*h^2 + 47*h - 60 sage: CHA2.cubic_equation_parameters() [12, 47, 60] sage: CHA2.cubic_equation_parameters(generic=True) [u, v, w]
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA2.cubic_equation() h^3 - 12*h^2 + 47*h - 60 >>> CHA2.cubic_equation_parameters() [12, 47, 60] >>> CHA2.cubic_equation_parameters(generic=True) [u, v, w]
- cubic_equation_roots(generic=False)[source]¶
Return the roots of the underlying cubic equation.
INPUT:
generic– boolean (default:False); if set toTruethe roots are returned as elements of the generic extension ring
OUTPUT: a triple consisting of the roots
EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2, cubic_equation_roots=(3, 4, 5)) sage: CHA2.cubic_equation() h^3 - 12*h^2 + 47*h - 60 sage: CHA2.cubic_equation_roots() [3, 4, 5] sage: CHA2.cubic_equation_roots(generic=True) [a, b, c]
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA2.cubic_equation() h^3 - 12*h^2 + 47*h - 60 >>> CHA2.cubic_equation_roots() [3, 4, 5] >>> CHA2.cubic_equation_roots(generic=True) [a, b, c]
- cubic_hecke_subalgebra(nstrands=None)[source]¶
Return a
CubicHeckeAlgebrathat realizes a sub-algebra ofselfon the firstn_strandsstrands.INPUT:
nstrands– integer at least 1 and at moststrands()giving the number of strands for the subgroup; the default is one strand less thanselfhas
OUTPUT: an instance of this class realizing the sub-algebra
EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3, cubic_equation_roots=(3, 4, 5)) sage: CHA3.cubic_hecke_subalgebra() Cubic Hecke algebra on 2 strands over Integer Ring localized at (2, 3, 5) with cubic equation: h^3 - 12*h^2 + 47*h - 60 = 0
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA3.cubic_hecke_subalgebra() Cubic Hecke algebra on 2 strands over Integer Ring localized at (2, 3, 5) with cubic equation: h^3 - 12*h^2 + 47*h - 60 = 0
- cyclotomic_generator(generic=False)[source]¶
Return the third root of unity as element of the extension ring.
The only thing where this is needed is in the nine dimensional irreducible representations of the cubic Hecke algebra on four strands (see the examples of
CubicHeckeElement.matrix()for instance).INPUT:
generic– boolean (default:False); ifTruethe cyclotomic generator is returned as an element extension ring of definition
EXAMMPLES:
sage: CHA2 = algebras.CubicHecke(2, cubic_equation_roots=(3, 4, 5)) sage: CHA2.cyclotomic_generator() E3 sage: CHA2.cyclotomic_generator(generic=True) e3
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA2.cyclotomic_generator() E3 >>> CHA2.cyclotomic_generator(generic=True) e3
- extension_ring(generic=False)[source]¶
Return the extension ring of
self.This is an extension of its base ring containing the roots of the cubic equation.
INPUT:
generic– boolean (default:False); ifTruethe extension ring of definition (here often called the generic extension ring) is returned
EXAMMPLES:
sage: CHA2 = algebras.CubicHecke(2, cubic_equation_roots=(3, 4, 5)) sage: CHA2.extension_ring() Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Integer Ring localized at (2, 3, 5) sage: CHA2.extension_ring(generic=True) Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA2.extension_ring() Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Integer Ring localized at (2, 3, 5) >>> CHA2.extension_ring(generic=True) Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring
- filecache_section()[source]¶
Return the
enumto select a section in the file cache.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: list(CHA2.filecache_section()) [<section.matrix_representations: 'matrix_representations'>, <section.braid_images: 'braid_images'>, <section.basis_extensions: 'basis_extensions'>, <section.markov_trace: 'markov_trace'>]
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> list(CHA2.filecache_section()) [<section.matrix_representations: 'matrix_representations'>, <section.braid_images: 'braid_images'>, <section.basis_extensions: 'basis_extensions'>, <section.markov_trace: 'markov_trace'>]
- garside_involution(element)[source]¶
Return the image of the given element of
selfunder the extension of the Garside involution of braids toself.This method may be invoked by the
revert_garsidemethod of the element class ofself, alternatively.INPUT:
element– instance of the element class ofself
OUTPUT:
Instance of the element class of
selfrepresenting the image ofelementunder the extension of the Garside involution toself.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element() sage: ele_gar = CHA3.garside_involution(ele); ele_gar -w*c1*c0^-1 + u*c0 + v*c1 - ((v*w-u)/w) sage: ele == CHA3.garside_involution(ele_gar) True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element() >>> ele_gar = CHA3.garside_involution(ele); ele_gar -w*c1*c0^-1 + u*c0 + v*c1 - ((v*w-u)/w) >>> ele == CHA3.garside_involution(ele_gar) True
- gen(i)[source]¶
The
i-th generator of the algebra.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.gen(0) c
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.gen(Integer(0)) c
- gens()[source]¶
Return the generators of
self.EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.gens() (c,)
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.gens() (c,)
- get_order()[source]¶
Return an ordering of the basis of
self.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: len(CHA3.get_order()) 24
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> len(CHA3.get_order()) 24
- irred_repr[source]¶
alias of
AbsIrreducibeRep
- is_filecache_empty(section=None)[source]¶
Return
Trueif the file cache of the givensectionis empty. If nosectionis given the answer is given for the complete file cache.INPUT:
section– (default: all sections) an element of enumsectionthat can be selected usingfilecache_section()
EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.is_filecache_empty() False
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.is_filecache_empty() False
- mirror_image()[source]¶
Return a copy of
selfwith the mirrored cubic equation, that is: the cubic equation has the inverse roots to the roots with respect toself.This is needed since the mirror involution of the braid group does not factor through
self(considered as an algebra over the base ring, just considered as \(\ZZ\)-algebra). Therefore, the mirror involution of an element ofselfbelongs tomirror_image.OUTPUT:
A cubic Hecke algebra over the same base and extension ring, but whose cubic equation is transformed by the mirror involution applied to its coefficients and roots.
EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: ce = CHA2.cubic_equation(); ce h^3 - u*h^2 + v*h - w sage: CHA2m = CHA2.mirror_image() sage: cem = CHA2m.cubic_equation(); cem h^3 + ((-v)/w)*h^2 + u/w*h + (-1)/w sage: mi = CHA2.base_ring().mirror_involution(); mi Ring endomorphism of Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) Defn: u |--> v/w v |--> u/w w |--> 1/w sage: cem == cem.parent()([mi(cf) for cf in ce.coefficients()]) True
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> ce = CHA2.cubic_equation(); ce h^3 - u*h^2 + v*h - w >>> CHA2m = CHA2.mirror_image() >>> cem = CHA2m.cubic_equation(); cem h^3 + ((-v)/w)*h^2 + u/w*h + (-1)/w >>> mi = CHA2.base_ring().mirror_involution(); mi Ring endomorphism of Multivariate Polynomial Ring in u, v, w over Integer Ring localized at (w,) Defn: u |--> v/w v |--> u/w w |--> 1/w >>> cem == cem.parent()([mi(cf) for cf in ce.coefficients()]) True
Note that both cubic Hecke algebras have the same ring of definition and identical generic cubic equation:
sage: cemg = CHA2m.cubic_equation(generic=True) sage: CHA2.cubic_equation(generic=True) == cemg True sage: CHA2.cubic_equation() == cemg True sage: a, b, c = CHA2.cubic_equation_roots() sage: CHA2m.cubic_equation_roots(generic=True) == [a, b, c] True sage: CHA2m.cubic_equation_roots() [((-1)/(-w))*a^2 + (u/(-w))*a + (-v)/(-w), ((1/(-w))*a)*b + (1/(-w))*a^2 + ((-u)/(-w))*a, (((-1)/(-w))*a)*b] sage: ai, bi, ci = _ sage: ai == ~a, bi == ~b, ci == ~c (True, True, True) sage: CHA2.extension_ring(generic=True).mirror_involution() Ring endomorphism of Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring Defn: a |--> a^-1 b |--> b^-1 c |--> c^-1 with map of base ring
>>> from sage.all import * >>> cemg = CHA2m.cubic_equation(generic=True) >>> CHA2.cubic_equation(generic=True) == cemg True >>> CHA2.cubic_equation() == cemg True >>> a, b, c = CHA2.cubic_equation_roots() >>> CHA2m.cubic_equation_roots(generic=True) == [a, b, c] True >>> CHA2m.cubic_equation_roots() [((-1)/(-w))*a^2 + (u/(-w))*a + (-v)/(-w), ((1/(-w))*a)*b + (1/(-w))*a^2 + ((-u)/(-w))*a, (((-1)/(-w))*a)*b] >>> ai, bi, ci = _ >>> ai == ~a, bi == ~b, ci == ~c (True, True, True) >>> CHA2.extension_ring(generic=True).mirror_involution() Ring endomorphism of Multivariate Laurent Polynomial Ring in a, b, c over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring Defn: a |--> a^-1 b |--> b^-1 c |--> c^-1 with map of base ring
The mirror image can not be obtained for specialized cubic Hecke algebras if the specialization does not factor through the mirror involution on the ring if definition:
sage: CHA2s = algebras.CubicHecke(2, cubic_equation_roots=(3, 4, 5)) sage: CHA2s Cubic Hecke algebra on 2 strands over Integer Ring localized at (2, 3, 5) with cubic equation: h^3 - 12*h^2 + 47*h - 60 = 0
>>> from sage.all import * >>> CHA2s = algebras.CubicHecke(Integer(2), cubic_equation_roots=(Integer(3), Integer(4), Integer(5))) >>> CHA2s Cubic Hecke algebra on 2 strands over Integer Ring localized at (2, 3, 5) with cubic equation: h^3 - 12*h^2 + 47*h - 60 = 0
In the next example it is not clear what the mirror image of
7should be:sage: CHA2s.mirror_image() Traceback (most recent call last): ... RuntimeError: base ring Integer Ring localized at (2, 3, 5) does not factor through mirror involution
>>> from sage.all import * >>> CHA2s.mirror_image() Traceback (most recent call last): ... RuntimeError: base ring Integer Ring localized at (2, 3, 5) does not factor through mirror involution
- mirror_isomorphism(element)[source]¶
Return the image of the given element of
selfunder the extension of the mirror involution of braids toself. The mirror involution of a braid is given by inverting all generators in the braid word. It does not factor throughselfover the base ring but it factors throughselfconsidered as a \(\ZZ\)-module relative to the mirror automorphism of the generic base ring. Consideringselfas algebra over its base ring this involution defines an isomorphism ofselfonto a different cubic Hecke algebra with a different cubic equation. This is defined over a different base (and extension) ring thanself. It can be obtained by the methodmirror_imageor as parent of the output of this method.This method may be invoked by the
CubicHeckeElelemnt.revert_mirrormethod of the element class ofself, alternatively.INPUT:
element– instance of the element class ofself
OUTPUT:
Instance of the element class of the mirror image of
selfrepresenting the image of element under the extension of the braid mirror involution toself.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element() sage: ele_mirr = CHA3.mirror_isomorphism(ele); ele_mirr -1/w*c0^-1*c1 + u/w*c0^-1 + v/w*c1^-1 + ((v*w-u)/w) sage: ele_mirr2 = ele.revert_mirror() # indirect doctest sage: ele_mirr == ele_mirr2 True sage: par_mirr = ele_mirr.parent() sage: par_mirr == CHA3 False sage: par_mirr == CHA3.mirror_image() True sage: ele == par_mirr.mirror_isomorphism(ele_mirr) True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element() >>> ele_mirr = CHA3.mirror_isomorphism(ele); ele_mirr -1/w*c0^-1*c1 + u/w*c0^-1 + v/w*c1^-1 + ((v*w-u)/w) >>> ele_mirr2 = ele.revert_mirror() # indirect doctest >>> ele_mirr == ele_mirr2 True >>> par_mirr = ele_mirr.parent() >>> par_mirr == CHA3 False >>> par_mirr == CHA3.mirror_image() True >>> ele == par_mirr.mirror_isomorphism(ele_mirr) True
- ngens()[source]¶
The number of generators of the algebra.
EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.ngens() 1
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.ngens() 1
- one_basis()[source]¶
Return the index of the basis element for the identity element in the cubic braid group.
EXAMPLES:
sage: CHA2 = algebras.CubicHecke(2) sage: CHA2.one_basis() 1
>>> from sage.all import * >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> CHA2.one_basis() 1
- orientation_antiinvolution(element)[source]¶
Return the image of the given element of
selfunder the extension of the orientation anti involution of braids toself. The orientation anti involution of a braid is given by reversing the order of generators in the braid word.This method may be invoked by the
revert_orientationmethod of the element class ofself, alternatively.INPUT:
element– instance of the element class ofself
OUTPUT:
Instance of the element class of
selfrepresenting the image ofelementunder the extension of the orientation reversing braid involution toself.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element() sage: ele_ori = CHA3.orientation_antiinvolution(ele); ele_ori -w*c1^-1*c0 + v*c0 + u*c1 - ((v*w-u)/w) sage: ele == CHA3.orientation_antiinvolution(ele_ori) True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element() >>> ele_ori = CHA3.orientation_antiinvolution(ele); ele_ori -w*c1^-1*c0 + v*c0 + u*c1 - ((v*w-u)/w) >>> ele == CHA3.orientation_antiinvolution(ele_ori) True
- product_on_basis(g1, g2)[source]¶
Return product on basis elements indexed by
g1andg2.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: g = CHA3.basis().keys().an_element(); g c0*c1 sage: CHA3.product_on_basis(g, ~g) 1 sage: CHA3.product_on_basis(g, g) w*c0^-1*c1*c0 - v*c1*c0 + u*c0*c1*c0
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> g = CHA3.basis().keys().an_element(); g c0*c1 >>> CHA3.product_on_basis(g, ~g) 1 >>> CHA3.product_on_basis(g, g) w*c0^-1*c1*c0 - v*c1*c0 + u*c0*c1*c0
- repr_type[source]¶
alias of
RepresentationType
- reset_filecache(section=None, commit=True)[source]¶
Reset the file cache of the given
sectionresp. the complete file cache if nosectionis given.INPUT:
section– (default: all sections) an element of enumsectionthat can be selected usingfilecache_section()commit– boolean (default:True); if set toFalsethe reset is not written to the filesystem
EXAMPLES:
sage: # optional - database_cubic_hecke sage: CHA5 = algebras.CubicHecke(5) sage: be = CHA5.filecache_section().basis_extensions sage: CHA5.is_filecache_empty(be) False sage: CHA5.reset_filecache(be) sage: CHA5.is_filecache_empty(be) True
>>> from sage.all import * >>> # optional - database_cubic_hecke >>> CHA5 = algebras.CubicHecke(Integer(5)) >>> be = CHA5.filecache_section().basis_extensions >>> CHA5.is_filecache_empty(be) False >>> CHA5.reset_filecache(be) >>> CHA5.is_filecache_empty(be) True
- schur_element(item, generic=False)[source]¶
Return a single Schur element of
selfas elements of the extension ring ofself.Note
This method needs
GAP3installed with packageCHEVIE.INPUT:
item– an element ofAbsIrreducibeRepto give the irreducible representation ofselfto which the Schur element should be returnedgeneric– boolean (default:False); ifTrue, the element is returned as element of the generic extension ring
EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) # optional gap3 sage: CHA3.schur_element(CHA3.irred_repr.W3_111) # optional gap3 (u^3*w + v^3 - 6*u*v*w + 8*w^2)/w^2
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) # optional gap3 >>> CHA3.schur_element(CHA3.irred_repr.W3_111) # optional gap3 (u^3*w + v^3 - 6*u*v*w + 8*w^2)/w^2
- schur_elements(generic=False)[source]¶
Return the list of Schur elements of
selfas elements of the extension ring ofself.Note
This method needs
GAP3installed with packageCHEVIE.INPUT:
generic– boolean (default:False); ifTrue, the element is returned as element of the generic extension ring
EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) # optional gap3 sage: sch_eles = CHA3.schur_elements() # optional gap3 sage: sch_eles[6] # optional gap3 (u^3*w + v^3 - 6*u*v*w + 8*w^2)/w^2
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) # optional gap3 >>> sch_eles = CHA3.schur_elements() # optional gap3 >>> sch_eles[Integer(6)] # optional gap3 (u^3*w + v^3 - 6*u*v*w + 8*w^2)/w^2
- class sage.algebras.hecke_algebras.cubic_hecke_algebra.CubicHeckeElement[source]¶
Bases:
IndexedFreeModuleElementAn element of a
CubicHeckeAlgebra.For more information see
CubicHeckeAlgebra.EXAMPLES:
sage: CHA3s = algebras.CubicHecke('s1, s2'); CHA3s.an_element() -w*s1*s2^-1 + v*s1 + u*s2 - ((v*w-u)/w) sage: CHA3.<c1, c2> = algebras.CubicHecke(3) sage: c1**3*~c2 u*w*c1^-1*c2^-1 + (u^2-v)*c1*c2^-1 - (u*v-w)*c2^-1
>>> from sage.all import * >>> CHA3s = algebras.CubicHecke('s1, s2'); CHA3s.an_element() -w*s1*s2^-1 + v*s1 + u*s2 - ((v*w-u)/w) >>> CHA3 = algebras.CubicHecke(Integer(3), names=('c1', 'c2',)); (c1, c2,) = CHA3._first_ngens(2) >>> c1**Integer(3)*~c2 u*w*c1^-1*c2^-1 + (u^2-v)*c1*c2^-1 - (u*v-w)*c2^-1
- Tietze()[source]¶
Return the Tietze presentation of
selfifselfbelongs to the basis of its parent andNoneotherwise.OUTPUT:
A tuple representing the pre image braid of
selfifselfis a monomial from the basisNoneelse-wiseEXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) sage: ele.Tietze() is None True sage: [CHA3(sp).Tietze() for sp in ele.support()] [(), (1,), (1, -2), (2,)]
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) >>> ele.Tietze() is None True >>> [CHA3(sp).Tietze() for sp in ele.support()] [(), (1,), (1, -2), (2,)]
- braid_group_algebra_pre_image()[source]¶
Return a pre image of
selfin the group algebra of the braid group (with respect to the basis given by Ivan Marin).OUTPUT:
The pre image of
selfas instance of the element class of the group algebra of the BraidGroupEXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) sage: b_ele = ele.braid_group_algebra_pre_image(); b_ele -((v*w-u)/w) + v*c0 + u*c1 - w*c0*c1^-1 sage: ele in CHA3 True sage: b_ele in CHA3 False sage: b_ele in CHA3.braid_group_algebra() True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) >>> b_ele = ele.braid_group_algebra_pre_image(); b_ele -((v*w-u)/w) + v*c0 + u*c1 - w*c0*c1^-1 >>> ele in CHA3 True >>> b_ele in CHA3 False >>> b_ele in CHA3.braid_group_algebra() True
- cubic_braid_group_algebra_pre_image()[source]¶
Return a pre image of
selfin the group algebra of the cubic braid group.OUTPUT:
The pre image of
selfas instance of the element class of the group algebra of theCubicBraidGroup.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) sage: cb_ele = ele.cubic_braid_group_algebra_pre_image(); cb_ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) sage: ele in CHA3 True sage: cb_ele in CHA3 False sage: cb_ele in CHA3.cubic_braid_group_algebra() True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) >>> cb_ele = ele.cubic_braid_group_algebra_pre_image(); cb_ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) >>> ele in CHA3 True >>> cb_ele in CHA3 False >>> cb_ele in CHA3.cubic_braid_group_algebra() True
- formal_markov_trace(extended=False, field_embedding=False)[source]¶
Return a formal expression which can be specialized to Markov traces which factor through the cubic Hecke algebra.
This covers Markov traces corresponding to the
HOMFLY-PT polynomial,
Kauffman polynomial,
Links-Gould polynomial.
These expressions are elements of a sub-module of the module of linear forms on
selfthe base ring of which is an extension of the generic base ring ofselfby an additional variablesrepresenting the writhe factor. All variables of this base ring extension are invertible.A Markov trace is a family of class functions \(tr_n\) on the family of braid groups \(B_n\) into some commutative ring \(R\) depending on a unit \(s \in R\) such that for all \(b \in B_n\) the following two conditions are satisfied (see [Kau1991], section 7):
\[\begin{split}\begin{array}{lll} tr_{n+1}(b g_n) & = & s tr_n(b), \\ tr_{n+1}(b g^{-1}_n) & = & s^{-1} tr_n(b). \end{array}\end{split}\]The unit \(s\) is often called the writhe factor and corresponds to the additional variable mentioned above.
Note
Currently it is not known if all linear forms of this sub-module belong to a Markov trace, i.e. can be extended to the full tower of cubic Hecke algebras. Anyway, at least the four basis elements (
U1,U2,U3andK4) can be reconstructed form the HOMFLY-PT and Kauffman polynomial.INPUT:
extended– boolean (default:False); if set toTruethe base ring of the Markov trace module is constructed as an extension of generic extension ring ofself; per default it is constructed upon the generic base ringfield_embedding– boolean (default:False); if set toTruethe base ring of the module is the smallest field containing the generic extension ring ofself; ignored ifextended=False
EXAMPLES:
sage: from sage.knots.knotinfo import KnotInfo sage: CHA2 = algebras.CubicHecke(2) sage: K3_1 = KnotInfo.K3_1 sage: b3_1 = CHA2(K3_1.braid()) sage: mt3_1 = b3_1.formal_markov_trace(); mt3_1 ((u^2*s^2-v*s^2+u*w)/s)*B[U1] - (u*v-w)*B[U2] sage: mt3_1.parent() Free module generated by {U1, U2} over Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u) sage: f = b3_1.formal_markov_trace(extended=True); f (a^2*b*c*s^-1+a*b^2*c*s^-1+a*b*c^2*s^-1+a^2*s+a*b*s+b^2*s+a*c*s+b*c*s+c^2*s)*B[U1] + (-a^2*b-a*b^2-a^2*c+(-2)*a*b*c-b^2*c-a*c^2-b*c^2)*B[U2] sage: f.parent().base_ring() Multivariate Laurent Polynomial Ring in a, b, c, s over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring sage: f = b3_1.formal_markov_trace(extended=True, field_embedding=True); f ((a^2*b*c+a*b^2*c+a*b*c^2+a^2*s^2+a*b*s^2+b^2*s^2+a*c*s^2+b*c*s^2+c^2*s^2)/s)*B[U1] - (a^2*b+a*b^2+a^2*c+2*a*b*c+b^2*c+a*c^2+b*c^2)*B[U2] sage: f.parent().base_ring() Fraction Field of Multivariate Polynomial Ring in a, b, c, s over Cyclotomic Field of order 3 and degree 2
>>> from sage.all import * >>> from sage.knots.knotinfo import KnotInfo >>> CHA2 = algebras.CubicHecke(Integer(2)) >>> K3_1 = KnotInfo.K3_1 >>> b3_1 = CHA2(K3_1.braid()) >>> mt3_1 = b3_1.formal_markov_trace(); mt3_1 ((u^2*s^2-v*s^2+u*w)/s)*B[U1] - (u*v-w)*B[U2] >>> mt3_1.parent() Free module generated by {U1, U2} over Multivariate Polynomial Ring in u, v, w, s over Integer Ring localized at (s, w, v, u) >>> f = b3_1.formal_markov_trace(extended=True); f (a^2*b*c*s^-1+a*b^2*c*s^-1+a*b*c^2*s^-1+a^2*s+a*b*s+b^2*s+a*c*s+b*c*s+c^2*s)*B[U1] + (-a^2*b-a*b^2-a^2*c+(-2)*a*b*c-b^2*c-a*c^2-b*c^2)*B[U2] >>> f.parent().base_ring() Multivariate Laurent Polynomial Ring in a, b, c, s over Splitting Algebra of x^2 + x + 1 with roots [e3, -e3 - 1] over Integer Ring >>> f = b3_1.formal_markov_trace(extended=True, field_embedding=True); f ((a^2*b*c+a*b^2*c+a*b*c^2+a^2*s^2+a*b*s^2+b^2*s^2+a*c*s^2+b*c*s^2+c^2*s^2)/s)*B[U1] - (a^2*b+a*b^2+a^2*c+2*a*b*c+b^2*c+a*c^2+b*c^2)*B[U2] >>> f.parent().base_ring() Fraction Field of Multivariate Polynomial Ring in a, b, c, s over Cyclotomic Field of order 3 and degree 2
Obtaining the well known link invariants from it:
sage: MT = mt3_1.base_ring() sage: sup = mt3_1.support() sage: u, v, w, s = mt3_1.base_ring().gens() sage: LK3_1 = mt3_1*s**-3 # since the writhe of K3_1 is 3 sage: f = MT.specialize_homfly() sage: g = sum(f(LK3_1.coefficient(b)) * b.regular_homfly_polynomial() for b in sup); g L^-2*M^2 - 2*L^-2 - L^-4 sage: g == K3_1.link().homfly_polynomial() True sage: f = MT.specialize_kauffman() sage: g = sum(f(LK3_1.coefficient(b)) * b.regular_kauffman_polynomial() for b in sup); g a^-2*z^2 - 2*a^-2 + a^-3*z + a^-4*z^2 - a^-4 + a^-5*z sage: g == K3_1.kauffman_polynomial() True sage: f = MT.specialize_links_gould() sage: g = sum(f(LK3_1.coefficient(b)) * b.links_gould_polynomial() for b in sup); g -t0^2*t1 - t0*t1^2 + t0^2 + 2*t0*t1 + t1^2 - t0 - t1 + 1 sage: g == K3_1.link().links_gould_polynomial() True
>>> from sage.all import * >>> MT = mt3_1.base_ring() >>> sup = mt3_1.support() >>> u, v, w, s = mt3_1.base_ring().gens() >>> LK3_1 = mt3_1*s**-Integer(3) # since the writhe of K3_1 is 3 >>> f = MT.specialize_homfly() >>> g = sum(f(LK3_1.coefficient(b)) * b.regular_homfly_polynomial() for b in sup); g L^-2*M^2 - 2*L^-2 - L^-4 >>> g == K3_1.link().homfly_polynomial() True >>> f = MT.specialize_kauffman() >>> g = sum(f(LK3_1.coefficient(b)) * b.regular_kauffman_polynomial() for b in sup); g a^-2*z^2 - 2*a^-2 + a^-3*z + a^-4*z^2 - a^-4 + a^-5*z >>> g == K3_1.kauffman_polynomial() True >>> f = MT.specialize_links_gould() >>> g = sum(f(LK3_1.coefficient(b)) * b.links_gould_polynomial() for b in sup); g -t0^2*t1 - t0*t1^2 + t0^2 + 2*t0*t1 + t1^2 - t0 - t1 + 1 >>> g == K3_1.link().links_gould_polynomial() True
- matrix(subdivide=False, representation_type=None, original=False)[source]¶
Return certain types of matrix representations of
self.The absolutely irreducible representations of the cubic Hecke algebra are constructed using the
GAP3interface and theCHEVIEpackage ifGAP3andCHEVIEare installed on the system. Furthermore, the representations given on Ivan Marin’s homepage are used:INPUT:
subdivide– boolean (default:False); this boolean is passed to the block_matrix functionrepresentation_type– instance of enumRepresentationType; this can be obtained by the attributeCubicHeckeAlgebra.repr_typeofself; the following values are possible:RegularLeft– (regular left repr. from the above URL)RegularRight– (regular right repr. from the above URL)SplitIrredChevie– (split irred. repr. via CHEVIE)SplitIrredMarin– (split irred. repr. from the above URL)default:
SplitIrredChevietaken if GAP3 and CHEVIE are installed on the system, otherwise the default will beSplitIrredMarin
original– boolean (default:False); if set toTruethe base ring of the matrix will be the generic base_ring resp. generic extension ring (for the split versions) of the parent ofself
OUTPUT:
An instance of
CubicHeckeMatrixRep, which is inherited fromMatrix_generic_dense. In the case of the irreducible representations the matrix is given as a block matrix. Each single irreducible can be obtained as item indexed by the members of the enumAbsIrreducibeRepavailable viaCubicHeckeAlgebra.irred_repr. For details type:CubicHeckeAlgebra.irred_repr?.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: CHA3.inject_variables() Defining c0, c1 sage: c0m = c0.matrix() sage: c0m[CHA3.irred_repr.W3_111] [ -b - a + u 0 0] [(-2*a + u)*b - 2*a^2 + 2*u*a - v b 0] [ b 1 a]
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> CHA3.inject_variables() Defining c0, c1 >>> c0m = c0.matrix() >>> c0m[CHA3.irred_repr.W3_111] [ -b - a + u 0 0] [(-2*a + u)*b - 2*a^2 + 2*u*a - v b 0] [ b 1 a]
using the
representation_typeoption:sage: CHA3.<c0, c1> = algebras.CubicHecke(3) # optional gap3 sage: chevie = CHA3.repr_type.SplitIrredChevie # optional gap3 sage: c0m_ch = c0.matrix(representation_type=chevie) # optional gap3 sage: c0m_ch[CHA3.irred_repr.W3_011] # optional gap3 [ b 0] [ -b -b - a + u] sage: c0m[CHA3.irred_repr.W3_011] [ b 0] [a^2 - u*a + v -b - a + u]
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3), names=('c0', 'c1',)); (c0, c1,) = CHA3._first_ngens(2)# optional gap3 >>> chevie = CHA3.repr_type.SplitIrredChevie # optional gap3 >>> c0m_ch = c0.matrix(representation_type=chevie) # optional gap3 >>> c0m_ch[CHA3.irred_repr.W3_011] # optional gap3 [ b 0] [ -b -b - a + u] >>> c0m[CHA3.irred_repr.W3_011] [ b 0] [a^2 - u*a + v -b - a + u]
using the
originaloption:sage: c0mo = c0.matrix(original=True) sage: c0mo_ch = c0.matrix(representation_type=chevie, original=True) # optional gap3 sage: c0mo[CHA3.irred_repr.W3_011] [ b 0] [b*c c] sage: c0mo_ch[CHA3.irred_repr.W3_011] # optional gap3 [ b 0] [-b c]
>>> from sage.all import * >>> c0mo = c0.matrix(original=True) >>> c0mo_ch = c0.matrix(representation_type=chevie, original=True) # optional gap3 >>> c0mo[CHA3.irred_repr.W3_011] [ b 0] [b*c c] >>> c0mo_ch[CHA3.irred_repr.W3_011] # optional gap3 [ b 0] [-b c]
specialized matrices:
sage: t = (3,7,11) sage: CHA4 = algebras.CubicHecke(4, cubic_equation_roots=t) # optional database_cubic_hecke sage: e = CHA4.an_element(); e # optional database_cubic_hecke -231*c0*c1^-1 + 131*c0*c2^-1 + 21*c2*c1 - 1440/11 sage: em = e.matrix() # optional database_cubic_hecke sage: em.base_ring() # optional database_cubic_hecke Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Integer Ring localized at (3, 7, 11) sage: em.dimensions() # optional database_cubic_hecke (108, 108) sage: em_irr24 = em[23] # optional database_cubic_hecke sage: em_irr24.dimensions() # optional database_cubic_hecke (9, 9) sage: em_irr24[3,2] # optional database_cubic_hecke -131*E3 - 393/7 sage: emg = e.matrix(representation_type=chevie) # optional gap3 database_cubic_hecke sage: emg_irr24 = emg[23] # optional gap3 database_cubic_hecke sage: emg_irr24[3,2] # optional gap3 database_cubic_hecke -131*E3 - 393/7
>>> from sage.all import * >>> t = (Integer(3),Integer(7),Integer(11)) >>> CHA4 = algebras.CubicHecke(Integer(4), cubic_equation_roots=t) # optional database_cubic_hecke >>> e = CHA4.an_element(); e # optional database_cubic_hecke -231*c0*c1^-1 + 131*c0*c2^-1 + 21*c2*c1 - 1440/11 >>> em = e.matrix() # optional database_cubic_hecke >>> em.base_ring() # optional database_cubic_hecke Splitting Algebra of T^2 + T + 1 with roots [E3, -E3 - 1] over Integer Ring localized at (3, 7, 11) >>> em.dimensions() # optional database_cubic_hecke (108, 108) >>> em_irr24 = em[Integer(23)] # optional database_cubic_hecke >>> em_irr24.dimensions() # optional database_cubic_hecke (9, 9) >>> em_irr24[Integer(3),Integer(2)] # optional database_cubic_hecke -131*E3 - 393/7 >>> emg = e.matrix(representation_type=chevie) # optional gap3 database_cubic_hecke >>> emg_irr24 = emg[Integer(23)] # optional gap3 database_cubic_hecke >>> emg_irr24[Integer(3),Integer(2)] # optional gap3 database_cubic_hecke -131*E3 - 393/7
- max_len()[source]¶
Return the maximum of the length of Tietze expressions among the support of
self.EXAMPLES:
sage: CHA3 = algebras.CubicHecke(3) sage: ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) sage: ele.max_len() 2
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3)) >>> ele = CHA3.an_element(); ele -w*c0*c1^-1 + v*c0 + u*c1 - ((v*w-u)/w) >>> ele.max_len() 2
- revert_garside()[source]¶
Return the image of
selfunder the Garside involution.EXAMPLES:
sage: roots = (E(3), ~E(3), 1) sage: CHA3.<c1, c2> = algebras.CubicHecke(3, cubic_equation_roots=roots) sage: e = CHA3.an_element(); e -c1*c2^-1 sage: _.revert_garside() -c2*c1^-1 sage: _.revert_garside() -c1*c2^-1
>>> from sage.all import * >>> roots = (E(Integer(3)), ~E(Integer(3)), Integer(1)) >>> CHA3 = algebras.CubicHecke(Integer(3), cubic_equation_roots=roots, names=('c1', 'c2',)); (c1, c2,) = CHA3._first_ngens(2) >>> e = CHA3.an_element(); e -c1*c2^-1 >>> _.revert_garside() -c2*c1^-1 >>> _.revert_garside() -c1*c2^-1
- revert_mirror()[source]¶
Return the image of
selfunder the mirror isomorphism.EXAMPLES:
sage: CHA3.<c1, c2> = algebras.CubicHecke(3) sage: e = CHA3.an_element() sage: e.revert_mirror() -1/w*c0^-1*c1 + u/w*c0^-1 + v/w*c1^-1 + ((v*w-u)/w) sage: _.revert_mirror() == e True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3), names=('c1', 'c2',)); (c1, c2,) = CHA3._first_ngens(2) >>> e = CHA3.an_element() >>> e.revert_mirror() -1/w*c0^-1*c1 + u/w*c0^-1 + v/w*c1^-1 + ((v*w-u)/w) >>> _.revert_mirror() == e True
- revert_orientation()[source]¶
Return the image of
selfunder the anti involution reverting the orientation of braids.EXAMPLES:
sage: CHA3.<c1, c2> = algebras.CubicHecke(3) sage: e = CHA3.an_element() sage: e.revert_orientation() -w*c2^-1*c1 + v*c1 + u*c2 - ((v*w-u)/w) sage: _.revert_orientation() == e True
>>> from sage.all import * >>> CHA3 = algebras.CubicHecke(Integer(3), names=('c1', 'c2',)); (c1, c2,) = CHA3._first_ngens(2) >>> e = CHA3.an_element() >>> e.revert_orientation() -w*c2^-1*c1 + v*c1 + u*c2 - ((v*w-u)/w) >>> _.revert_orientation() == e True