omnibias-difference 0.1.0a2__py3-none-any.whl

omnibias/difference/__init__.py

@@ -0,0 +1,268 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Derivon
+r"""omnibias-difference -- the founding ``delta -> 0`` register for discrete calculus.
+
+This package is the **founding bias collapse** the library is named for: ``K``
+biases on a difference stencil (spread ``delta``), with signs
+``s_k = (-1)^(K-k) C(K-1, k-1) / delta^(K-1)``, so
+
+.. math::
+
+    f_K(z) = \sum_k s_k\,\sigma(z + b_k) \;\longrightarrow\; \sigma^{(K-1)}(z + b_{\text{mean}})
+        \qquad \text{as } \delta \to 0.
+
+The many biases coalesce and the finite difference *becomes* the derivative
+``sigma^(K-1)``. The closed-form tower evaluates that limit **exactly**, with no
+``1/delta^(K-1)`` catastrophic cancellation.
+
+This is a ``delta -> 0`` limit yielding a smooth **derivative** -- it is **not**
+**temperature collapse** -- the ``beta -> inf`` *feasibility penalty* of
+``omnibias-convex`` / ``-control`` / ``-routing`` (a 0/1 step). Same word, opposite limit: **do not
+conflate** the two (see the ``omnibias-core-concepts`` skill and
+``docs/derivatives.md``).
+
+Honesty labels used throughout: **closed-form** (the sigma / sech / tanh towers
+and the exact integer/rational special-number coefficients) and **numerical**
+(the finite-difference estimate and any floating-point asymptotic). There is no
+``autodiff-exact`` path in this package.
+
+The pure-Python core (:mod:`omnibias.difference._core`) imports only
+``omnibias.core.*``. The optional :mod:`omnibias.difference.torch` /
+:mod:`omnibias.difference.jax` twins add a bit-identical finite-difference
+stencil operator and require the respective backend.
+
+.. important::
+
+    **Bit-parity with the PyTorch twin requires 64-bit JAX** --
+    ``jax.config.update("jax_enable_x64", True)`` before the first JAX array is
+    created (or ``JAX_ENABLE_X64=1``). JAX otherwise truncates to ``float32``
+    while PyTorch uses ``float64``, so the twins stay internally consistent but
+    agree only to ``float32`` tolerance. Where a value feeds a threshold, a
+    rounding step or an ``argmax``, that is enough to change the decision rather
+    than just the last digits. See :mod:`omnibias.jax.precision`.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError as _PkgNotFound
+from importlib.metadata import version as _pkg_version
+
+from omnibias.difference._core import (
+    DerivativeEnclosure,
+    DerivativeProofVerdict,
+    DerivBound,
+    DifferenceEstimate,
+    FiniteDifferenceCertificate,
+    IrregularStencil,
+    RationalIdentityVerdict,
+    ShefferClass,
+    StencilRequest,
+    TransferEstimate,
+    accuracy_order,
+    appell_sequence,
+    apply_irregular_stencil,
+    associated_sequence,
+    bell_asymptotic_relative_error,
+    bell_dobinski_enclosure,
+    bell_number,
+    bell_number_asymptotic,
+    bell_number_asymptotic_refined,
+    bernoulli_asymptotic,
+    bernoulli_enclosure,
+    bernoulli_number,
+    bernoulli_polynomial,
+    bernoulli_recurrence_identity,
+    bernoulli_sign_certificate,
+    binomial_coefficient,
+    binomial_transform,
+    catalan_asymptotic,
+    cauchy_product,
+    certified_derivative_enclosure,
+    certified_fd_error,
+    certified_fd_error_general,
+    certified_irregular_error,
+    check_derivative_certificate,
+    check_identity_certificate,
+    compose_series,
+    compositional_inverse,
+    connection_constants,
+    delta_operator_apply,
+    derivative_sign_certificate,
+    dirichlet_beta_odd_enclosure,
+    dominant_pole_coefficient_asymptotic,
+    euler_asymptotic,
+    euler_enclosure,
+    euler_number,
+    euler_polynomial,
+    euler_recurrence_identity,
+    eulerian_number,
+    exponential_generating_coeffs,
+    falling_factorial_coeffs,
+    falling_to_monomial,
+    finite_difference_estimate,
+    forward_difference,
+    inverse_binomial_transform,
+    is_poised_exact,
+    log_bell_number_asymptotic,
+    log_bell_number_asymptotic_refined,
+    monomial_to_falling,
+    newton_forward_coeffs,
+    newton_forward_value,
+    offsets_exact,
+    ordinary_from_exponential,
+    pade_approximant,
+    pade_certified_remainder,
+    pade_evaluate,
+    pade_evaluate_interval,
+    physical_weights,
+    pincherle_derivative,
+    polya_screen,
+    power_sum_coeffs,
+    rational_ogf_coefficients,
+    rational_ogf_growth_base,
+    rational_series,
+    rational_value_identity,
+    recommended_bell_fallback_n,
+    riordan_array,
+    riordan_inverse,
+    riordan_product,
+    rising_factorial_coeffs,
+    series_reciprocal,
+    sheffer_classify,
+    sheffer_sequence,
+    shift_polynomial,
+    sigma_deriv_bound,
+    signs_exact,
+    singular_template_coefficient,
+    solve_irregular_stencil,
+    stencil_offsets,
+    stencil_signs,
+    stirling_first_signed,
+    stirling_first_signed_row,
+    stirling_first_unsigned,
+    stirling_second,
+    stirling_second_asymptotic,
+    stirling_second_row,
+    thiele_evaluate,
+    thiele_interpolation,
+    transfer_theorem,
+    umbral_composition,
+    umbral_functional,
+    zeta_int_enclosure,
+    zeta_negative_odd_identity,
+)
+
+try:
+    __version__ = _pkg_version("omnibias-difference")
+except _PkgNotFound:  # pragma: no cover - bare source checkout
+    __version__ = "0.0.0+unknown"
+
+# Limit family exposed as package metadata.
+__lineage__ = "bias collapse"
+
+__all__ = [
+    "DerivBound",
+    "DerivativeEnclosure",
+    "DerivativeProofVerdict",
+    "DifferenceEstimate",
+    "FiniteDifferenceCertificate",
+    "IrregularStencil",
+    "RationalIdentityVerdict",
+    "ShefferClass",
+    "StencilRequest",
+    "TransferEstimate",
+    "__lineage__",
+    "__version__",
+    "accuracy_order",
+    "appell_sequence",
+    "apply_irregular_stencil",
+    "associated_sequence",
+    "bell_asymptotic_relative_error",
+    "bell_dobinski_enclosure",
+    "bell_number",
+    "bell_number_asymptotic",
+    "bell_number_asymptotic_refined",
+    "bernoulli_asymptotic",
+    "bernoulli_enclosure",
+    "bernoulli_number",
+    "bernoulli_polynomial",
+    "bernoulli_recurrence_identity",
+    "bernoulli_sign_certificate",
+    "binomial_coefficient",
+    "binomial_transform",
+    "catalan_asymptotic",
+    "cauchy_product",
+    "certified_derivative_enclosure",
+    "certified_fd_error",
+    "certified_fd_error_general",
+    "certified_irregular_error",
+    "check_derivative_certificate",
+    "check_identity_certificate",
+    "compose_series",
+    "compositional_inverse",
+    "connection_constants",
+    "delta_operator_apply",
+    "derivative_sign_certificate",
+    "dirichlet_beta_odd_enclosure",
+    "dominant_pole_coefficient_asymptotic",
+    "euler_asymptotic",
+    "euler_enclosure",
+    "euler_number",
+    "euler_polynomial",
+    "euler_recurrence_identity",
+    "eulerian_number",
+    "exponential_generating_coeffs",
+    "falling_factorial_coeffs",
+    "falling_to_monomial",
+    "finite_difference_estimate",
+    "forward_difference",
+    "inverse_binomial_transform",
+    "is_poised_exact",
+    "log_bell_number_asymptotic",
+    "log_bell_number_asymptotic_refined",
+    "monomial_to_falling",
+    "newton_forward_coeffs",
+    "newton_forward_value",
+    "offsets_exact",
+    "ordinary_from_exponential",
+    "pade_approximant",
+    "pade_certified_remainder",
+    "pade_evaluate",
+    "pade_evaluate_interval",
+    "physical_weights",
+    "pincherle_derivative",
+    "polya_screen",
+    "power_sum_coeffs",
+    "rational_ogf_coefficients",
+    "rational_ogf_growth_base",
+    "rational_series",
+    "rational_value_identity",
+    "recommended_bell_fallback_n",
+    "riordan_array",
+    "riordan_inverse",
+    "riordan_product",
+    "rising_factorial_coeffs",
+    "series_reciprocal",
+    "sheffer_classify",
+    "sheffer_sequence",
+    "shift_polynomial",
+    "sigma_deriv_bound",
+    "signs_exact",
+    "singular_template_coefficient",
+    "solve_irregular_stencil",
+    "stencil_offsets",
+    "stencil_signs",
+    "stirling_first_signed",
+    "stirling_first_signed_row",
+    "stirling_first_unsigned",
+    "stirling_second",
+    "stirling_second_asymptotic",
+    "stirling_second_row",
+    "thiele_evaluate",
+    "thiele_interpolation",
+    "transfer_theorem",
+    "umbral_composition",
+    "umbral_functional",
+    "zeta_int_enclosure",
+    "zeta_negative_odd_identity",
+]

omnibias/difference/_core/__init__.py

@@ -0,0 +1,245 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Derivon
+"""Pure-Python core of :mod:`omnibias.difference` (imports only ``omnibias.core.*``).
+
+The founding ``delta -> 0`` bias-collapse math: backend-neutral finite-difference
+stencils, certified finite-difference -> derivative extraction, the special-number
+readers (Stirling / Bernoulli / Euler off the closed-form towers), umbral / Sheffer
+calculus, and the leading asymptotics.
+"""
+
+from __future__ import annotations
+
+from omnibias.difference._core.asymptotics import (
+    bell_number_asymptotic,
+    bernoulli_asymptotic,
+    euler_asymptotic,
+    log_bell_number_asymptotic,
+    stirling_second_asymptotic,
+)
+from omnibias.difference._core.bernoulli import (
+    bernoulli_number,
+    bernoulli_polynomial,
+    power_sum_coeffs,
+)
+from omnibias.difference._core.certify import (
+    DerivativeProofVerdict,
+    check_derivative_certificate,
+    derivative_sign_certificate,
+)
+from omnibias.difference._core.euler import (
+    euler_number,
+    euler_polynomial,
+    eulerian_number,
+)
+from omnibias.difference._core.extraction import (
+    DerivativeEnclosure,
+    DerivBound,
+    DifferenceEstimate,
+    FiniteDifferenceCertificate,
+    certified_derivative_enclosure,
+    certified_fd_error,
+    certified_fd_error_general,
+    finite_difference_estimate,
+    sigma_deriv_bound,
+)
+from omnibias.difference._core.generating import (
+    TransferEstimate,
+    bell_asymptotic_relative_error,
+    bell_dobinski_enclosure,
+    bell_number_asymptotic_refined,
+    bernoulli_enclosure,
+    catalan_asymptotic,
+    cauchy_product,
+    dirichlet_beta_odd_enclosure,
+    dominant_pole_coefficient_asymptotic,
+    euler_enclosure,
+    exponential_generating_coeffs,
+    log_bell_number_asymptotic_refined,
+    ordinary_from_exponential,
+    rational_ogf_coefficients,
+    rational_ogf_growth_base,
+    recommended_bell_fallback_n,
+    singular_template_coefficient,
+    transfer_theorem,
+    zeta_int_enclosure,
+)
+from omnibias.difference._core.identities import (
+    RationalIdentityVerdict,
+    bernoulli_recurrence_identity,
+    bernoulli_sign_certificate,
+    check_identity_certificate,
+    euler_recurrence_identity,
+    rational_value_identity,
+    zeta_negative_odd_identity,
+)
+from omnibias.difference._core.irregular import (
+    IrregularStencil,
+    StencilRequest,
+    apply_irregular_stencil,
+    certified_irregular_error,
+    is_poised_exact,
+    physical_weights,
+    polya_screen,
+    solve_irregular_stencil,
+)
+from omnibias.difference._core.pade import (
+    pade_approximant,
+    pade_certified_remainder,
+    pade_evaluate,
+    pade_evaluate_interval,
+    rational_series,
+    thiele_evaluate,
+    thiele_interpolation,
+)
+from omnibias.difference._core.sheffer import (
+    associated_sequence,
+    delta_operator_apply,
+    pincherle_derivative,
+    sheffer_sequence,
+    shift_polynomial,
+    umbral_composition,
+    umbral_functional,
+)
+from omnibias.difference._core.stencil import (
+    accuracy_order,
+    offsets_exact,
+    signs_exact,
+    stencil_offsets,
+    stencil_signs,
+)
+from omnibias.difference._core.stirling import (
+    bell_number,
+    falling_factorial_coeffs,
+    rising_factorial_coeffs,
+    stirling_first_signed,
+    stirling_first_signed_row,
+    stirling_first_unsigned,
+    stirling_second,
+    stirling_second_row,
+)
+from omnibias.difference._core.umbral import (
+    ShefferClass,
+    appell_sequence,
+    binomial_coefficient,
+    binomial_transform,
+    compose_series,
+    compositional_inverse,
+    connection_constants,
+    falling_to_monomial,
+    forward_difference,
+    inverse_binomial_transform,
+    monomial_to_falling,
+    newton_forward_coeffs,
+    newton_forward_value,
+    riordan_array,
+    riordan_inverse,
+    riordan_product,
+    series_reciprocal,
+    sheffer_classify,
+)
+
+__all__ = [
+    "DerivBound",
+    "DerivativeEnclosure",
+    "DerivativeProofVerdict",
+    "DifferenceEstimate",
+    "FiniteDifferenceCertificate",
+    "IrregularStencil",
+    "RationalIdentityVerdict",
+    "ShefferClass",
+    "StencilRequest",
+    "TransferEstimate",
+    "accuracy_order",
+    "appell_sequence",
+    "apply_irregular_stencil",
+    "associated_sequence",
+    "bell_asymptotic_relative_error",
+    "bell_dobinski_enclosure",
+    "bell_number",
+    "bell_number_asymptotic",
+    "bell_number_asymptotic_refined",
+    "bernoulli_asymptotic",
+    "bernoulli_enclosure",
+    "bernoulli_number",
+    "bernoulli_polynomial",
+    "bernoulli_recurrence_identity",
+    "bernoulli_sign_certificate",
+    "binomial_coefficient",
+    "binomial_transform",
+    "catalan_asymptotic",
+    "cauchy_product",
+    "certified_derivative_enclosure",
+    "certified_fd_error",
+    "certified_fd_error_general",
+    "certified_irregular_error",
+    "check_derivative_certificate",
+    "check_identity_certificate",
+    "compose_series",
+    "compositional_inverse",
+    "connection_constants",
+    "delta_operator_apply",
+    "derivative_sign_certificate",
+    "dirichlet_beta_odd_enclosure",
+    "dominant_pole_coefficient_asymptotic",
+    "euler_asymptotic",
+    "euler_enclosure",
+    "euler_number",
+    "euler_polynomial",
+    "euler_recurrence_identity",
+    "eulerian_number",
+    "exponential_generating_coeffs",
+    "falling_factorial_coeffs",
+    "falling_to_monomial",
+    "finite_difference_estimate",
+    "forward_difference",
+    "inverse_binomial_transform",
+    "is_poised_exact",
+    "log_bell_number_asymptotic",
+    "log_bell_number_asymptotic_refined",
+    "monomial_to_falling",
+    "newton_forward_coeffs",
+    "newton_forward_value",
+    "offsets_exact",
+    "ordinary_from_exponential",
+    "pade_approximant",
+    "pade_certified_remainder",
+    "pade_evaluate",
+    "pade_evaluate_interval",
+    "physical_weights",
+    "pincherle_derivative",
+    "polya_screen",
+    "power_sum_coeffs",
+    "rational_ogf_coefficients",
+    "rational_ogf_growth_base",
+    "rational_series",
+    "rational_value_identity",
+    "recommended_bell_fallback_n",
+    "riordan_array",
+    "riordan_inverse",
+    "riordan_product",
+    "rising_factorial_coeffs",
+    "series_reciprocal",
+    "sheffer_classify",
+    "sheffer_sequence",
+    "shift_polynomial",
+    "sigma_deriv_bound",
+    "signs_exact",
+    "singular_template_coefficient",
+    "solve_irregular_stencil",
+    "stencil_offsets",
+    "stencil_signs",
+    "stirling_first_signed",
+    "stirling_first_signed_row",
+    "stirling_first_unsigned",
+    "stirling_second",
+    "stirling_second_asymptotic",
+    "stirling_second_row",
+    "thiele_evaluate",
+    "thiele_interpolation",
+    "transfer_theorem",
+    "umbral_composition",
+    "umbral_functional",
+    "zeta_int_enclosure",
+    "zeta_negative_odd_identity",
+]

omnibias/difference/_core/asymptotics.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Derivon
+r"""Leading asymptotics of the analytic-combinatorics coefficients (pure ``math``).
+
+Closed-form leading asymptotics for the numbers extracted off the towers. Each is
+the genuine leading term (relative error ``-> 0`` as the index grows); the exact
+values and a high-precision ``mpmath`` cross-check live in the tests.
+
+* **Bernoulli** ``B_{2m} ~ (-1)^{m+1} 2 (2m)! / (2 pi)^{2m}`` (fast: relative
+  error ``O(2^{-2m})``).
+* **Euler (secant)** ``E_{2m} ~ (-1)^m 2^{2m+2} (2m)! / pi^{2m+1}`` (fast).
+* **Stirling second kind, fixed ``k``** ``S(n, k) ~ k^n / k!`` as ``n -> inf``.
+* **Bell numbers** -- the Dobinski saddle-point form
+  ``B_n ~ e^{n/r - 1} n! / (r^n sqrt(2 pi n (r+1)))`` with ``r = W(n)`` (Lambert
+  W); relative error ``~1%`` by ``n = 30`` and shrinking.
+
+Values are returned as ``float`` and are computed in log space where possible, so
+they stay finite far past the point where ``(2m)!`` would overflow a double; the
+Bell helper also exposes its logarithm for very large ``n``.
+"""
+
+from __future__ import annotations
+
+from math import exp, lgamma, log, pi
+
+
+def bernoulli_asymptotic(n: int) -> float:
+    r"""Signed leading asymptotic of ``B_n`` (even ``n = 2m >= 2`` only).
+
+    ``B_{2m} ~ (-1)^{m+1} 2 (2m)! / (2 pi)^{2m}``.
+    """
+    if n < 2 or n % 2 == 1:
+        raise ValueError(f"Bernoulli asymptotic is defined for even n >= 2, got {n}")
+    m = n // 2
+    log_mag = log(2.0) + lgamma(n + 1) - n * log(2.0 * pi)
+    return (-1.0) ** (m + 1) * exp(log_mag)
+
+
+def euler_asymptotic(n: int) -> float:
+    r"""Signed leading asymptotic of the Euler (secant) number ``E_n`` (even ``n = 2m >= 2``).
+
+    ``E_{2m} ~ (-1)^m 2^{2m+2} (2m)! / pi^{2m+1}``.
+    """
+    if n < 2 or n % 2 == 1:
+        raise ValueError(f"Euler asymptotic is defined for even n >= 2, got {n}")
+    m = n // 2
+    log_mag = (2 * m + 2) * log(2.0) + lgamma(n + 1) - (2 * m + 1) * log(pi)
+    return (-1.0) ** m * exp(log_mag)
+
+
+def stirling_second_asymptotic(n: int, k: int) -> float:
+    r"""Fixed-``k`` leading asymptotic ``S(n, k) ~ k^n / k!`` as ``n -> inf``."""
+    if k < 1:
+        raise ValueError(f"k must be >= 1, got {k}")
+    if n < 0:
+        raise ValueError(f"n must be >= 0, got {n}")
+    return exp(n * log(k) - lgamma(k + 1))
+
+
+def _lambert_w(x: float) -> float:
+    """Principal real branch ``W(x)`` for ``x >= 0`` (Halley iteration)."""
+    if x < 0.0:
+        raise ValueError(f"_lambert_w supports x >= 0 only, got {x}")
+    if x == 0.0:
+        return 0.0
+    w = log(1.0 + x)  # globally safe start for x > 0
+    for _ in range(100):
+        ew = exp(w)
+        f = w * ew - x
+        denom = ew * (w + 1.0) - (w + 2.0) * f / (2.0 * w + 2.0)
+        w_next = w - f / denom
+        if abs(w_next - w) <= 1e-16 * (1.0 + abs(w_next)):
+            return w_next
+        w = w_next
+    return w
+
+
+def log_bell_number_asymptotic(n: int) -> float:
+    r"""Natural log of the Bell-number saddle-point asymptotic (safe for large ``n``)."""
+    if n < 1:
+        raise ValueError(f"n must be >= 1, got {n}")
+    r = _lambert_w(float(n))
+    return (n / r - 1.0) + lgamma(n + 1) - n * log(r) - 0.5 * log(2.0 * pi * n * (r + 1.0))
+
+
+def bell_number_asymptotic(n: int) -> float:
+    r"""Dobinski saddle-point asymptotic of the Bell number ``Bell(n)``.
+
+    ``Bell(n) ~ e^{n/r - 1} n! / (r^n sqrt(2 pi n (r+1)))`` with ``r = W(n)``. Use
+    :func:`log_bell_number_asymptotic` when ``n`` is large enough to overflow.
+    """
+    return exp(log_bell_number_asymptotic(n))
+
+
+__all__ = [
+    "bell_number_asymptotic",
+    "bernoulli_asymptotic",
+    "euler_asymptotic",
+    "log_bell_number_asymptotic",
+    "stirling_second_asymptotic",
+]

omnibias/difference/_core/bernoulli.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (C) 2026 Derivon
+r"""Bernoulli numbers read off the closed-form ``tanh`` tower (exact rationals).
+
+The odd derivatives of ``tanh`` at the origin are the (signed) **tangent
+numbers** ``tanh^(2m-1)(0)``, read straight off the constant term of the exact
+``tanh`` derivative-tower polynomial
+(:func:`omnibias.core.verified.coeffs.tanh_poly_coeffs_exact`). The Taylor series
+``tanh(x) = sum_{m>=1} 2^{2m}(2^{2m}-1) B_{2m}/(2m)! x^{2m-1}`` then gives the
+even Bernoulli numbers exactly:
+
+.. math::
+
+    B_{2m} = \tanh^{(2m-1)}(0)\;\frac{2m}{2^{2m}\,(2^{2m}-1)}.
+
+Convention: ``B_0 = 1``, ``B_1 = -1/2`` (the "first Bernoulli number"; matches
+``mpmath.bernoulli``), and ``B_{2m+1} = 0`` for ``m >= 1``.
+"""
+
+from __future__ import annotations
+
+from fractions import Fraction
+from math import comb
+
+from omnibias.core.verified.coeffs import bernoulli_number_exact
+
+
+def bernoulli_number(n: int) -> Fraction:
+    """The ``n``-th Bernoulli number ``B_n`` (exact ``Fraction``; ``B_1 = -1/2``).
+
+    A thin re-export of :func:`omnibias.core.verified.coeffs.bernoulli_number_exact`
+    -- the shared source of truth also consumed by the certified Euler-Maclaurin
+    engine -- so the Bernoulli numbers are defined once (off the ``tanh`` tower) and
+    never forked per package.
+    """
+    return bernoulli_number_exact(n)
+
+
+def bernoulli_polynomial(n: int) -> tuple[Fraction, ...]:
+    r"""Coefficients of the Bernoulli polynomial ``B_n(x) = sum_k C(n,k) B_{n-k} x^k``.
+
+    Returns ``(c_0, ..., c_n)`` with ``B_n(x) = sum_k c_k x^k``. This is an Appell
+    sequence: ``B_n'(x) = n B_{n-1}(x)`` and ``B_n(0) = B_n``.
+    """
+    if n < 0:
+        raise ValueError(f"n must be >= 0, got {n}")
+    return tuple(Fraction(comb(n, k)) * bernoulli_number(n - k) for k in range(n + 1))
+
+
+def power_sum_coeffs(p: int) -> tuple[Fraction, ...]:
+    r"""Faulhaber coefficients of ``S_p(N) = sum_{i=0}^{N-1} i^p`` as a polynomial in ``N``.
+
+    Returns ``(c_0, ..., c_{p+1})`` with ``S_p(N) = sum_j c_j N^j``, via
+    ``S_p(N) = (B_{p+1}(N) - B_{p+1}) / (p + 1)``. (Sum runs to ``N - 1``, the
+    convention matched to ``B_1 = -1/2``.)
+    """
+    if p < 0:
+        raise ValueError(f"p must be >= 0, got {p}")
+    out = [Fraction(0)] * (p + 2)
+    for k in range(1, p + 2):
+        out[k] = Fraction(comb(p + 1, k)) * bernoulli_number(p + 1 - k) / Fraction(p + 1)
+    return tuple(out)
+
+
+__all__ = [
+    "bernoulli_number",
+    "bernoulli_polynomial",
+    "power_sum_coeffs",
+]