passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/libs/symmetrica/kostka.pxi

@@ -0,0 +1,168 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+
+from cpython.object cimport *
+from cysignals.signals cimport sig_on, sig_off
+
+cdef extern from 'symmetrica/def.h':
+    INT kostka_number(OP shape, OP content, OP result)
+    INT kostka_tab(OP shape, OP content, OP result)
+    INT kostka_tafel(OP n, OP result)
+
+
+def kostka_number_symmetrica(shape, content):
+    """
+    Compute the kostkanumber, i.e. the number of
+    tableaux of given shape, which is a PARTITION object, and
+    of given content, which also is a PARTITION object, or a VECTOR
+    object with INTEGER entries. The
+    result is an INTEGER object, which is freed to an empty
+    object at the beginning. The shape could also be a
+    SKEWPARTITION object, then we compute the number of
+    skewtableaux of the given shape.
+
+    EXAMPLES::
+
+        sage: symmetrica.kostka_number([2,1],[1,1,1])
+        2
+        sage: symmetrica.kostka_number([1,1,1],[1,1,1])
+        1
+        sage: symmetrica.kostka_number([3],[1,1,1])
+        1
+    """
+    cdef OP cshape = callocobject(), ccontent = callocobject(), result = callocobject()
+
+    if isinstance(shape, <type>builtinlist):
+        if isinstance(shape[0], <type>builtinlist):
+            shape = SkewPartition(shape)
+        else:
+            shape = Partition(shape)
+
+
+    if isinstance(shape, <type>SkewPartition):
+        _op_skew_partition(shape, cshape)
+    else:
+        _op_partition(shape, cshape)
+
+    _op_partition(content, ccontent)
+
+    kostka_number(ccontent, cshape, result)
+
+    res = _py(result)
+
+    freeall(cshape)
+    freeall(ccontent)
+    freeall(result)
+
+
+    return res
+
+
+def kostka_tab_symmetrica(shape, content):
+    """
+    Compute the list of tableaux of given shape
+    and content. shape is a PARTITION object or a
+    SKEWPARTITION object and
+    content is a PARTITION object or a VECTOR object with
+    INTEGER entries, the result becomes a
+    LIST object whose entries are the computed TABLEAUX
+    object.
+
+    EXAMPLES::
+
+        sage: symmetrica.kostka_tab([3],[1,1,1])
+        [[[1, 2, 3]]]
+        sage: symmetrica.kostka_tab([2,1],[1,1,1])
+        [[[1, 2], [3]], [[1, 3], [2]]]
+        sage: symmetrica.kostka_tab([1,1,1],[1,1,1])
+        [[[1], [2], [3]]]
+        sage: symmetrica.kostka_tab([[2,2,1],[1,1]],[1,1,1])
+        [[[None, 1], [None, 2], [3]],
+         [[None, 1], [None, 3], [2]],
+         [[None, 2], [None, 3], [1]]]
+        sage: symmetrica.kostka_tab([[2,2],[1]],[1,1,1])
+        [[[None, 1], [2, 3]], [[None, 2], [1, 3]]]
+    """
+    late_import()
+
+    cdef OP cshape = callocobject(), ccontent = callocobject(), result = callocobject()
+    cdef INT err
+
+    if isinstance(shape, <type>builtinlist):
+        if isinstance(shape[0], <type>builtinlist):
+            shape = SkewPartition(shape)
+        else:
+            shape = Partition(shape)
+
+
+    if isinstance(shape, <type>SkewPartition):
+        _op_skew_partition(shape, cshape)
+    else:
+        _op_partition(shape, cshape)
+
+
+    #Check to make sure the content is compatible with the shape.
+
+    _op_il_vector(content, ccontent)
+
+    err = kostka_tab(cshape, ccontent, result)
+
+    res = _py(result)
+
+    freeall(cshape)
+    freeall(ccontent)
+    freeall(result)
+
+
+    return res
+
+
+def kostka_tafel_symmetrica(n):
+    """
+    Return the table of Kostka numbers of weight `n`.
+
+    EXAMPLES::
+
+        sage: symmetrica.kostka_tafel(1)
+        [1]
+
+        sage: symmetrica.kostka_tafel(2)
+        [1 0]
+        [1 1]
+
+        sage: symmetrica.kostka_tafel(3)
+        [1 0 0]
+        [1 1 0]
+        [1 2 1]
+
+        sage: symmetrica.kostka_tafel(4)
+        [1 0 0 0 0]
+        [1 1 0 0 0]
+        [1 1 1 0 0]
+        [1 2 1 1 0]
+        [1 3 2 3 1]
+
+        sage: symmetrica.kostka_tafel(5)
+        [1 0 0 0 0 0 0]
+        [1 1 0 0 0 0 0]
+        [1 1 1 0 0 0 0]
+        [1 2 1 1 0 0 0]
+        [1 2 2 1 1 0 0]
+        [1 3 3 3 2 1 0]
+        [1 4 5 6 5 4 1]
+    """
+
+    cdef OP cn = callocobject(), cresult = callocobject()
+
+    _op_integer(n, cn)
+
+    sig_on()
+    kostka_tafel(cn, cresult)
+    sig_off()
+
+    res = _py(cresult)
+
+    freeall(cn)
+    freeall(cresult)
+
+    return res

sage/libs/symmetrica/part.pxi

@@ -0,0 +1,193 @@
+# sage_setup: distribution = sagemath-combinat
+cdef extern from 'symmetrica/def.h':
+    INT strict_to_odd_part(OP s, OP o)
+    INT odd_to_strict_part(OP o, OP s)
+    INT q_core(OP part, OP d,  OP core)
+    INT gupta_nm(OP n, OP m, OP res)
+    INT gupta_tafel(OP max, OP res)
+    INT random_partition(OP nx, OP res)
+
+
+def strict_to_odd_part_symmetrica(part):
+    """
+    Implement the bijection between strict partitions
+    and partitions with odd parts. input is a VECTOR type partition, the
+    result is a partition of the same weight with only odd parts.
+    """
+
+    #Make sure that the partition is strict
+    cdef INT i
+    for i from 0 <= i < len(part)-1:
+        if part[i] == part[i+1]:
+            raise ValueError("the partition part (= %s) must be strict" % str(part))
+
+    cdef OP cpart, cres
+    anfang()
+    cpart = callocobject()
+    cres = callocobject()
+
+    _op_partition(part, cpart)
+
+    strict_to_odd_part(cpart, cres)
+
+    res = _py(cres)
+
+    freeall(cpart)
+    freeall(cres)
+    ende()
+
+    return res
+
+
+def odd_to_strict_part_symmetrica(part):
+    """
+    Implement the bijection between partitions with odd parts
+    and strict partitions. input is a VECTOR type partition, the
+    result is a partition of the same weight with different parts.
+    """
+
+    #Make sure that the partition is strict
+    cdef INT i
+    for i from 0 <= i < len(part):
+        if part[i] % 2 == 0:
+            raise ValueError("the partition part (= %s) must be odd" % str(part))
+
+    cdef OP cpart, cres
+    anfang()
+    cpart = callocobject()
+    cres = callocobject()
+
+    _op_partition(part, cpart)
+
+    odd_to_strict_part(cpart, cres)
+
+    res = _py(cres)
+
+    freeall(cpart)
+    freeall(cres)
+    ende()
+
+    return res
+
+
+def q_core_symmetrica(part, d):
+    """
+    Compute the q-core of a PARTITION object
+    part. This is the remaining partition (=res) after
+    removing of all hooks of length d (= INTEGER object).
+    The result may be an empty object, if the whole
+    partition disappears.
+    """
+
+
+    cdef OP cpart, cres, cd
+    anfang()
+    cpart = callocobject()
+    cd = callocobject()
+    cres = callocobject()
+
+    _op_partition(part, cpart)
+    _op_integer(d, cd)
+
+    q_core(cpart, cd, cres)
+
+    res = _py(cres)
+
+    freeall(cpart)
+    freeall(cres)
+    freeall(cd)
+    ende()
+
+    return res
+
+
+def gupta_nm_symmetrica(n, m):
+    """
+    This routine computes the number of partitions
+    of n with maximal part m. The result is erg. The
+    input n,m must be INTEGER objects. The result is
+    freed first to an empty object. The result must
+    be a different from m and n.
+    """
+
+
+    cdef OP cn, cm, cres
+    anfang()
+    cm = callocobject()
+    cn = callocobject()
+    cres = callocobject()
+
+
+    _op_integer(n, cn)
+    _op_integer(m, cm)
+
+    gupta_nm(cn, cm, cres)
+
+    res = _py(cres)
+
+    freeall(cn)
+    freeall(cres)
+    freeall(cm)
+    ende()
+
+    return res
+
+
+def gupta_tafel_symmetrica(max):
+    """
+    It computes the table of the above values. The entry
+    n,m is the result of gupta_nm. mat is freed first.
+    max must be an INTEGER object, it is the maximum
+    weight for the partitions. max must be different from
+    result.
+    """
+
+
+    cdef OP cmax, cres
+    anfang()
+
+    cmax = callocobject()
+    cres = callocobject()
+
+
+    _op_integer(max, cmax)
+
+    gupta_tafel(cmax, cres)
+
+    res = _py(cres)
+
+    freeall(cmax)
+    freeall(cres)
+    ende()
+
+    return res
+
+
+def random_partition_symmetrica(n):
+    """
+    Return a random partition p of the entered weight w.
+
+    w must be an INTEGER object, p becomes a PARTITION object.
+    Type of partition is VECTOR . It uses the algorithm of
+    Nijenhuis and Wilf, p.76
+    """
+
+
+    cdef OP cn, cres
+    anfang()
+
+    cn = callocobject()
+    cres = callocobject()
+
+
+    _op_integer(n, cn)
+
+    random_partition(cn, cres)
+
+    res = _py(cres)
+
+    freeall(cn)
+    freeall(cres)
+    ende()
+
+    return res

sage/libs/symmetrica/plet.pxi

@@ -0,0 +1,42 @@
+# sage_setup: distribution = sagemath-combinat
+cdef extern from 'symmetrica/def.h':
+    INT plethysm(OP s1, OP s2, OP res)
+    INT schur_schur_plet(OP p1, OP p2, OP res)
+
+
+def plethysm_symmetrica(outer, inner):
+    cdef OP couter = callocobject(), cinner = callocobject(), cresult = callocobject()
+
+    _op_schur(outer, couter)
+    _op_schur(inner, cinner)
+
+    sig_on()
+    plethysm(couter, cinner, cresult)
+    sig_off()
+
+    res = _py(cresult)
+
+    freeall(couter)
+    freeall(cinner)
+    freeall(cresult)
+
+    return res
+
+
+def schur_schur_plet_symmetrica(outer, inner):
+    cdef OP couter = callocobject(), cinner = callocobject(), cresult = callocobject()
+
+    _op_partition(outer, couter)
+    _op_partition(inner, cinner)
+
+    sig_on()
+    schur_schur_plet(couter, cinner, cresult)
+    sig_off()
+
+    res = _py(cresult)
+
+    freeall(couter)
+    freeall(cinner)
+    freeall(cresult)
+
+    return res

sage/libs/symmetrica/sab.pxi

@@ -0,0 +1,196 @@
+# sage_setup: distribution = sagemath-combinat
+cdef extern from 'symmetrica/def.h':
+    INT dimension_symmetrization(OP n, OP part, OP a)
+    INT bdg(OP part, OP perm, OP D)
+    INT sdg(OP part, OP perm, OP D)
+    INT odg(OP part, OP perm, OP D)
+    INT ndg(OP part, OP perm, OP D)
+    INT specht_dg(OP part, OP perm, OP D)
+    INT glmndg(OP m, OP n, OP M, INT VAR)
+
+
+def dimension_symmetrization_symmetrica(n, part):
+    """
+    Compute the dimension of the degree of a irreducible
+    representation of the GL_n, n is a INTEGER object, labeled
+    by the PARTITION object a.
+    """
+    cdef OP cn, cpart, cres
+
+
+    cn    = callocobject()
+    cpart = callocobject()
+    cres  = callocobject()
+
+    _op_partition(part, cpart)
+    _op_integer(n, cn)
+
+    dimension_symmetrization(cn, cpart, cres)
+    res = _py(cres)
+
+    freeall(cn)
+    freeall(cpart)
+    freeall(cres)
+
+
+    return res
+
+
+def bdg_symmetrica(part, perm):
+    """
+    Calculate the irreducible matrix representation
+    D^part(perm), whose entries are of integral numbers.
+
+    REFERENCE: H. Boerner:
+               Darstellungen von Gruppen, Springer 1955.
+               pp. 104-107.
+    """
+    cdef OP cpart, cperm, cD
+
+
+    cpart = callocobject()
+    cperm = callocobject()
+    cD    = callocobject()
+
+    _op_partition(part, cpart)
+    _op_permutation(perm, cperm)
+
+    bdg(cpart, cperm, cD)
+    res = _py_matrix(cD)
+
+    freeall(cpart)
+    freeall(cperm)
+    freeall(cD)
+
+
+def sdg_symmetrica(part, perm):
+    """
+    Calculate the irreducible matrix representation
+    D^part(perm), which consists of rational numbers.
+
+    REFERENCE: G. James/ A. Kerber:
+               Representation Theory of the Symmetric Group.
+               Addison/Wesley 1981.
+               pp. 124-126.
+    """
+    cdef OP cpart, cperm, cD
+
+
+    cpart = callocobject()
+    cperm = callocobject()
+    cD    = callocobject()
+
+    _op_partition(part, cpart)
+    _op_permutation(perm, cperm)
+
+    sdg(cpart, cperm, cD)
+    res = _py_matrix(cD)
+
+    freeall(cpart)
+    freeall(cperm)
+    freeall(cD)
+
+    return res
+
+
+def odg_symmetrica(part, perm):
+    """
+    Calculate the irreducible matrix representation
+    D^part(perm), which consists of real numbers.
+
+    REFERENCE: G. James/ A. Kerber:
+               Representation Theory of the Symmetric Group.
+               Addison/Wesley 1981.
+               pp. 127-129.
+    """
+    cdef OP cpart, cperm, cD
+
+
+    cpart = callocobject()
+    cperm = callocobject()
+    cD    = callocobject()
+
+    _op_partition(part, cpart)
+    _op_permutation(perm, cperm)
+
+    odg(cpart, cperm, cD)
+    res = _py_matrix(cD)
+
+    freeall(cpart)
+    freeall(cperm)
+    freeall(cD)
+
+    return res
+
+
+def ndg_symmetrica(part, perm):
+    cdef OP cpart, cperm, cD
+
+    cpart = callocobject()
+    cperm = callocobject()
+    cD    = callocobject()
+
+    _op_partition(part, cpart)
+    _op_permutation(perm, cperm)
+
+    ndg(cpart, cperm, cD)
+    res = _py_matrix(cD)
+
+    freeall(cpart)
+    freeall(cperm)
+    freeall(cD)
+
+    return res
+
+
+def specht_dg_symmetrica(part, perm):
+    cdef OP cpart, cperm, cD
+
+    cpart = callocobject()
+    cperm = callocobject()
+    cD    = callocobject()
+
+    _op_partition(part, cpart)
+    _op_permutation(perm, cperm)
+
+    specht_dg(cpart, cperm, cD)
+    res = _py_matrix(cD)
+
+    freeall(cpart)
+    freeall(cperm)
+    freeall(cD)
+
+    return res
+
+
+## def glmndg_symmetrica(m, n, VAR=0):
+##     """
+##     If VAR is equal to 0 the orthogonal representation
+##     is used for the decomposition, otherwise, if VAR
+##     equals 1, the natural representation is considered.
+
+##     The result is the  VECTOR-Object M, consisting of
+##     components of type MATRIX, representing the several
+##     irreducible matrix representations of GLm(C) with
+##     part_1' <= m, where part is a partition of n.
+
+##     """
+##     cdef OP cm, cn, cM
+
+##     cm = callocobject()
+##     _op_integer(m, cm)
+
+##     cn = callocobject()
+##     _op_integer(n, cn)
+
+##     cM = callocobject()
+
+##     glmndg(cm, cn, cM, VAR)
+##     res = _py(cM)
+
+
+##    freeall(cm)
+##    freeall(cn)
+##    freeall(cM)
+
+##    return res