code stringlengths 17 6.64M |
|---|
class CycleSpeciesStructure(GenericSpeciesStructure):
def __repr__(self):
'\n EXAMPLES::\n\n sage: S = species.CycleSpecies()\n sage: S.structures(["a","b","c"])[0]\n (\'a\', \'b\', \'c\')\n '
s = GenericSpeciesStructure.__repr__(self)
return... |
class CycleSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
@staticmethod
@accept_size
def __classcall__(cls, *args, **kwds):
'\n EXAMPLES::\n\n sage: C = species.CycleSpecies(); C\n Cyclic permutation species\n '
return super().__classcall__... |
class EmptySpecies(GenericCombinatorialSpecies, UniqueRepresentation):
'\n Returns the empty species. This species has no structure at all.\n It is the zero of the semi-ring of species.\n\n EXAMPLES::\n\n sage: X = species.EmptySpecies(); X\n Empty species\n sage: X.structures([]).li... |
class FunctorialCompositionStructure(GenericSpeciesStructure):
pass
|
class FunctorialCompositionSpecies(GenericCombinatorialSpecies):
def __init__(self, F, G, min=None, max=None, weight=None):
"\n Returns the functorial composition of two species.\n\n EXAMPLES::\n\n sage: E = species.SetSpecies()\n sage: E2 = species.SetSpecies(size=2)\... |
class OrdinaryGeneratingSeries(LazyPowerSeries):
'\n A class for ordinary generating series.\n\n Note that it is just a :class:`LazyPowerSeries` whose elements\n have some extra methods.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.generating_series import OrdinaryGeneratingSeriesRing\n ... |
class OrdinaryGeneratingSeriesRing(LazyPowerSeriesRing):
'\n Return the ring of ordinary generating series over ``R``.\n\n Note that it is just a\n :class:`LazyPowerSeriesRing` whose elements have\n some extra methods.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.generating_series imp... |
class ExponentialGeneratingSeries(LazyPowerSeries):
'\n A class for ordinary generating series.\n\n Note that it is just a\n :class:`LazyPowerSeries` whose elements have\n some extra methods.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.generating_series import OrdinaryGeneratingSerie... |
class ExponentialGeneratingSeriesRing(LazyPowerSeriesRing):
'\n Return the ring of exponential generating series over ``R``.\n\n Note that it is just a\n :class:`LazyPowerSeriesRing` whose elements have\n some extra methods.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.generating_seri... |
class CycleIndexSeries(LazySymmetricFunction):
def count(self, t):
'\n Return the number of structures corresponding to a certain cycle\n type ``t``.\n\n EXAMPLES::\n\n sage: # needs sage.modules\n sage: from sage.combinat.species.generating_series import CycleI... |
class CycleIndexSeriesRing(LazySymmetricFunctions):
'\n Return the ring of cycle index series over ``R``.\n\n This is the ring of formal power series `\\Lambda[x]`, where\n `\\Lambda` is the ring of symmetric functions over ``R`` in the\n `p`-basis. Its purpose is to house the cycle index series of\n ... |
@cached_function
def _exp_term(n, R=QQ):
'\n Compute the order-``n`` term of the cycle index series of the species\n `E` of sets.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.generating_series import _exp_term\n sage: [_exp_term(i) for i in range(4)] ... |
@cached_function
def ExponentialCycleIndexSeries(R=QQ):
'\n Return the cycle index series of the species `E` of sets.\n\n This cycle index satisfies\n\n .. MATH::\n\n Z_{E} = \\sum_{n \\geq 0} \\sum_{\\lambda \\vdash n}\n \\frac{p_{\\lambda}}{z_{\\lambda}}.\n\n EXAMPLES::\n\n sage... |
@cached_function
def _cl_term(n, R=QQ):
'\n Compute the order-``n`` term of the cycle index series of\n the virtual species `\\Omega`, the compositional inverse of\n the species `E^{+}` of nonempty sets.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.generating_series import _cl_term\n ... |
@cached_function
def LogarithmCycleIndexSeries(R=QQ):
"\n Return the cycle index series of the virtual species `\\Omega`, the\n compositional inverse of the species `E^{+}` of nonempty sets.\n\n The notion of virtual species is treated thoroughly in [BLL1998]_.\n The specific algorithm used here to co... |
@cached_function
def SimpleGraphSpecies():
'\n Return the species of simple graphs.\n\n EXAMPLES::\n\n sage: S = species.SimpleGraphSpecies()\n sage: S.generating_series().counts(10)\n [1, 1, 2, 8, 64, 1024, 32768, 2097152, 268435456, 68719476736]\n sage: S.cycle_index_series()[:... |
@cached_function
def BinaryTreeSpecies():
'\n Return the species of binary trees on `n` leaves.\n\n The species of binary trees `B` is defined by `B = X + B \\cdot B`,\n where `X` is the singleton species.\n\n EXAMPLES::\n\n sage: B = species.BinaryTreeSpecies()\n sage: B.generating_seri... |
@cached_function
def BinaryForestSpecies():
'\n Return the species of binary forests.\n\n Binary forests are defined as sets of binary trees.\n\n EXAMPLES::\n\n sage: F = species.BinaryForestSpecies()\n sage: F.generating_series().counts(10)\n [1, 1, 3, 19, 193, 2721, 49171, 1084483,... |
class LinearOrderSpeciesStructure(GenericSpeciesStructure):
def canonical_label(self):
'\n EXAMPLES::\n\n sage: P = species.LinearOrderSpecies()\n sage: s = P.structures(["a", "b", "c"]).random_element()\n sage: s.canonical_label()\n [\'a\', \'b\', \'c\'... |
class LinearOrderSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
@staticmethod
@accept_size
def __classcall__(cls, *args, **kwds):
'\n EXAMPLES::\n\n sage: L = species.LinearOrderSpecies(); L\n Linear order species\n '
return super().__class... |
def change_support(perm, support, change_perm=None):
'\n Changes the support of a permutation defined on [1, ..., n] to\n support.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.misc import change_support\n sage: p = PermutationGroupElement((1,2,3)); p\n (1,2,3)\n sage: c... |
def accept_size(f):
'\n The purpose of this decorator is to change calls like\n species.SetSpecies(size=1) to species.SetSpecies(min=1, max=2).\n This is to make caching species easier and to restrict the number\n of parameters that the lower level code needs to know about.\n\n EXAMPLES::\n\n ... |
class PartitionSpeciesStructure(GenericSpeciesStructure):
def __init__(self, parent, labels, list):
"\n EXAMPLES::\n\n sage: from sage.combinat.species.partition_species import PartitionSpeciesStructure\n sage: P = species.PartitionSpecies()\n sage: s = PartitionSp... |
class PartitionSpecies(GenericCombinatorialSpecies):
@staticmethod
@accept_size
def __classcall__(cls, *args, **kwds):
'\n EXAMPLES::\n\n sage: P = species.PartitionSpecies(); P\n Partition species\n '
return super().__classcall__(cls, *args, **kwds)
... |
class PermutationSpeciesStructure(GenericSpeciesStructure):
def canonical_label(self):
'\n EXAMPLES::\n\n sage: P = species.PermutationSpecies()\n sage: S = P.structures(["a", "b", "c"])\n sage: [s.canonical_label() for s in S]\n [[\'a\', \'b\', \'c\'],\... |
class PermutationSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
@staticmethod
@accept_size
def __classcall__(cls, *args, **kwds):
'\n EXAMPLES::\n\n sage: P = species.PermutationSpecies(); P\n Permutation species\n '
return super().__classcal... |
class ProductSpeciesStructure(GenericSpeciesStructure):
def __init__(self, parent, labels, subset, left, right):
"\n TESTS::\n\n sage: S = species.SetSpecies()\n sage: F = S * S\n sage: a = F.structures(['a','b','c']).random_element()\n sage: a == loads(... |
class ProductSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
def __init__(self, F, G, min=None, max=None, weight=None):
'\n EXAMPLES::\n\n sage: X = species.SingletonSpecies()\n sage: A = X*X\n sage: A.generating_series()[0:4]\n [0, 0, 1, 0]\... |
class CombinatorialSpeciesStructure(SpeciesStructureWrapper):
pass
|
class CombinatorialSpecies(GenericCombinatorialSpecies):
def __init__(self, min=None):
'\n EXAMPLES::\n\n sage: F = CombinatorialSpecies()\n sage: loads(dumps(F))\n Combinatorial species\n\n ::\n\n sage: X = species.SingletonSpecies()\n ... |
class SetSpeciesStructure(GenericSpeciesStructure):
def __repr__(self):
'\n EXAMPLES::\n\n sage: S = species.SetSpecies()\n sage: a = S.structures(["a","b","c"]).random_element(); a\n {\'a\', \'b\', \'c\'}\n '
s = GenericSpeciesStructure.__repr__(sel... |
class SetSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
@staticmethod
@accept_size
def __classcall__(cls, *args, **kwds):
'\n EXAMPLES::\n\n sage: E = species.SetSpecies(); E\n Set species\n '
return super().__classcall__(cls, *args, **kwds... |
class GenericCombinatorialSpecies(SageObject):
def __init__(self, min=None, max=None, weight=None):
'\n TESTS::\n\n sage: P = species.PermutationSpecies(size=3)\n sage: P._weight\n 1\n sage: P._min\n 3\n sage: P._max\n 4\... |
class GenericSpeciesStructure(CombinatorialObject):
def __init__(self, parent, labels, list):
'\n This is a base class from which the classes for the structures inherit.\n\n EXAMPLES::\n\n sage: from sage.combinat.species.structure import GenericSpeciesStructure\n sage... |
class SpeciesStructureWrapper(GenericSpeciesStructure):
def __init__(self, parent, s, **options):
'\n This is a class for the structures of species such as the sum\n species that do not provide "additional" structure. For example,\n if you have the sum `C` of species `A` and `B`,\n ... |
class SpeciesWrapper(CombinatorialClass):
def __init__(self, species, labels, iterator, generating_series, name, structure_class):
'\n This is a abstract base class for the set of structures of a\n species as well as the set of isotypes of the species.\n\n .. note::\n\n On... |
class StructuresWrapper(SpeciesWrapper):
def __init__(self, species, labels, structure_class):
'\n A base class for the set of structures of a species with given\n set of labels. An object of this type is returned when you\n call the :meth:`structures` method of a species.\n\n ... |
class IsotypesWrapper(SpeciesWrapper):
def __init__(self, species, labels, structure_class):
'\n A base class for the set of isotypes of a species with given\n set of labels. An object of this type is returned when you\n call the :meth:`isotypes` method of a species.\n\n EXAM... |
class SimpleStructuresWrapper(SpeciesWrapper):
def __init__(self, species, labels, structure_class):
'\n .. warning::\n\n This is deprecated and currently not used for anything.\n\n EXAMPLES::\n\n sage: F = species.SetSpecies()\n sage: S = F.structures([1,2,... |
class SimpleIsotypesWrapper(SpeciesWrapper):
def __init__(self, species, labels, structure_class):
'\n .. warning::\n\n This is deprecated and currently not used for anything.\n\n EXAMPLES::\n\n sage: F = species.SetSpecies()\n sage: S = F.structures([1,2,3]... |
class SubsetSpeciesStructure(GenericSpeciesStructure):
def __repr__(self):
'\n EXAMPLES::\n\n sage: set_random_seed(0)\n sage: S = species.SubsetSpecies()\n sage: a = S.structures(["a","b","c"])[0]; a\n {}\n '
s = GenericSpeciesStructure._... |
class SubsetSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
@staticmethod
@accept_size
def __classcall__(cls, *args, **kwds):
'\n EXAMPLES::\n\n sage: S = species.SubsetSpecies(); S\n Subset species\n '
return super().__classcall__(cls, *arg... |
class SumSpeciesStructure(SpeciesStructureWrapper):
pass
|
class SumSpecies(GenericCombinatorialSpecies, UniqueRepresentation):
def __init__(self, F, G, min=None, max=None, weight=None):
'\n Returns the sum of two species.\n\n EXAMPLES::\n\n sage: S = species.PermutationSpecies()\n sage: A = S+S\n sage: A.generating... |
def Subsets(s, k=None, submultiset=False):
"\n Return the combinatorial class of the subsets of the finite set\n ``s``. The set can be given as a list, Set or any iterable\n convertible to a set. Alternatively, a non-negative integer `n`\n can be provided in place of ``s``; in this case, the result is... |
class Subsets_s(Parent):
'\n Subsets of a given set.\n\n EXAMPLES::\n\n sage: S = Subsets(4); S\n Subsets of {1, 2, 3, 4}\n sage: S.cardinality()\n 16\n sage: Subsets(4).list()\n [{}, {1}, {2}, {3}, {4},\n {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4},\n ... |
class Subsets_sk(Subsets_s):
'\n Subsets of fixed size of a set.\n\n EXAMPLES::\n\n sage: S = Subsets([0,1,2,5,7], 3); S\n Subsets of {0, 1, 2, 5, 7} of size 3\n sage: S.cardinality()\n 10\n sage: S.first(), S.last()\n ({0, 1, 2}, {2, 5, 7})\n sage: S.random_... |
def dict_to_list(d):
"\n Return a list whose elements are the elements of ``i`` of ``d`` repeated with\n multiplicity ``d[i]``.\n\n EXAMPLES::\n\n sage: from sage.combinat.subset import dict_to_list\n sage: dict_to_list({'a':1, 'b':3})\n ['a', 'b', 'b', 'b']\n "
l = []
for... |
def list_to_dict(l):
"\n Return a dictionary of multiplicities and the list of its keys.\n\n INPUT:\n\n a list ``l`` with possibly repeated elements\n\n The keys are the elements of ``l`` (in the same order in which they appear)\n and values are the multiplicities of each element in ``l``.\n\n E... |
class SubMultiset_s(Parent):
'\n The combinatorial class of the sub multisets of ``s``.\n\n EXAMPLES::\n\n sage: S = Subsets([1,2,2,3], submultiset=True)\n sage: S.cardinality()\n 12\n sage: S.list()\n [[],\n [1],\n [2],\n [3],\n [1, 2],\n ... |
class SubMultiset_sk(SubMultiset_s):
'\n The combinatorial class of the subsets of size ``k`` of a multiset ``s``. Note\n that each subset is represented by a list of the elements rather than a\n set since we can have multiplicities (no multiset data structure yet in\n sage).\n\n EXAMPLES::\n\n ... |
class SubsetsSorted(Subsets_s):
"\n Lightweight class of all subsets of some set `S`, with each\n subset being encoded as a sorted tuple.\n\n Used to model indices of algebras given by subsets (so we don't\n have to explicitly build all `2^n` subsets in memory).\n For example, :class:`CliffordAlgeb... |
def powerset(X):
'\n Iterator over the *list* of all subsets of the iterable ``X``, in no\n particular order. Each list appears exactly once, up to order.\n\n INPUT:\n\n - ``X`` - an iterable\n\n OUTPUT: iterator of lists\n\n EXAMPLES::\n\n sage: list(powerset([1,2,3]))\n [[], [1]... |
def uniq(L):
"\n Iterate over the elements of ``L``, yielding every element at most\n once: keep only the first occurrence of any item.\n\n The items must be hashable.\n\n INPUT:\n\n - ``L`` -- iterable\n\n EXAMPLES::\n\n sage: L = [1, 1, 8, -5, 3, -5, 'a', 'x', 'a']\n sage: it = u... |
def subsets_with_hereditary_property(f, X, max_obstruction_size=None, ncpus=1):
"\n Return all subsets `S` of `X` such that `f(S)` is true.\n\n The boolean function `f` must be decreasing, i.e. `f(S)\\Rightarrow f(S')` if\n `S'\\subseteq S`.\n\n This function is implemented to call `f` as few times as... |
class PairwiseCompatibleSubsets(RecursivelyEnumeratedSet_forest):
"\n The set of all subsets of ``ambient`` whose elements satisfy\n ``predicate`` pairwise\n\n INPUT:\n\n - ``ambient`` -- a set (or iterable)\n - ``predicate`` -- a binary predicate\n\n Assumptions: ``predicate`` is symmetric (``p... |
def _stringification(data):
"\n TESTS::\n\n sage: from sage.combinat.subword import _stringification\n sage: _stringification(['a','b','c'])\n 'abc'\n "
return ''.join(data)
|
def Subwords(w, k=None, element_constructor=None):
"\n Return the set of subwords of ``w``.\n\n INPUT:\n\n - ``w`` -- a word (can be a list, a string, a tuple or a word)\n\n - ``k`` -- an optional integer to specify the length of subwords\n\n - ``element_constructor`` -- an optional function that w... |
class Subwords_w(Parent):
'\n Subwords of a given word.\n '
def __init__(self, w, element_constructor):
"\n TESTS::\n\n sage: TestSuite(Subwords([1,2,3])).run()\n sage: TestSuite(Subwords('sage')).run()\n "
Parent.__init__(self, category=FiniteEnumera... |
class Subwords_wk(Subwords_w):
'\n Subwords with fixed length of a given word.\n '
def __init__(self, w, k, element_constructor):
'\n TESTS::\n\n sage: S = Subwords([1,2,3],2)\n sage: S == loads(dumps(S))\n True\n sage: TestSuite(S).run()\n ... |
def smallest_positions(word, subword, pos=0) -> (list | bool):
'\n Return the smallest positions for which ``subword`` appears as a\n subword of ``word``.\n\n If ``pos`` is specified, then it returns the positions\n of the first appearance of subword starting at ``pos``.\n\n If ``subword`` is not f... |
class SubwordComplexFacet(Simplex, Element):
"\n A facet of a subword complex.\n\n Facets of the subword complex `\\mathcal{SC}(Q,w)` are complements\n of sets of positions in `Q` defining a reduced expression for `w`.\n\n EXAMPLES::\n\n sage: # optional - gap3\n sage: W = ReflectionGrou... |
class SubwordComplex(UniqueRepresentation, SimplicialComplex):
"\n Fix a Coxeter system `(W,S)`. The subword complex\n `\\mathcal{SC}(Q,w)` associated to a word `Q \\in S^*` and an\n element `w \\in W` is the simplicial complex whose ground set is the set of\n positions in `Q` and whose facets are com... |
def _greedy_facet(Q, w, side='negative', n=None, pos=0, l=None, elems=[]):
"\n Return the (positive or negative) *greedy facet* of the subword\n complex `SC(Q, w)`.\n\n INPUT:\n\n - ``Q`` -- a word\n - ``w`` -- an element in the Coxeter group\n - ``side`` -- optional, either ``'negative'`` (defa... |
def _extended_root_configuration_indices(W, Q, F):
"\n Return the extended root configuration indices of the facet `F`.\n\n INPUT:\n\n - ``W`` -- a Coxeter group\n - ``Q`` -- a word representing an element of `W`\n - ``F`` -- a facet of the subword complex\n\n OUTPUT:\n\n a list of root indic... |
def _greedy_flip_algorithm(Q, w):
"\n INPUT:\n\n - ``Q`` -- a word in a Coxeter group `W`\n - ``w`` -- an element of `W`\n\n OUTPUT:\n\n a pair: the list of facets and the list of extended root conf. indices\n\n EXAMPLES::\n\n sage: from sage.combinat.subword_complex import _greedy_flip_a... |
class SemistandardSuperTableau(Tableau):
'\n A semistandard super tableau.\n\n A semistandard super tableau is a tableau with primed positive integer entries.\n As defined in [Muth2019]_, a semistandard super tableau weakly increases along\n the rows and down the columns. Also, the letters of even par... |
class StandardSuperTableau(SemistandardSuperTableau):
'\n A standard super tableau.\n\n A standard super tableau is a semistandard super tableau whose entries\n are in bijection with positive primed integers `1\', 1, 2\' \\ldots n`.\n\n For more information refer [Muth2019]_.\n\n INPUT:\n\n - ``... |
class SemistandardSuperTableaux(SemistandardTableaux):
'\n The set of semistandard super tableaux.\n\n A semistandard super tableau is a tableau with primed positive integer entries.\n As defined in [Muth2019]_, a semistandard super tableau weakly increases along\n the rows and down the columns. Also,... |
class SemistandardSuperTableaux_all(SemistandardSuperTableaux):
'\n All semistandard super tableaux.\n '
def __init__(self):
'\n Initializes the class of all semistandard super tableaux.\n\n TESTS::\n\n sage: from sage.combinat.super_tableau import SemistandardSuperTabl... |
class StandardSuperTableaux(SemistandardSuperTableaux, Parent):
'\n The set of standard super tableaux.\n\n A standard super tableau is a tableau whose entries are primed positive\n integers, which are strictly increasing in rows and down columns and\n contains each letters from 1\',1,2\'...n exactly ... |
class StandardSuperTableaux_all(StandardSuperTableaux, DisjointUnionEnumeratedSets):
'\n All standard super tableaux.\n '
def __init__(self):
'\n Initializes the class of all standard super tableaux.\n\n TESTS::\n\n sage: from sage.combinat.super_tableau import Standard... |
class StandardSuperTableaux_size(StandardSuperTableaux, DisjointUnionEnumeratedSets):
"\n Standard super tableaux of fixed size `n`.\n\n EXAMPLES::\n\n sage: [ t for t in StandardSuperTableaux(1) ]\n [[[1']]]\n sage: [ t for t in StandardSuperTableaux(2) ]\n [[[1', 1]], [[1'], [1... |
class StandardSuperTableaux_shape(StandardSuperTableaux):
'\n Standard super tableaux of a fixed shape `p`.\n '
def __init__(self, p):
'\n Initializes the class of all standard super tableaux of a given shape.\n\n TESTS::\n\n sage: TestSuite( StandardSuperTableaux([2,2,... |
@richcmp_method
class SuperPartition(ClonableArray, metaclass=InheritComparisonClasscallMetaclass):
'\n A super partition.\n\n A *super partition* of size `n` and fermionic sector `m` is a\n pair consisting of a strict partition of some integer `r` of\n length `m` (that may end in a `0`) and an intege... |
class SuperPartitions(UniqueRepresentation, Parent):
'\n Super partitions.\n\n A super partition of size `n` and fermionic sector `m` is a\n pair consisting of a strict partition of some integer `r` of\n length `m` (that may end in a `0`) and an integer partition of\n `n - r`.\n\n INPUT:\n\n ... |
class SuperPartitions_n_m(SuperPartitions):
def __init__(self, n, m):
'\n Initialize ``self``.\n\n TESTS::\n\n sage: SP = SuperPartitions(3,2)\n sage: TestSuite(SP).run()\n '
self.n = n
self.m = m
SuperPartitions.__init__(self, False)
... |
class SuperPartitions_n(SuperPartitions):
def __init__(self, n):
'\n Initialize ``self``.\n\n TESTS::\n\n sage: SP = SuperPartitions(3)\n sage: TestSuite(SP).run()\n '
self.n = n
SuperPartitions.__init__(self, False)
def _repr_(self) -> str:... |
class SuperPartitions_all(SuperPartitions):
def __init__(self):
'\n Initialize ``self``.\n\n TESTS::\n\n sage: SP = SuperPartitions()\n sage: TestSuite(SP).run()\n '
SuperPartitions.__init__(self, True)
def _repr_(self) -> str:
"\n Re... |
def SymmetricGroupAlgebra(R, W, category=None):
'\n Return the symmetric group algebra of order ``W`` over the ring ``R``.\n\n INPUT:\n\n - ``W`` -- a symmetric group; alternatively an integer `n` can be\n provided, as shorthand for ``Permutations(n)``.\n - ``R`` -- a base ring\n - ``category`... |
class SymmetricGroupAlgebra_n(GroupAlgebra_class):
def __init__(self, R, W, category):
'\n TESTS::\n\n sage: QS3 = SymmetricGroupAlgebra(QQ, 3)\n sage: TestSuite(QS3).run()\n\n sage: QS3 in GroupAlgebras(QQ)\n True\n sage: QS3 in FiniteDimensi... |
def epsilon_ik(itab, ktab, star=0):
'\n Return the seminormal basis element of the symmetric group\n algebra `\\QQ S_n` corresponding to the pair of tableaux\n ``itab`` and ``ktab`` (or restrictions of these tableaux,\n if the optional variable ``star`` is set).\n\n INPUT:\n\n - ``itab``, ``ktab... |
def epsilon(tab, star=0):
'\n The `(T, T)`-th element of the seminormal basis of the group\n algebra `\\QQ[S_n]`, where `T` is the tableau ``tab`` (with its\n ``star`` highest entries removed if the optional variable\n ``star`` is set).\n\n See the docstring of\n :meth:`~sage.combinat.symmetric_... |
def pi_ik(itab, ktab):
'\n Return the permutation `p` which sends every entry of the\n tableau ``itab`` to the respective entry of the tableau\n ``ktab``, as an element of the corresponding symmetric group\n algebra.\n\n This assumes that ``itab`` and ``ktab`` are tableaux (possibly\n given just... |
def kappa(alpha):
'\n Return `\\kappa_\\alpha`, which is `n!` divided by the number\n of standard tableaux of shape `\\alpha` (where `\\alpha` is a\n partition of `n`).\n\n INPUT:\n\n - ``alpha`` -- integer partition (can be encoded as a list).\n\n OUTPUT:\n\n The factorial of the size of ``a... |
def a(tableau, star=0, base_ring=QQ):
"\n The row projection operator corresponding to the Young tableau\n ``tableau`` (which is supposed to contain every integer from\n `1` to its size precisely once, but may and may not be standard).\n\n This is the sum (in the group algebra of the relevant symmetri... |
def b(tableau, star=0, base_ring=QQ):
"\n The column projection operator corresponding to the Young tableau\n ``tableau`` (which is supposed to contain every integer from\n `1` to its size precisely once, but may and may not be standard).\n\n This is the signed sum (in the group algebra of the relevan... |
def e(tableau, star=0):
'\n The unnormalized Young projection operator corresponding to\n the Young tableau ``tableau`` (which is supposed to contain\n every integer from `1` to its size precisely once, but may\n and may not be standard).\n\n If `n` is a nonnegative integer, and `T` is a Young tabl... |
def e_hat(tab, star=0):
'\n The Young projection operator corresponding to the Young tableau\n ``tab`` (which is supposed to contain every integer from `1` to\n its size precisely once, but may and may not be standard). This\n is an idempotent in the rational group algebra.\n\n If `n` is a nonnegat... |
def e_ik(itab, ktab, star=0):
'\n EXAMPLES::\n\n sage: from sage.combinat.symmetric_group_algebra import e_ik\n sage: e_ik([[1,2,3]], [[1,2,3]])\n [1, 2, 3] + [1, 3, 2] + [2, 1, 3] + [2, 3, 1] + [3, 1, 2] + [3, 2, 1]\n sage: e_ik([[1,2,3]], [[1,2,3]], star=1)\n [1, 2] + [2, 1... |
def seminormal_test(n):
"\n Run a variety of tests to verify that the construction of the\n seminormal basis works as desired. The numbers appearing are\n results in James and Kerber's 'Representation Theory of the\n Symmetric Group' [JK1981]_.\n\n EXAMPLES::\n\n sage: from sage.combinat.sym... |
class SGACellularBasis(CellularBasis):
'\n A cellular basis of the symmetric group algebra.\n '
def __init__(self, SGA):
'\n Initialize ``self``.\n\n EXAMPLES::\n\n sage: SGA = SymmetricGroupAlgebra(GF(3), 3)\n sage: M = SGA.murphy_basis()\n sage: ... |
class MurphyBasis(SGACellularBasis):
"\n The Murphy basis of a symmetric group algebra.\n\n Let `R` be a commutative ring, and let `A = R[S_n]` denote the group\n algebra (over `R`) of `S_n`. The *Murphy basis* is the basis of `A`\n defined as follows. Let `S, T` be standard tableaux of shape `\\lambd... |
class KLCellularBasis(SGACellularBasis):
"\n The Kazhdan-Lusztig `C'` basis (at `q = 1`) of the symmetric group\n algebra realized as a :class:`cellular basis\n <sage.algebras.cellular_basis.CellularBasis>`\n\n EXAMPLES::\n\n sage: SGA = SymmetricGroupAlgebra(GF(3), 5)\n sage: KL = SGA.k... |
def HeckeAlgebraSymmetricGroupT(R, n, q=None):
'\n Return the Hecke algebra of the symmetric group `S_n` on the T-basis\n with quantum parameter ``q`` over the ring `R`.\n\n If `R` is a commutative ring and `q` is an invertible element of `R`,\n and if `n` is a nonnegative integer, then the Hecke alge... |
class HeckeAlgebraSymmetricGroup_generic(CombinatorialFreeModule):
def __init__(self, R, n, q=None):
'\n TESTS::\n\n sage: HeckeAlgebraSymmetricGroupT(QQ, 3)\n Hecke algebra of the symmetric group of order 3 on the T basis over Univariate Polynomial Ring in q over Rational Fi... |
class HeckeAlgebraSymmetricGroup_t(HeckeAlgebraSymmetricGroup_generic):
def __init__(self, R, n, q=None):
'\n TESTS::\n\n sage: H3 = HeckeAlgebraSymmetricGroupT(QQ, 3)\n sage: H3 == loads(dumps(H3))\n True\n '
HeckeAlgebraSymmetricGroup_generic.__ini... |
def SymmetricGroupRepresentation(partition, implementation='specht', ring=None, cache_matrices=True):
'\n The irreducible representation of the symmetric group corresponding to\n ``partition``.\n\n INPUT:\n\n - ``partition`` -- a partition of a positive integer\n\n - ``implementation`` -- string (d... |
def SymmetricGroupRepresentations(n, implementation='specht', ring=None, cache_matrices=True):
'\n Irreducible representations of the symmetric group.\n\n INPUT:\n\n - ``n`` -- positive integer\n\n - ``implementation`` -- string (default: ``"specht"``), one of:\n\n * ``"seminormal"`` - for Young\... |
class SymmetricGroupRepresentation_generic_class(Element):
'\n Generic methods for a representation of the symmetric group.\n '
_default_ring = None
def __init__(self, parent, partition):
'\n An irreducible representation of the symmetric group corresponding\n to ``partition``... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.