passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/combinat/q_bernoulli.pyx

@@ -0,0 +1,128 @@
+# sage_setup: distribution = sagemath-combinat
+"""
+`q`-Bernoulli numbers and polynomials
+"""
+from sage.rings.integer_ring import ZZ
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+from sage.misc.cachefunc import cached_function
+
+
+@cached_function
+def q_bernoulli(m, p=None):
+    r"""
+    Compute Carlitz's `q`-analogue of the Bernoulli numbers.
+
+    For every nonnegative integer `m`, the `q`-Bernoulli number
+    `\beta_m` is a rational function of the indeterminate `q` whose
+    value at `q=1` is the usual Bernoulli number `B_m`.
+
+    INPUT:
+
+    - ``m`` -- nonnegative integer
+
+    - ``p`` -- (default: ``None``) an optional value for `q`
+
+    OUTPUT:
+
+    A rational function of the indeterminate `q` (if `p` is ``None``)
+
+    Otherwise, the rational function is evaluated at `p`.
+
+    EXAMPLES::
+
+        sage: from sage.combinat.q_bernoulli import q_bernoulli
+        sage: q_bernoulli(0)
+        1
+        sage: q_bernoulli(1)
+        -1/(q + 1)
+        sage: q_bernoulli(2)
+        q/(q^3 + 2*q^2 + 2*q + 1)
+        sage: all(q_bernoulli(i)(q=1) == bernoulli(i) for i in range(12))               # needs sage.libs.flint
+        True
+
+    One can evaluate the rational function by giving a second argument::
+
+        sage: x = PolynomialRing(GF(2),'x').gen()
+        sage: q_bernoulli(5,x)
+        x/(x^6 + x^5 + x + 1)
+
+    The function does not accept negative arguments::
+
+        sage: q_bernoulli(-1)
+        Traceback (most recent call last):
+        ...
+        ValueError: the argument must be a nonnegative integer
+
+    REFERENCES:
+
+    .. [Ca1948] Leonard Carlitz, "q-Bernoulli numbers and polynomials". Duke Math J. 15, 987-1000 (1948), :doi:`10.1215/S0012-7094-48-01588-9`
+
+    .. [Ca1954] Leonard Carlitz, "q-Bernoulli and Eulerian numbers". Trans Am Soc. 76, 332-350 (1954), :doi:`10.1090/S0002-9947-1954-0060538-2`
+    """
+    m = ZZ(m)
+    if m < 0:
+        raise ValueError("the argument must be a nonnegative integer")
+    cdef int i
+    q = PolynomialRing(ZZ, 'q').gen()
+    result = (q - 1)**(1-m) * sum((-1)**(m-i)*m.binomial(i)*(i+1)/(q**(i+1)-1)
+                                  for i in range(m + 1))
+    if p is None:
+        return result
+    else:
+        return result(q=p)
+
+
+@cached_function
+def q_bernoulli_polynomial(m):
+    r"""
+    Compute Carlitz's `q`-analogue of the Bernoulli polynomials.
+
+    For every nonnegative integer `m`, the `q`-Bernoulli polynomial
+    is a polynomial in one variable `x` with coefficients in `\QQ(q)` whose
+    value at `q=1` is the usual Bernoulli polynomial `B_m(x)`.
+
+    The original `q`-Bernoulli polynomials introduced by Carlitz were
+    polynomials in `q^y` with coefficients in `\QQ(q)`. This function returns
+    these polynomials but expressed in the variable `x=(q^y-1)/(q-1)`. This
+    allows to let `q=1` to recover the classical Bernoulli polynomials.
+
+    INPUT:
+
+    - ``m`` -- nonnegative integer
+
+    OUTPUT: a polynomial in one variable `x`
+
+    EXAMPLES::
+
+        sage: from sage.combinat.q_bernoulli import q_bernoulli_polynomial, q_bernoulli
+        sage: q_bernoulli_polynomial(0)
+        1
+        sage: q_bernoulli_polynomial(1)
+        (2/(q + 1))*x - 1/(q + 1)
+        sage: x = q_bernoulli_polynomial(1).parent().gen()
+        sage: all(q_bernoulli_polynomial(i)(q=1) == bernoulli_polynomial(x,i)           # needs sage.libs.flint
+        ....:     for i in range(12))
+        True
+        sage: all(q_bernoulli_polynomial(i)(x=0) == q_bernoulli(i)
+        ....:     for i in range(12))
+        True
+
+    The function does not accept negative arguments::
+
+        sage: q_bernoulli_polynomial(-1)
+        Traceback (most recent call last):
+        ...
+        ValueError: the argument must be a nonnegative integer
+
+    REFERENCES: [Ca1948]_, [Ca1954]_
+    """
+    m = ZZ(m)
+    if m < 0:
+        raise ValueError("the argument must be a nonnegative integer")
+    cdef int i
+    R = PolynomialRing(ZZ, 'q')
+    q = R.gen()
+    x = PolynomialRing(R, 'x').gen()
+    z = 1 + (q - 1) * x
+    return sum(m.binomial(i) * x ** (m - i) * z ** i * q_bernoulli(i)
+               for i in range(m + 1))

sage/combinat/quickref.py

@@ -0,0 +1,81 @@
+# sage_setup: distribution = sagemath-combinat
+r"""
+Combinatorics quickref
+
+Integer Sequences::
+
+    sage: s = oeis([1,3,19,211]); s                         # optional - internet
+    0: A000275: ...
+    sage: s[0].programs()                                   # optional - internet
+    [('maple', ...),
+     ('mathematica', ...),
+     ('pari',
+      0: {a(n) = if( n<0, 0, n!^2 * 4^n * polcoeff( 1 / besselj(0, x + x * O(x^(2*n))), 2*n))}; /* _Michael Somos_, May 17 2004 */)]
+
+Combinatorial objects::
+
+    sage: S = Subsets([1,2,3,4]); S.list(); S.<tab>                       # not tested
+    sage: P = Partitions(10000); P.cardinality()                                        # needs sage.libs.flint
+    3616...315650422081868605887952568754066420592310556052906916435144
+    sage: Combinations([1,3,7]).random_element()            # random
+    sage: Compositions(5, max_part=3).unrank(3)
+    [2, 2, 1]
+
+    sage: DyckWord([1,0,1,0,1,1,0,0]).to_binary_tree()                                  # needs sage.graphs
+    [., [., [[., .], .]]]
+    sage: Permutation([3,1,4,2]).robinson_schensted()
+    [[[1, 2], [3, 4]], [[1, 3], [2, 4]]]
+    sage: StandardTableau([[1, 4], [2, 5], [3]]).schuetzenberger_involution()
+    [[1, 3], [2, 4], [5]]
+
+Constructions and Species::
+
+    sage: for (p, s) in cartesian_product([P,S]): print((p, s)) # not tested
+    sage: def IV_3(n):
+    ....:     return IntegerVectors(n, 3)
+    sage: DisjointUnionEnumeratedSets(Family(IV_3, NonNegativeIntegers))  # not tested
+
+Words::
+
+    sage: Words('abc', 4).list()
+    [word: aaaa, ..., word: cccc]
+
+    sage: Word('aabcacbaa').is_palindrome()
+    True
+    sage: WordMorphism('a->ab,b->a').fixed_point('a')
+    word: abaababaabaababaababaabaababaabaababaaba...
+
+Polytopes::
+
+    sage: points = random_matrix(ZZ, 6, 3, x=7).rows()                                  # needs sage.modules
+    sage: L = LatticePolytope(points)                                                   # needs sage.geometry.polyhedron sage.modules
+    sage: L.npoints(); L.plot3d()                           # random                    # needs palp sage.geometry.polyhedron sage.modules sage.plot
+
+:ref:`Root systems, Coxeter and Weyl groups <sage.combinat.root_system.all>`::
+
+    sage: WeylGroup(["B",3]).bruhat_poset()                                             # needs sage.graphs sage.modules
+    Finite poset containing 48 elements
+    sage: RootSystem(["A",2,1]).weight_lattice().plot()         # not tested            # needs sage.graphs sage.modules sage.plot
+
+:ref:`Crystals <sage.combinat.crystals.all>`::
+
+    sage: CrystalOfTableaux(["A",3], shape=[3,2]).some_flashy_feature()   # not tested
+
+:mod:`Symmetric functions and combinatorial Hopf algebras <sage.combinat.algebraic_combinatorics>`::
+
+    sage: Sym = SymmetricFunctions(QQ); Sym.inject_shorthands(verbose=False)            # needs sage.sage.modules
+    sage: m( ( h[2,1] * (1 + 3 * p[2,1]) ) + s[2](s[3]) )                               # needs sage.sage.modules
+    3*m[1, 1, 1] + ... + 10*m[5, 1] + 4*m[6]
+
+:ref:`Discrete groups, Permutation groups <sage.groups.groups_catalog>`::
+
+    sage: S = SymmetricGroup(4)                                                         # needs sage.groups
+    sage: M = PolynomialRing(QQ, 'x0,x1,x2,x3')
+    sage: M.an_element() * S.an_element()                                               # needs sage.groups
+    x0
+
+Graph theory, posets, lattices (:ref:`sage.graphs`, :ref:`sage.combinat.posets.all`)::
+
+    sage: Poset({1: [2,3], 2: [4], 3: [4]}).linear_extensions().cardinality()           # needs sage.graphs sage.modules
+    2
+"""