passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/libs/symmetrica/sb.pxi

@@ -0,0 +1,332 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+
+cdef extern from 'symmetrica/def.h':
+    INT mult_schubert_schubert(OP a, OP b, OP result)
+    INT m_perm_sch(OP a, OP b)
+    INT t_SCHUBERT_POLYNOM(OP a, OP b)
+    INT t_POLYNOM_SCHUBERT(OP a, OP b)
+    INT mult_schubert_variable(OP a, OP i, OP r)
+    INT divdiff_perm_schubert(OP perm, OP sb, OP res)
+    INT scalarproduct_schubert(OP a, OP b, OP c)
+    INT divdiff_schubert(OP a, OP schub, OP res)
+
+    INT t_2SCHUBERT_POLYNOM(OP a,OP b)
+    INT mult_schubert_polynom(OP a,OP b,OP c)
+
+
+cdef object _check_schubert(object a, OP ca):
+    if a in Permutations():
+        if isinstance(a, builtinlist):
+            a = Permutation(a)
+        _op_schubert_perm(a, ca)
+        return max(a.reduced_word()+[0])
+    elif isinstance(a, SchubertPolynomial_class):
+        br = a.parent().base_ring()
+        if (br == QQ or br == ZZ):
+            _op_schubert_sp(a, ca)
+            return min(max(i.reduced_word(), default=0) for i in a.support())
+        else:
+            raise ValueError("a must be a Schubert polynomial over ZZ or QQ")
+    else:
+        raise TypeError("a must be a permutation or a Schubert polynomial")
+
+
+def mult_schubert_schubert_symmetrica(a, b):
+    """
+    Multiply the Schubert polynomials `a` and `b`.
+
+    EXAMPLES::
+
+        sage: symmetrica.mult_schubert_schubert([3,2,1], [3,2,1])
+        X[5, 3, 1, 2, 4]
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), cb = callocobject(), cres = callocobject()
+
+    try:
+        max_a = _check_schubert(a, ca)
+        max_b = _check_schubert(b, cb)
+    except (ValueError, TypeError), err:
+        freeall(ca)
+        freeall(cb)
+        freeall(cres)
+        raise err
+
+    sig_on()
+    mult_schubert_schubert(ca, cb, cres)
+    sig_off()
+
+    res = _py(cres)
+
+    freeall(ca)
+    freeall(cb)
+    freeall(cres)
+
+    return res
+
+
+def t_SCHUBERT_POLYNOM_symmetrica(a):
+    """
+    Convert a Schubert polynomial to a 'regular' multivariate
+    polynomial.
+
+    EXAMPLES::
+
+        sage: symmetrica.t_SCHUBERT_POLYNOM([3,2,1])
+        x0^2*x1
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), cres = callocobject()
+
+    try:
+        max_a = _check_schubert(a, ca)
+    except (ValueError, TypeError), err:
+        freeall(ca)
+        freeall(cres)
+        raise err
+
+    sig_on()
+    t_SCHUBERT_POLYNOM(ca, cres)
+    sig_off()
+
+    res = _py(cres)
+
+    freeall(ca)
+    freeall(cres)
+
+    return res
+
+
+def t_POLYNOM_SCHUBERT_symmetrica(a):
+    """
+    Convert a multivariate polynomial a to a Schubert polynomial.
+
+    EXAMPLES::
+
+        sage: R.<x1,x2,x3> = QQ[]
+        sage: w0 = x1^2*x2
+        sage: symmetrica.t_POLYNOM_SCHUBERT(w0)
+        X[3, 2, 1]
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), cres = callocobject()
+
+    if not isinstance(a, MPolynomial):
+        freeall(ca)
+        freeall(cres)
+        raise TypeError("a (= %s) must be a multivariate polynomial")
+    else:
+        br = a.parent().base_ring()
+        if br != QQ and br != ZZ:
+            freeall(ca)
+            freeall(cres)
+            raise ValueError("a's base ring must be either ZZ or QQ")
+        else:
+            _op_polynom(a, ca)
+
+    sig_on()
+    t_POLYNOM_SCHUBERT(ca, cres)
+    sig_off()
+
+    res = _py(cres)
+
+    freeall(ca)
+    freeall(cres)
+
+    return res
+
+
+def mult_schubert_variable_symmetrica(a, i):
+    """
+    Return the product of `a` and `x_i`.  Note that indexing with `i`
+    starts at 1.
+
+    EXAMPLES::
+
+        sage: symmetrica.mult_schubert_variable([3,2,1], 2)
+        X[3, 2, 4, 1]
+        sage: symmetrica.mult_schubert_variable([3,2,1], 4)
+        X[3, 2, 1, 4, 6, 5] - X[3, 2, 1, 5, 4]
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), ci = callocobject(),  cres = callocobject()
+
+    try:
+        max_a = _check_schubert(a, ca)
+    except (ValueError, TypeError), err:
+        freeall(ca)
+        freeall(ci)
+        freeall(cres)
+        raise err
+
+    _op_integer(i, ci)
+
+    sig_on()
+    mult_schubert_variable(ca, ci, cres)
+    sig_off()
+
+    res = _py(cres)
+
+    freeall(ca)
+    freeall(ci)
+    freeall(cres)
+
+    return res
+
+
+def divdiff_perm_schubert_symmetrica(perm, a):
+    r"""
+    Return the result of applying the divided difference operator
+    `\delta_i` to `a` where `a` is either a permutation or a
+    Schubert polynomial over `\QQ`.
+
+    EXAMPLES::
+
+       sage: symmetrica.divdiff_perm_schubert([2,3,1], [3,2,1])
+       X[2, 1]
+       sage: symmetrica.divdiff_perm_schubert([3,1,2], [3,2,1])
+       X[1, 3, 2]
+       sage: symmetrica.divdiff_perm_schubert([3,2,4,1], [3,2,1])
+       Traceback (most recent call last):
+       ...
+       ValueError: cannot apply \delta_{[3, 2, 4, 1]} to a (= [3, 2, 1])
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), cperm = callocobject(),  cres = callocobject()
+
+    try:
+        max_a = _check_schubert(a, ca)
+    except (ValueError, TypeError), err:
+        freeall(ca)
+        freeall(cperm)
+        freeall(cres)
+        raise err
+
+    if perm not in Permutations():
+        freeall(ca)
+        freeall(cperm)
+        freeall(cres)
+        raise TypeError("perm must be a permutation")
+    else:
+        perm = Permutation(perm)
+        rw = perm.reduced_word()
+        max_perm = max(rw)
+        _op_permutation(perm, cperm)
+
+    if max_perm > max_a:
+        freeall(ca)
+        freeall(cperm)
+        freeall(cres)
+        raise ValueError(r"cannot apply \delta_{%s} to a (= %s)" % (perm, a))
+
+    sig_on()
+    divdiff_perm_schubert(cperm, ca, cres)
+    sig_off()
+
+    res = _py(cres)
+
+    freeall(ca)
+    freeall(cperm)
+    freeall(cres)
+
+    return res
+
+
+def scalarproduct_schubert_symmetrica(a, b):
+    """
+    EXAMPLES::
+
+        sage: symmetrica.scalarproduct_schubert([3,2,1], [3,2,1])
+        X[1, 3, 5, 2, 4]
+        sage: symmetrica.scalarproduct_schubert([3,2,1], [2,1,3])
+        X[1, 2, 4, 3]
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), cb = callocobject(), cres = callocobject()
+
+    try:
+        max_a = _check_schubert(a, ca)
+        max_b = _check_schubert(b, cb)
+    except (ValueError, TypeError), err:
+        freeall(ca)
+        freeall(cb)
+        freeall(cres)
+        raise err
+
+    sig_on()
+    scalarproduct_schubert(ca, cb, cres)
+    sig_off()
+
+    if empty_listp(cres):
+        res = Integer(0)
+    else:
+        res = _py(cres)
+
+    freeall(ca)
+    freeall(cb)
+    freeall(cres)
+
+    return res
+
+
+def divdiff_schubert_symmetrica(i, a):
+    r"""
+    Return the result of applying the divided difference operator
+    `\delta_i` to `a` where `a` is either a permutation or a
+    Schubert polynomial over `\QQ`.
+
+    EXAMPLES::
+
+       sage: symmetrica.divdiff_schubert(1, [3,2,1])
+       X[2, 3, 1]
+       sage: symmetrica.divdiff_schubert(2, [3,2,1])
+       X[3, 1, 2]
+       sage: symmetrica.divdiff_schubert(3, [3,2,1])
+       Traceback (most recent call last):
+       ...
+       ValueError: cannot apply \delta_{3} to a (= [3, 2, 1])
+    """
+    late_import()
+
+    cdef OP ca = callocobject(), ci = callocobject(),  cres = callocobject()
+
+    try:
+        max_a = _check_schubert(a, ca)
+    except (ValueError, TypeError), err:
+        freeall(ca)
+        freeall(ci)
+        freeall(cres)
+        raise err
+
+    if not isinstance(i, (int, Integer)):
+        freeall(ca)
+        freeall(ci)
+        freeall(cres)
+        raise TypeError("i must be an integer")
+    else:
+        _op_integer(i, ci)
+
+    if i > max_a or i <= 0:
+        freeall(ca)
+        freeall(ci)
+        freeall(cres)
+        raise ValueError(r"cannot apply \delta_{%s} to a (= %s)" % (i, a))
+
+    sig_on()
+    divdiff_schubert(ci, ca, cres)
+    sig_off()
+
+    res = _py(cres)
+
+    freeall(ca)
+    freeall(ci)
+    freeall(cres)
+
+    return res

sage/libs/symmetrica/sc.pxi

@@ -0,0 +1,192 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.modules
+
+cdef extern from 'symmetrica/def.h':
+    INT chartafel(OP degree, OP result)
+    INT charvalue(OP irred, OP cls, OP result, OP table)
+    INT kranztafel(OP a, OP b, OP res, OP co, OP cl)
+    INT c_ijk_sn(OP i, OP j, OP k, OP res)
+
+
+def chartafel_symmetrica(n):
+    """
+    You enter the degree of the symmetric group, as INTEGER
+    object and the result is a MATRIX object: the charactertable
+    of the symmetric group of the given degree.
+
+    EXAMPLES::
+
+        sage: symmetrica.chartafel(3)
+        [ 1  1  1]
+        [-1  0  2]
+        [ 1 -1  1]
+        sage: symmetrica.chartafel(4)
+        [ 1  1  1  1  1]
+        [-1  0 -1  1  3]
+        [ 0 -1  2  0  2]
+        [ 1  0 -1 -1  3]
+        [-1  1  1 -1  1]
+    """
+    cdef OP cn, cres
+
+    cn   = callocobject()
+    cres = callocobject()
+
+    _op_integer(n, cn)
+
+    chartafel(cn, cres)
+
+    res = _py(cres)
+
+    freeall(cn)
+    freeall(cres)
+
+    return res
+
+
+def charvalue_symmetrica(irred, cls, table=None):
+    """
+    You enter a PARTITION object part, labelling the irreducible
+    character, you enter a PARTITION object class, labeling the class
+    or class may be a PERMUTATION object, then result becomes the value
+    of that character on that class or permutation. Note that the
+    table may be NULL, in which case the value is computed, or it may be
+    taken from a precalculated charactertable.
+
+    FIXME: add table parameter
+
+    EXAMPLES::
+
+        sage: n = 3
+        sage: m = matrix([[symmetrica.charvalue(irred, cls) for cls in Partitions(n)]
+        ....:             for irred in Partitions(n)]); m
+        [ 1  1  1]
+        [-1  0  2]
+        [ 1 -1  1]
+        sage: m == symmetrica.chartafel(n)
+        True
+        sage: n = 4
+        sage: m = matrix([[symmetrica.charvalue(irred, cls) for cls in Partitions(n)]
+        ....:             for irred in Partitions(n)])
+        sage: m == symmetrica.chartafel(n)
+        True
+    """
+    cdef OP cirred, cclass, ctable, cresult
+
+    cirred = callocobject()
+    cclass = callocobject()
+    cresult = callocobject()
+
+    if table is None:
+        ctable = NULL
+    else:
+        ctable = callocobject()
+        _op_matrix(table, ctable)
+
+    #FIXME: assume that class is a partition
+    _op_partition(cls, cclass)
+
+    _op_partition(irred, cirred)
+
+    charvalue(cirred, cclass, cresult, ctable)
+
+    res = _py(cresult)
+
+    freeall(cirred)
+    freeall(cclass)
+    freeall(cresult)
+    if ctable != NULL:
+        freeall(ctable)
+
+    return res
+
+
+def kranztafel_symmetrica(a, b):
+    r"""
+    You enter the INTEGER objects, say `a` and `b`, and ``res`` becomes a
+    MATRIX object, the charactertable of `S_b \wr S_a`, ``co`` becomes a
+    VECTOR object of classorders and ``cl`` becomes a VECTOR object of
+    the classlabels.
+
+    EXAMPLES::
+
+        sage: (a,b,c) = symmetrica.kranztafel(2,2)
+        sage: a
+        [ 1 -1  1 -1  1]
+        [ 1  1  1  1  1]
+        [-1  1  1 -1  1]
+        [ 0  0  2  0 -2]
+        [-1 -1  1  1  1]
+        sage: b
+        [2, 2, 1, 2, 1]
+        sage: for m in c: print(m)
+        [0 0]
+        [0 1]
+        [0 0]
+        [1 0]
+        [0 2]
+        [0 0]
+        [1 1]
+        [0 0]
+        [2 0]
+        [0 0]
+    """
+    cdef OP ca, cb, cres, cco, ccl
+
+    ca = callocobject()
+    cb = callocobject()
+    cres = callocobject()
+    cco = callocobject()
+    ccl = callocobject()
+
+    _op_integer(a, ca)
+    _op_integer(b, cb)
+
+    kranztafel(ca,cb,cres,cco,ccl)
+
+    res = _py(cres)
+    co  = _py(cco)
+    cl  = _py(ccl)
+
+    freeall(ca)
+    freeall(cb)
+    freeall(cres)
+    freeall(cco)
+    freeall(ccl)
+
+    return (res, co, cl)
+
+
+## def c_ijk_sn_symmetrica(i, j, k):
+##     """
+##     computes the coefficients of the class multiplication in the
+##     group algebra of the S_n. It uses the method described in
+##     Curtis/Reiner: Methods of representation theory I p. 216
+
+##     EXAMPLES:
+
+##     """
+
+##     cdef OP ci, cj, ck, cresult
+
+
+##     ci = callocobject()
+##     cj = callocobject()
+##     cresult = callocobject()
+##     ck = callocobject()
+
+
+##     _op_partition(i, ci)
+##     _op_partition(j, cj)
+##     _op_partition(k, ck)
+
+##     c_ijk_sn(ci, cj, ck, cresult)
+
+##     res = _py(cresult)
+
+##     freeall(ci)
+##     freeall(cj)
+##     freeall(cresult)
+##     freeall(ck)
+
+##     return res