def __init__(self, R, n, q=None):
"""
TESTS::
sage: HeckeAlgebraSymmetricGroupT(QQ, 3)
Hecke algebra of the symmetric group of order 3 on the T basis over Univariate Polynomial Ring in q over Rational Field
::
sage: HeckeAlgebraSymmetricGroupT(QQ, 3, q=1)
Hecke algebra of the symmetric group of order 3 with q=1 on the T basis over Rational Field
"""
self.n = n
self._basis_keys = permutation.Permutations(n)
self._name = "Hecke algebra of the symmetric group of order %s"%self.n
self._one = permutation.Permutation(range(1,n+1))
if q is None:
q = PolynomialRing(R, 'q').gen()
R = q.parent()
else:
if q not in R:
raise ValueError, "q must be in R (= %s)"%R
self._name += " with q=%s"%q
self._q = q
CombinatorialAlgebra.__init__(self, R)
# _repr_ customization: output the basis element indexed by [1,2,3] as [1,2,3]
self.print_options(prefix="")
def graph_implementation_rec(skp, weight, length, function):
"""
TESTS::
sage: from sage.combinat.ribbon_tableau import graph_implementation_rec, list_rec
sage: graph_implementation_rec(SkewPartition([[1], []]), [1], 1, list_rec)
[[[], [[1]]]]
sage: graph_implementation_rec(SkewPartition([[2, 1], []]), [1, 2], 1, list_rec)
[[[], [[2], [1, 2]]]]
sage: graph_implementation_rec(SkewPartition([[], []]), [0], 1, list_rec)
[[[], []]]
"""
if sum(weight) == 0:
weight = []
partp = skp[0].conjugate()
## Some tests in order to know if the shape and the weight are compatible.
if weight != [] and weight[-1] <= len(partp):
perms = permutation.Permutations([0] * (len(partp) - weight[-1]) +
[length] * (weight[-1])).list()
else:
return function([], [], skp, weight, length)
selection = []
for j in range(len(perms)):
retire = [(partp[i] + len(partp) - (i + 1) - perms[j][i])
for i in range(len(partp))]
retire.sort(reverse=True)
retire = [retire[i] - len(partp) + (i + 1) for i in range(len(retire))]
if retire[-1] >= 0 and retire == [i for i in reversed(sorted(retire))]:
retire = Partition([x for x in retire if x != 0]).conjugate()
# Cutting branches if the retired partition has a line strictly included into the inner one
append = True
padded_retire = retire + [0] * (len(skp[1]) - len(retire))
for k in range(len(skp[1])):
if padded_retire[k] - skp[1][k] < 0:
append = False
break
if append:
selection.append([retire, perms[j]])
#selection contains the list of current nodes
#print "selection", selection
if len(weight) == 1:
return function([], selection, skp, weight, length)
else:
#The recursive calls permit us to construct the list of the sons
#of all current nodes in selection
a = [
graph_implementation_rec([p[0], skp[1]], weight[:-1], length,
function) for p in selection
]
#print "a", a
return function(a, selection, skp, weight, length)
def _conjugacy_classes_representatives_underlying_group(self):
r"""
Return a complete list of representatives of conjugacy
classes of the underlying symmetric group.
EXAMPLES::
sage: SG=SymmetricGroupAlgebra(ZZ,3)
sage: SG._conjugacy_classes_representatives_underlying_group()
[[2, 3, 1], [2, 1, 3], [1, 2, 3]]
"""
return [permutation.Permutations(self.n).element_in_conjugacy_classes(nu) for nu in partition.Partitions(self.n)]
def __init__(self, R, n):
"""
TESTS::
sage: QS3 = SymmetricGroupAlgebra(QQ, 3)
sage: TestSuite(QS3).run()
"""
self.n = n
self._name = "Symmetric group algebra of order %s"%self.n
CombinatorialFreeModule.__init__(self, R, permutation.Permutations(n), prefix='', latex_prefix='', category = (GroupAlgebras(R),FiniteDimensionalAlgebrasWithBasis(R)))
# This is questionable, and won't be inherited properly
if n > 0:
S = SymmetricGroupAlgebra(R, n-1)
self.register_coercion(S.canonical_embedding(self))
def __init__(self, R):
"""
EXAMPLES::
sage: X = SchubertPolynomialRing(QQ)
sage: X == loads(dumps(X))
True
"""
self._name = "Schubert polynomial ring with X basis"
self._repr_option_bracket = False
self._one = permutation.Permutation([1])
CombinatorialAlgebra.__init__(self,
R,
cc=permutation.Permutations(),
category=GradedAlgebrasWithBasis(R))
self.print_options(prefix='X')
def _coerce_start(self, x):
"""
EXAMPLES::
sage: H3 = HeckeAlgebraSymmetricGroupT(QQ, 3)
sage: H3._coerce_start([2,1])
T[2, 1, 3]
"""
###################################################
# Coerce permutations of size smaller that self.n #
###################################################
if x == []:
return self( self._one )
if len(x) < self.n and x in permutation.Permutations():
return self( list(x) + range(len(x)+1, self.n+1) )
raise TypeError
def divided_difference(self, i):
"""
EXAMPLES::
sage: X = SchubertPolynomialRing(ZZ)
sage: a = X([3,2,1])
sage: a.divided_difference(1)
X[2, 3, 1]
sage: a.divided_difference([3,2,1])
X[1]
"""
if isinstance(i, Integer):
return symmetrica.divdiff_schubert(i, self)
elif i in permutation.Permutations():
return symmetrica.divdiff_perm_schubert(i, self)
else:
raise TypeError, "i must either be an integer or permutation"
