symplex 0.49.0

//! One identity for every mathematical function: [`Func`], with its
//! declarative data in a [`FuncSpec`], generated from **one list** together
//! with the public [`LibFn`].
//!
//! A function reaches the arena in one of three representations:
//!
//! - a dedicated [`ExprNode`] variant (`Sin(x)`, `Beta(a, b)`, `Min(…)`:
//!   the 43 *node-backed* functions);
//! - an `Apply(name, args)` whose head names a library function (the 50
//!   [`LibFn`]s: Bessel, orthogonal polynomials, `erfi`, …);
//! - an `Apply` headed by one of the 8 internal pseudo-functions of Gruntz's
//!   asymptotic rewrite (`__ei_asym`, …; they exist only inside a limit
//!   computation and are never parsed).
//!
//! Until 0.49 nothing named "the function" across the three: code that had
//! to treat a family uniformly matched node variants *and* compared `Apply`
//! names, and code that identified a node by its shape confused functions —
//! `evalf`'s conjugate pairing signed every `Apply` alike, so `Shi(z̄)` and
//! `erfi(z)` "paired" and an imaginary part of 10⁻⁴⁵ became exactly 0, a
//! value off by 2πi after a logarithm.  [`Func`] is that identity: one
//! variant per function whatever its representation, `Copy`, hashable, and
//! exhaustive, so a `match f` that forgets a function does not compile.
//! User functions (`Context::apply("f", …)`) are not functions in this
//! sense: nothing is known about them, and they have no `Func`.
//!
//! # The list
//!
//! Every function is one entry of the `funcs!` invocation below: its
//! variant name and a [`FuncSpec`] struct literal written out in full
//! (`name` first, no `..`).  Adding a field to `FuncSpec` makes every entry
//! that does not set it a compile error (E0063), so a new function cannot
//! forget a facet and a new facet cannot forget a function.  The library
//! entries also generate the public [`LibFn`] — same variants, order, names
//! and arities as before the list existed — and `From<LibFn> for Func`.
//!
//! Only facets that are *data*, uniform across the representations, live in
//! the spec: the name, the parser's further names, the argument count, the
//! sort-key sub-rank and the LaTeX layout, and five facets with semantics,
//! each read by the code that used to keep a list of its own:
//!
//! | Facet | Says | Read by |
//! |---|---|---|
//! | [`Conj`] | where `conj f(z…) = f(conj z…)` | `conjugate` (`base/complex.rs`), `evalf`'s exact-realness signatures |
//! | [`RealOn`] | on which arguments `f` is real | the assumption system (`compute_func`) |
//! | [`Parity`] | `f(−z) = ±f(z)`, and how the sign is extracted today | a test against `canon`/`eval` |
//! | [`Poles`] | where `f` is infinite at finite arguments | the assumption system (no claim at a known pole) |
//! | [`Constants`] | whether its special values at constants are folded | the assumption system (no claim at constants otherwise) |
//!
//! Up to 0.48 symbolic conjugation knew 14 functions and `evalf` 35, in
//! two lists that disagreed, and the assumption system knew no library
//! function at all: `conjugate(erfi(z))` stayed unevaluated and
//! `erfi(x)` for a real `x` was not known to be real.  The values come
//! from DLMF and SymPy; an entry says why where it is not obvious, and
//! each rule is checked numerically (mpmath at two complex points off
//! the cut).  Algorithms (evaluation, derivatives, series, integration)
//! stay in their modules as exhaustive `match f: Func` arms.
//!
//! # Which entry point
//!
//! | Need | Use |
//! |---|---|
//! | which function a node applies, and to what | [`ExprNode::func`] (`None` for non-functions and user functions) |
//! | build `f(args)` as today's constructors do (canonical folds included) | [`Arena::func`] (arity-checked) |
//! | a function's data | [`Func::spec`] |
//! | the public library-function type | [`LibFn`] (`Func::from`, [`Func::as_lib`]) |
//!
//! # Corner cases
//!
//! - **Lambert W.**  The principal branch `W(x)` is the node
//!   `ExprNode::LambertW`, [`Func::LambertW0`]; the library function
//!   `lambertw(x, k)` ([`LibFn::LambertW`], [`Func::LambertW`]) carries the
//!   other branches.  `Arena::func(Func::LambertW, [x])` and `[x, 0]` build
//!   the node, as `lambertw(x)` and `lambertw(x, 0)` parse.  Both print as
//!   `W`; the library entry's `name` is its interned head `lambertw`.
//! - **Names.**  `name` is the head `Display` prints in call notation (and
//!   the interned head symbol of an `Apply` family).  Two exceptions, both
//!   tested: `Factorial` prints postfix (`n!`) and `lambertw(x, k)` prints
//!   as `W(x, k)`.  The parser compares names ignoring ASCII case, except
//!   Heaviside's display name `H`, which it reads only as written (and only
//!   while no undefined function `H` exists); `parse` lists the names it
//!   reads besides `name`, at the function's own arity (`log(x, b)` is a
//!   quotient, not `ln`).
//! - **Wrong argument counts.**  An `Apply` whose head names a library or
//!   internal function but whose argument count the function does not
//!   accept (`ctx.apply("Shi", [x, 3])`) is not a call of that function:
//!   every consumer leaves it unevaluated, and [`ExprNode::func`] returns
//!   `None`.
//! - **Sort keys.**  [`SortSub`] reproduces the hand-assigned bytes of
//!   `sort_key.rs` exactly.  `Binomial` and `Asin` share byte 8 (since
//!   0.13; byte identity keeps it), the one allowlisted duplicate.
//! - **`Min`/`Max`** take any positive number of arguments
//!   ([`ArgCount::AtLeast`]); one argument folds to itself.  The parser asks
//!   for two.
//! - **Internal names are reserved.**  [`Context::apply`] refuses them and
//!   the parser does not read them, so a user expression never takes on
//!   the asymptotic semantics of `__ei_asym` (up to 0.48 `apply("__ei_asym",
//!   [x])` had limit 0 at `∞`).
//! - **Poles and the generic point.**  A claim of the table ("real",
//!   "finite complex") is withheld only where an argument is *known* to be
//!   at a pole ([`Poles`]); a symbol is a generic point, so `Γ(x)` for a
//!   real `x` is real, as it was before the table.  A *constant* is not a
//!   generic point: a function whose special values at constants are not
//!   all folded at construction ([`Constants::Evaluated`]: the library
//!   functions, `B`) gets no claim at constant arguments — it is a number
//!   for evaluation to decide, and an unfolded zero (`subfactorial(1)`,
//!   `chebyshev_t(3, 0)`) called "real" would make `√2/subfactorial(1)`
//!   real.
//!
//! [`Context::apply`]: crate::api::context::Context::apply

use std::fmt;

use smallvec::{SmallVec, smallvec};

use crate::base::arena::Arena;
use crate::base::errors::SymplexError;
use crate::base::libfn::Arity;
use crate::base::node::{ExprId, ExprNode, SymbolId};

// ---------------------------------------------------------------------------
// The facets
// ---------------------------------------------------------------------------

/// How many arguments a [`Func`] takes.
///
/// The public [`Arity`] of a [`LibFn`] cannot say "any number": `Min` and
/// `Max` need [`AtLeast`](Self::AtLeast).  [`LibFn::arity`] is this, read
/// back as an `Arity`.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum ArgCount {
    /// Exactly `n` arguments.
    Exactly(u8),
    /// Between `min` and `max` arguments, inclusive (`lambertw(x)` or
    /// `lambertw(x, k)`).
    Between {
        /// Fewest arguments accepted.
        min: u8,
        /// Most arguments accepted.
        max: u8,
    },
    /// `min` arguments or more (`min(a, b, …)`).
    AtLeast(u8),
}

impl ArgCount {
    /// Does a call with `n` arguments have an acceptable shape?
    pub(crate) const fn accepts(self, n: usize) -> bool {
        match self {
            ArgCount::Exactly(k) => n == k as usize,
            ArgCount::Between { min, max } => min as usize <= n && n <= max as usize,
            ArgCount::AtLeast(min) => min as usize <= n,
        }
    }

    /// The public [`Arity`] of a library function.  No library function
    /// is variadic (tested); `AtLeast` would read as a range up to 255.
    const fn lib_arity(self) -> Arity {
        match self {
            ArgCount::Exactly(n) => Arity::Fixed(n),
            ArgCount::Between { min, max } => Arity::Range { min, max },
            ArgCount::AtLeast(min) => Arity::Range { min, max: u8::MAX },
        }
    }
}

impl fmt::Display for ArgCount {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match *self {
            ArgCount::Exactly(1) => f.write_str("1 argument"),
            ArgCount::Exactly(n) => write!(f, "{n} arguments"),
            ArgCount::Between { min, max } => write!(f, "{min} to {max} arguments"),
            ArgCount::AtLeast(1) => f.write_str("at least 1 argument"),
            ArgCount::AtLeast(n) => write!(f, "at least {n} arguments"),
        }
    }
}

/// Where a function's nodes sort: the leading bytes of their sort key,
/// before the arguments' keys (see `sort_key.rs`, whose bytes these
/// reproduce; a test compares them for every [`Func`]).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum SortSub {
    /// The function rank (100), then this byte.
    Function(u8),
    /// A rank of its own (`Min` 130, `Max` 132).
    Rank(u8),
    /// The function rank (100), the `Apply` byte (17), the interned name and
    /// a 0 byte: library and internal functions sort by name among
    /// themselves and with user functions.
    Named,
}

/// The LaTeX layout of a call, with each argument rendered in place.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum Tex {
    /// `head\left(a, b, …\right)`.
    Call(&'static str),
    /// Literal pieces and argument slots, in output order
    /// (`\binom{n}{k}`, `\operatorname{E}_{n}\left(x\right)`).
    Layout(&'static [TexPiece]),
    /// `a!` for an atom `a`, `\left(a\right)!` otherwise.
    Postfix(&'static str),
}

/// One piece of a [`Tex::Layout`].
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum TexPiece {
    /// Literal LaTeX.
    Lit(&'static str),
    /// The argument at this position.
    Arg(u8),
}

/// A branch cut: where, in the values of one argument, a function's
/// principal branch is discontinuous (DLMF §4.2(i), §4.23(vii), §6.2,
/// §10.2(ii), §8.2(i), §25.12).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) struct Cut {
    /// The position of the argument whose values are cut.
    pub(crate) arg: u8,
    /// The cut.
    pub(crate) line: CutLine,
}

/// The point sets of the complex plane that the cuts of the table are.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum CutLine {
    /// `(−∞, 0]`: `ln`, `ln Γ`, `Ci`, `Ei`, `Chi`, `E_n`, the incomplete
    /// gamma functions, the Bessel functions of non-integer order.
    NonPositiveReals,
    /// `(−∞, 1]`: `acosh`, `li`.
    BelowOne,
    /// `[1, ∞)`: `polylog`, the complete elliptic integrals.
    AtLeastOne,
    /// `(−∞, −1] ∪ [1, ∞)`: `asin`, `acos`, `atanh`.
    OutsideUnitInterval,
    /// `(−i∞, −i] ∪ [i, i∞)`: `atan`, `asinh`.
    ImaginaryOutsideUnit,
}

/// Complex conjugation: where `conj f(z₁, …, zₙ) = f(conj z₁, …, conj
/// zₙ)` (every argument conjugated) holds.  `conjugate` (`base/complex.rs`)
/// pushes the conjugate inside where the rule holds by the assumptions, and
/// `evalf`'s exact-realness signatures (`evalf/conjugate.rs`) pair `f(z̄)`
/// with `f(z)` where it holds for the computed values.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum Conj {
    /// Everywhere: the function is entire or meromorphic in every
    /// argument and real on the real axis (Schwarz reflection, DLMF
    /// §1.10(ii)).
    Entire,
    /// Everywhere off the cut; on it the principal branch breaks the
    /// symmetry (`conj √−1 = −i ≠ √(conj −1)`).
    OffCut(Cut),
    /// Everywhere when the first argument (an order) is an integer
    /// (`nonnegative`: an integer `≥ 0`), where the function is entire or
    /// meromorphic in the others; off the cut otherwise (`J_ν`, `I_ν`;
    /// `ψ⁽ᵐ⁾`, which is `ln Γ`, cut, at `m = −1`).
    IntegerOrderOffCut {
        /// The cut for the other orders.
        cut: Cut,
        /// Whether the order must also be non-negative.
        nonnegative: bool,
    },
    /// Everywhere when argument `degree` is a non-negative integer: the
    /// function is then a polynomial in the others with real coefficients.
    /// No rule otherwise.
    Polynomial {
        /// The position of the degree.
        degree: u8,
    },
    /// No rule: none holds, or one holds off a cut or for a definition
    /// the consumers cannot test (the entry says which).
    No,
}

/// Where a function is real: the argument domain on which the assumption
/// system claims `f(args)` real.  The handler of the table
/// (`AssumptionCache::compute_func`) reads the variants up to
/// [`NonNegativeIntegers`](Self::NonNegativeIntegers); the functions with
/// the later variants have handlers of their own, which a test checks
/// against the variant.
///
/// Claims are made away from the poles only in the sense of [`Poles`]: an
/// argument known to be at a pole withholds every claim; one merely real
/// does not (`Γ(x)` for a real `x` is real).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum RealOn {
    /// Real when every argument is real; finite complex when every
    /// argument is (`erfi`, `Γ`, `B(a, b)`, `min`).
    Reals,
    /// Real when every argument is real; defined there only, so no complex
    /// claim (the real-analytic continuations of counting sequences that
    /// `evalf` evaluates at real arguments: `fibonacci`, `bernoulli`).
    RealLine,
    /// Real when the last argument is positive (and finite) and the others
    /// are real; finite complex when the last argument is (`ln Γ`, `Chi`,
    /// `Y_ν`, `ψ⁽ᵐ⁾`: the earlier arguments are parameters).
    PositiveReals,
    /// Real when the last argument is non-negative (and finite) and the
    /// others are real; finite complex as for
    /// [`PositiveReals`](Self::PositiveReals) (`W₀`, `H_x`).
    NonNegativeReals,
    /// Real when the last argument is a real below 1 (known non-positive,
    /// or a rational literal `< 1`) and the others are real; finite complex
    /// as for [`PositiveReals`](Self::PositiveReals) (`K(m)`, `F(φ | m)`).
    BelowOne,
    /// Real for a real argument known to lie in `[−1, 1]` (`closed`) or
    /// `(−1, 1)` (a rational literal, `sin`/`cos`/`tanh` of a real): `asin`,
    /// `acos`, `atanh`, `erfinv`.  No complex claim by the table.
    UnitInterval {
        /// Whether `±1` belong to the domain.
        closed: bool,
    },
    /// Real when argument `degree` is a non-negative integer and the
    /// others are real; finite complex when it is one and the others are
    /// complex (the orthogonal polynomials, `(x)ₙ`).
    Polynomial {
        /// The position of the degree.
        degree: u8,
    },
    /// Real when the order (first argument) is an integer and the second
    /// argument real, or the order is real and the second argument
    /// positive; finite complex when both are complex (`J_ν`, `I_ν`).
    BesselOrder,
    /// Real when every argument is a non-negative integer (the counting
    /// sequences, defined at the integers only).  No complex claim.
    NonNegativeIntegers,
    /// Real on `[1, ∞)` (`acosh`).
    AtLeastOne,
    /// Integer-valued for a real argument (`floor`, `ceiling`, `sign`).
    IntegerValued,
    /// Real for every argument (`abs`, `re`, `im`, `arg`).
    Everywhere,
    /// Decided by a handler of its own from the arguments' facts
    /// (`conjugate`, `KroneckerDelta`).
    Custom,
    /// No claim: the function may be real somewhere (the entry says
    /// where), but the assumption system cannot express where.
    Unclaimed,
}

/// Symmetry under `z ↦ −z` (of the only argument), and how today's
/// canonical forms and `eval` extract the sign.  The extraction is
/// written in `canon.rs` and `eval.rs`; a test checks it against this
/// facet for every function, so a change to one is a test failure until
/// the other follows.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum Parity {
    /// `f(−z) = −f(z)`.
    Odd(AutoSign),
    /// `f(−z) = f(z)`.
    Even(AutoSign),
    /// Neither (and every function of more than one argument).
    Neither,
}

/// Which negated arguments the sign is pulled out of automatically.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum AutoSign {
    /// At construction, from any argument with a negative coefficient
    /// (`Si(−2x)` is `−Si(2x)`).
    Canonical,
    /// By `eval`, from any argument with a negative coefficient
    /// (`erfi(−2x)` → `−erfi(2x)`).
    Coefficient,
    /// By `eval`, from a negated term or a negative number (`sin(−x)` →
    /// `−sin(x)`; `sin(−2x)` stays).
    Negation,
    /// By `eval`, from a symbol-free argument only (`erf(−2)` → `−erf(2)`;
    /// `erf(−x)` stays).
    SymbolFree,
    /// Never.
    Never,
}

/// Whether the table's claims extend to constant arguments.
///
/// The assumption system treats a real value as a generic point (`1/x` is
/// real for a real `x`).  A constant is a specific number: if it is an
/// unfolded exact zero, "real" makes `1/c` real and `im(1/c)` 0.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum Constants {
    /// The constructors fold the function's special values at constant
    /// arguments (`Γ(−2) = zoo`, `ζ(−2) = 0`, `Si(0) = 0`): claims hold for
    /// constants as for symbols.
    Folded,
    /// Some special values at constant arguments stay unfolded
    /// (`subfactorial(1)`, `chebyshev_t(3, 0)`, `B(1/2, −1/2)` are 0): claims
    /// are made for arguments with a symbol only, and a constant is left to
    /// evaluation.
    Evaluated,
}

/// Where a function is infinite (a pole or a logarithmic singularity) at
/// finite arguments.  An argument *known* to be there withholds every
/// claim of the table's handler (`Γ(n)` for an integer `n ≤ 0` is
/// `zoo`); claims for arguments merely real or complex are made (the
/// convention of the assumption system: a symbol is a generic point).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum Poles {
    /// Finite at every finite argument.
    None,
    /// Where any of these arguments is an integer `≤ 0`.
    NonPositiveIntegers(&'static [u8]),
    /// Where this argument is 0.
    Zero(u8),
    /// Where this argument is 1.
    One(u8),
    /// Elsewhere, at points the facet does not describe (`tan` at
    /// `π/2 + kπ`): the table then claims no complex value, and claims
    /// realness only on a domain clear of them.
    Other,
}

/// The data of one function.  Every entry of the list writes every field
/// (a struct literal without `..`), so a new field is a compile error
/// until each function says what it is.
#[derive(Clone, Copy, Debug)]
#[cfg_attr(
    not(test),
    expect(
        dead_code,
        reason = "`parse`, `sort`, `tex` and `parity` are read by the tests over `Func::ALL`; the \
                  printers, parser, sort keys and sign extraction migrate to them later"
    )
)]
pub(crate) struct FuncSpec {
    /// The name: the head `Display` prints in call notation (`sin`,
    /// `Gamma`, `W`, `C`), and for a library or internal function the
    /// interned head of its `Apply` node (`besselj`, `lambertw`,
    /// `__ei_asym`).  See the module documentation for the two printing
    /// exceptions.
    pub(crate) name: &'static str,
    /// Further names the parser reads as this function at its arity
    /// (`arcsin`, `ceil`, `log`), compared ignoring ASCII case.
    pub(crate) parse: &'static [&'static str],
    /// The accepted argument counts.
    pub(crate) arity: ArgCount,
    /// The sort-key sub-rank.
    pub(crate) sort: SortSub,
    /// The LaTeX layout.
    pub(crate) tex: Tex,
    /// Where complex conjugation commutes with the function.
    pub(crate) conj: Conj,
    /// Where the function is real.
    pub(crate) real_on: RealOn,
    /// Symmetry under negation and today's automatic sign extraction.
    pub(crate) parity: Parity,
    /// Where the function is infinite.
    pub(crate) poles: Poles,
    /// Whether the claims extend to constant arguments.
    pub(crate) constants: Constants,
}

/// Which representation a [`Func`] has in the arena.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub(crate) enum Family {
    /// A dedicated [`ExprNode`] variant.
    Node,
    /// `Apply` headed by a [`LibFn`] name.
    Lib,
    /// `Apply` headed by an internal `__…` name (never parsed).
    Internal,
}

// ---------------------------------------------------------------------------
// The generator
// ---------------------------------------------------------------------------

/// Generates [`Func`], its spec table, the public [`LibFn`] and the
/// conversions from the three groups of entries.  Each entry is
/// `Variant => FuncSpec { name: "…", <every other field> };`; the `name`
/// literal is matched separately so that `LibFn::name`/`from_name` stay
/// plain `match`es on string literals.
macro_rules! funcs {
    (
        node {
            $( $(#[$ndoc:meta])* $N:ident => FuncSpec {
                name: $nname:literal, $( $nfield:ident : $nvalue:expr ),+ $(,)?
            }; )*
        }
        lib {
            $( $(#[$ldoc:meta])* $L:ident => FuncSpec {
                name: $lname:literal, $( $lfield:ident : $lvalue:expr ),+ $(,)?
            }; )*
        }
        internal {
            $( $(#[$idoc:meta])* $I:ident => FuncSpec {
                name: $iname:literal, $( $ifield:ident : $ivalue:expr ),+ $(,)?
            }; )*
        }
    ) => {
        /// A library special function carried as `Apply(name, args)`.
        ///
        /// The variant order is the declaration order of the historical
        /// `FN_*` name constants and is the order of [`LibFn::ALL`].  The
        /// type is generated, together with the crate's internal function
        /// identity, from the one function list in `base/func.rs`.
        ///
        /// ```
        /// use symplex::base::libfn::LibFn;
        ///
        /// assert_eq!(LibFn::UpperGamma.name(), "uppergamma");
        /// assert_eq!(LibFn::from_name("besselj"), Some(LibFn::BesselJ));
        /// assert_eq!(LibFn::from_name("sin"), None);
        /// assert_eq!(LibFn::ALL.len(), 50);
        /// assert_eq!(LibFn::Shi.to_string(), "Shi");
        /// ```
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
        pub enum LibFn {
            $( $(#[$ldoc])* $L, )*
        }

        impl LibFn {
            /// Every library function, in declaration order.
            pub const ALL: &[LibFn] = &[ $( LibFn::$L, )* ];

            /// The interned name: what the `Apply` node's symbol holds and
            /// what `Display` prints (`lambertw(x, k)` prints as `W(x, k)`).
            pub const fn name(self) -> &'static str {
                match self { $( LibFn::$L => $lname, )* }
            }

            /// The function whose interned name is exactly `s`.
            pub fn from_name(s: &str) -> Option<LibFn> {
                match s { $( $lname => Some(LibFn::$L), )* _ => None }
            }

            /// The number of arguments the function takes; a call of any
            /// other length is left unevaluated by every consumer.
            pub const fn arity(self) -> Arity {
                self.func().spec().arity.lib_arity()
            }

            /// The function identity of this library function.
            pub(crate) const fn func(self) -> Func {
                match self { $( LibFn::$L => Func::$L, )* }
            }
        }

        /// One mathematical function, whatever its representation in the
        /// arena (see the [module documentation](self)).
        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
        pub(crate) enum Func {
            $( $(#[$ndoc])* $N, )*
            $( $(#[$ldoc])* $L, )*
            $( $(#[$idoc])* $I, )*
        }

        impl Func {
            /// Every function: the node-backed ones in `ExprNode` order, the
            /// library functions in [`LibFn::ALL`] order, then the internal
            /// ones.
            #[cfg_attr(
                not(test),
                expect(dead_code, reason = "iterated by the tests; by the table consumers in W6")
            )]
            pub(crate) const ALL: &[Func] = &[
                $( Func::$N, )* $( Func::$L, )* $( Func::$I, )*
            ];

            /// The specs, indexed by discriminant (the order of `ALL`).
            const SPECS: &[FuncSpec] = &[
                $( FuncSpec { name: $nname, $( $nfield: $nvalue ),+ }, )*
                $( FuncSpec { name: $lname, $( $lfield: $lvalue ),+ }, )*
                $( FuncSpec { name: $iname, $( $ifield: $ivalue ),+ }, )*
            ];

            /// The function's data.
            pub(crate) const fn spec(self) -> &'static FuncSpec {
                &Self::SPECS[self as usize]
            }

            /// The representation of the function's nodes.
            pub(crate) const fn family(self) -> Family {
                match self {
                    $( Func::$N => Family::Node, )*
                    $( Func::$L => Family::Lib, )*
                    $( Func::$I => Family::Internal, )*
                }
            }

            /// The public library function, for the 50 that are one.
            pub(crate) const fn as_lib(self) -> Option<LibFn> {
                match self {
                    $( Func::$N => None, )*
                    $( Func::$L => Some(LibFn::$L), )*
                    $( Func::$I => None, )*
                }
            }

            /// The internal function whose head is exactly `s`.
            fn internal_named(s: &str) -> Option<Func> {
                match s { $( $iname => Some(Func::$I), )* _ => None }
            }
        }

        /// The pattern matching every function that is not node-backed.
        macro_rules! non_node_funcs {
            () => { $( Func::$L )|* | $( Func::$I )|* };
        }
    };
}

impl From<LibFn> for Func {
    fn from(f: LibFn) -> Func {
        f.func()
    }
}

use ArgCount::{AtLeast, Between, Exactly};
use AutoSign::{Canonical, Coefficient, Negation, SymbolFree};
use Parity::{Even, Neither, Odd};
use SortSub::{Function, Named, Rank};
use TexPiece::{Arg, Lit};

/// The cut `(−∞, 0]` of the first argument.
const NEG0: Cut = Cut {
    arg: 0,
    line: CutLine::NonPositiveReals,
};
/// The cut `(−∞, 0]` of the second argument.
const NEG1: Cut = Cut {
    arg: 1,
    line: CutLine::NonPositiveReals,
};

funcs! {
    node {
        /// Minimum `min(a, b, …)`.
        Min => FuncSpec {
            name: "min", parse: &[], arity: AtLeast(1), sort: Rank(130), tex: Tex::Call(r"\min"),
            // Of real arguments only (the order of ℝ).
            conj: Conj::No, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Maximum `max(a, b, …)`.
        Max => FuncSpec {
            name: "max", parse: &[], arity: AtLeast(1), sort: Rank(132), tex: Tex::Call(r"\max"),
            conj: Conj::No, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Floor `⌊x⌋`.
        Floor => FuncSpec {
            name: "floor", parse: &[], arity: Exactly(1), sort: Function(20),
            tex: Tex::Layout(&[Lit(r"\lfloor "), Arg(0), Lit(r"\rfloor")]),
            // SymPy's `floor(x + iy) = floor(x) + i·floor(y)` does not reflect:
            // `floor(−y) ≠ −floor(y)`.
            conj: Conj::No, real_on: RealOn::IntegerValued, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Ceiling `⌈x⌉`.
        Ceiling => FuncSpec {
            name: "ceiling", parse: &["ceil"], arity: Exactly(1), sort: Function(21),
            tex: Tex::Layout(&[Lit(r"\lceil "), Arg(0), Lit(r"\rceil")]),
            conj: Conj::No, real_on: RealOn::IntegerValued, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Sine.
        Sin => FuncSpec {
            name: "sin", parse: &[], arity: Exactly(1), sort: Function(0), tex: Tex::Call(r"\sin"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Negation), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Cosine.
        Cos => FuncSpec {
            name: "cos", parse: &[], arity: Exactly(1), sort: Function(1), tex: Tex::Call(r"\cos"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Even(Negation), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Tangent.
        Tan => FuncSpec {
            name: "tan", parse: &[], arity: Exactly(1), sort: Function(2), tex: Tex::Call(r"\tan"),
            // Poles at π/2 + kπ; real and finite for a real argument by the
            // generic convention of its own handler (`compute_trig`).
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Negation), poles: Poles::Other,
            constants: Constants::Folded,
        };
        /// Exponential `eˣ`.
        Exp => FuncSpec {
            name: "exp", parse: &[], arity: Exactly(1), sort: Function(3), tex: Tex::Call(r"\exp"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Natural logarithm (`log(x)` with one argument).
        Ln => FuncSpec {
            name: "ln", parse: &["log"], arity: Exactly(1), sort: Function(4), tex: Tex::Call(r"\ln"),
            conj: Conj::OffCut(NEG0), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(0),
            constants: Constants::Folded,
        };
        /// Absolute value (complex modulus).
        Abs => FuncSpec {
            name: "abs", parse: &[], arity: Exactly(1), sort: Function(6),
            tex: Tex::Layout(&[Lit(r"\left|"), Arg(0), Lit(r"\right|")]),
            conj: Conj::Entire, real_on: RealOn::Everywhere, parity: Even(Canonical),
            poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Inverse sine.
        Asin => FuncSpec {
            name: "asin", parse: &["arcsin"], arity: Exactly(1), sort: Function(8),
            tex: Tex::Call(r"\arcsin"),
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::OutsideUnitInterval }),
            real_on: RealOn::UnitInterval { closed: true }, parity: Odd(SymbolFree),
            poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Inverse cosine.
        Acos => FuncSpec {
            name: "acos", parse: &["arccos"], arity: Exactly(1), sort: Function(9),
            tex: Tex::Call(r"\arccos"),
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::OutsideUnitInterval }),
            real_on: RealOn::UnitInterval { closed: true }, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Inverse tangent.
        Atan => FuncSpec {
            name: "atan", parse: &["arctan"], arity: Exactly(1), sort: Function(10),
            tex: Tex::Call(r"\arctan"),
            // Poles at ±i.
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::ImaginaryOutsideUnit }),
            real_on: RealOn::Reals, parity: Odd(SymbolFree), poles: Poles::Other,
            constants: Constants::Folded,
        };
        /// Two-argument arctangent `atan2(y, x)`.
        Atan2 => FuncSpec {
            name: "atan2", parse: &[], arity: Exactly(2), sort: Function(19),
            tex: Tex::Call(r"\operatorname{atan2}"),
            // Of real arguments only.
            conj: Conj::No, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Hyperbolic sine.
        Sinh => FuncSpec {
            name: "sinh", parse: &[], arity: Exactly(1), sort: Function(11), tex: Tex::Call(r"\sinh"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Negation), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Hyperbolic cosine.
        Cosh => FuncSpec {
            name: "cosh", parse: &[], arity: Exactly(1), sort: Function(12), tex: Tex::Call(r"\cosh"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Even(Negation), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Hyperbolic tangent.
        Tanh => FuncSpec {
            name: "tanh", parse: &[], arity: Exactly(1), sort: Function(13), tex: Tex::Call(r"\tanh"),
            // Poles at i(π/2 + kπ).
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Negation), poles: Poles::Other,
            constants: Constants::Folded,
        };
        /// Inverse hyperbolic sine.
        Asinh => FuncSpec {
            name: "asinh", parse: &["arcsinh"], arity: Exactly(1), sort: Function(14),
            tex: Tex::Call(r"\operatorname{asinh}"),
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::ImaginaryOutsideUnit }),
            real_on: RealOn::Reals, parity: Odd(SymbolFree), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Inverse hyperbolic cosine.
        Acosh => FuncSpec {
            name: "acosh", parse: &["arccosh"], arity: Exactly(1), sort: Function(15),
            tex: Tex::Call(r"\operatorname{acosh}"),
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::BelowOne }),
            real_on: RealOn::AtLeastOne, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Inverse hyperbolic tangent.
        Atanh => FuncSpec {
            name: "atanh", parse: &["arctanh"], arity: Exactly(1), sort: Function(16),
            tex: Tex::Call(r"\operatorname{atanh}"),
            // Poles at ±1.
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::OutsideUnitInterval }),
            real_on: RealOn::UnitInterval { closed: false }, parity: Odd(SymbolFree),
            poles: Poles::Other,
            constants: Constants::Folded,
        };
        /// Sign function.
        Sign => FuncSpec {
            name: "sign", parse: &["sgn"], arity: Exactly(1), sort: Function(18),
            tex: Tex::Call(r"\operatorname{sgn}"),
            // `sign z = z/|z|` (SymPy's `sign._eval_conjugate`).
            conj: Conj::Entire, real_on: RealOn::IntegerValued, parity: Odd(Canonical),
            poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Heaviside step `H(x)` (the parser reads `H` only as written).
        Heaviside => FuncSpec {
            name: "H", parse: &["heaviside"], arity: Exactly(1), sort: Function(28),
            tex: Tex::Call(r"\operatorname{H}"),
            // Of real arguments.
            conj: Conj::No, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Dirac delta `δ(x)`.
        DiracDelta => FuncSpec {
            name: "DiracDelta", parse: &["dirac_delta"], arity: Exactly(1), sort: Function(29),
            tex: Tex::Call(r"\delta"),
            // A distribution: 0 off the origin, no value at it.
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Even(AutoSign::Never),
            poles: Poles::Other,
            constants: Constants::Folded,
        };
        /// Real part.
        Re => FuncSpec {
            name: "re", parse: &[], arity: Exactly(1), sort: Function(31), tex: Tex::Call(r"\Re"),
            conj: Conj::Entire, real_on: RealOn::Everywhere, parity: Odd(Canonical),
            poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Imaginary part.
        Im => FuncSpec {
            name: "im", parse: &[], arity: Exactly(1), sort: Function(32), tex: Tex::Call(r"\Im"),
            // `im z̄ = −im z`.
            conj: Conj::No, real_on: RealOn::Everywhere, parity: Odd(Canonical), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Complex conjugate.
        Conjugate => FuncSpec {
            name: "conjugate", parse: &["conj"], arity: Exactly(1), sort: Function(33),
            tex: Tex::Layout(&[Lit(r"\overline{"), Arg(0), Lit("}")]),
            conj: Conj::Entire, real_on: RealOn::Custom, parity: Odd(Canonical), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Principal argument `arg(z) ∈ (−π, π]`.
        Arg => FuncSpec {
            name: "arg", parse: &[], arity: Exactly(1), sort: Function(34), tex: Tex::Call(r"\arg"),
            // `arg z̄ = −arg z` off the cut.
            conj: Conj::No, real_on: RealOn::Everywhere, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Gamma function.
        Gamma => FuncSpec {
            name: "Gamma", parse: &[], arity: Exactly(1), sort: Function(22), tex: Tex::Call(r"\Gamma"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither,
            poles: Poles::NonPositiveIntegers(&[0]),
            constants: Constants::Folded,
        };
        /// Log-gamma function.
        LogGamma => FuncSpec {
            name: "LogGamma", parse: &[], arity: Exactly(1), sort: Function(23),
            tex: Tex::Call(r"\ln \Gamma"),
            conj: Conj::OffCut(NEG0), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::NonPositiveIntegers(&[0]),
            constants: Constants::Folded,
        };
        /// Digamma `ψ(x)`.
        Digamma => FuncSpec {
            name: "Digamma", parse: &[], arity: Exactly(1), sort: Function(24), tex: Tex::Call(r"\psi"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither,
            poles: Poles::NonPositiveIntegers(&[0]),
            constants: Constants::Folded,
        };
        /// Error function.
        Erf => FuncSpec {
            name: "erf", parse: &[], arity: Exactly(1), sort: Function(25),
            tex: Tex::Call(r"\operatorname{erf}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(SymbolFree), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Complementary error function.
        Erfc => FuncSpec {
            name: "erfc", parse: &[], arity: Exactly(1), sort: Function(26),
            tex: Tex::Call(r"\operatorname{erfc}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Principal branch `W₀(x)` of Lambert W (the node `ExprNode::LambertW`;
        /// the other branches are [`Func::LambertW`]).
        LambertW0 => FuncSpec {
            name: "W", parse: &["lambertw"], arity: Exactly(1), sort: Function(30),
            tex: Tex::Call(r"\operatorname{W}"),
            // `W₀(z̄) = conj W₀(z)` off the cut `(−∞, −1/e]`, which no consumer
            // tests; real on `[−1/e, ∞)` (DLMF §4.13), claimed on `[0, ∞)`.
            conj: Conj::No, real_on: RealOn::NonNegativeReals, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Beta function `B(a, b)`.
        Beta => FuncSpec {
            name: "B", parse: &["beta"], arity: Exactly(2), sort: Function(27),
            tex: Tex::Call(r"\mathrm{B}"),
            // `Γ(a)Γ(b)/Γ(a + b)`; real for real arguments as SymPy's `beta`.
            // Zero where `a + b` is a pole and `a`, `b` are not: `B(1/2, −1/2)`
            // stays unfolded.
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither,
            poles: Poles::NonPositiveIntegers(&[0, 1]),
            constants: Constants::Evaluated,
        };
        /// Sine integral.
        Si => FuncSpec {
            name: "Si", parse: &[], arity: Exactly(1), sort: Function(35),
            tex: Tex::Call(r"\operatorname{Si}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Canonical), poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Cosine integral.
        Ci => FuncSpec {
            name: "Ci", parse: &[], arity: Exactly(1), sort: Function(36),
            tex: Tex::Call(r"\operatorname{Ci}"),
            // `Ci(−x) = Ci(x) + iπ` for `x > 0` (DLMF §6.4).
            conj: Conj::OffCut(NEG0), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(0),
            constants: Constants::Folded,
        };
        /// Exponential integral.
        Ei => FuncSpec {
            name: "Ei", parse: &[], arity: Exactly(1), sort: Function(37),
            tex: Tex::Call(r"\operatorname{Ei}"),
            // Real on the whole real line (the principal value on the cut,
            // where the reflection holds too; tested off it only).
            conj: Conj::OffCut(NEG0), real_on: RealOn::Reals, parity: Neither, poles: Poles::Zero(0),
            constants: Constants::Folded,
        };
        /// Logarithmic integral.
        Li => FuncSpec {
            name: "li", parse: &[], arity: Exactly(1), sort: Function(38),
            tex: Tex::Call(r"\operatorname{li}"),
            // `li z = Ei(ln z)` is cut along `(−∞, 0]` only (real on `(0, 1)`);
            // `(−∞, 1]` is the sufficient test `evalf` has used since 0.45.
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::BelowOne }),
            real_on: RealOn::PositiveReals, parity: Neither, poles: Poles::One(0),
            constants: Constants::Folded,
        };
        /// Riemann zeta.
        Zeta => FuncSpec {
            name: "zeta", parse: &[], arity: Exactly(1), sort: Function(39), tex: Tex::Call(r"\zeta"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::One(0),
            constants: Constants::Folded,
        };
        /// Polygamma `ψ⁽ⁿ⁾(x)`, `polygamma(n, x)`.
        Polygamma => FuncSpec {
            name: "polygamma", parse: &[], arity: Exactly(2), sort: Function(40),
            tex: Tex::Layout(&[Lit(r"\psi^{("), Arg(0), Lit(r")}\left("), Arg(1), Lit(r"\right)")]),
            // Meromorphic in `x` for an order `m ≥ 0`; for other real orders
            // (`ζ(m + 1, x)`-like, real for `x > 0` in mpmath's and SymPy's
            // definitions) cut along `x ≤ 0`.
            conj: Conj::IntegerOrderOffCut { cut: NEG1, nonnegative: true },
            real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::NonPositiveIntegers(&[1]),
            constants: Constants::Folded,
        };
        /// Kronecker delta `δᵢⱼ`.
        KroneckerDelta => FuncSpec {
            name: "KroneckerDelta", parse: &["kronecker_delta"], arity: Exactly(2),
            sort: Function(41),
            tex: Tex::Layout(&[Lit(r"\delta_{"), Arg(0), Lit(" "), Arg(1), Lit("}")]),
            // 0 or 1: `δ(ī, j̄) = δ(i, j)`.
            conj: Conj::Entire, real_on: RealOn::Custom, parity: Neither, poles: Poles::None,
            constants: Constants::Folded,
        };
        /// Factorial `n!` (printed postfix).
        Factorial => FuncSpec {
            name: "factorial", parse: &[], arity: Exactly(1), sort: Function(7),
            tex: Tex::Postfix("!"),
            // `Γ(x + 1)`: poles at the negative integers, so claimed real on
            // `[0, ∞)` only (SymPy: real for a non-negative or non-integer `x`).
            conj: Conj::Entire, real_on: RealOn::NonNegativeReals, parity: Neither,
            poles: Poles::Other,
            constants: Constants::Folded,
        };
        /// Binomial coefficient `C(n, k)`.  Its sort byte 8 is `Asin`'s too.
        Binomial => FuncSpec {
            name: "C", parse: &["binomial"], arity: Exactly(2), sort: Function(8),
            tex: Tex::Layout(&[Lit(r"\binom{"), Arg(0), Lit("}{"), Arg(1), Lit("}")]),
            // `Γ(n + 1)/(Γ(k + 1)Γ(n − k + 1))`, meromorphic; an integer for
            // non-negative integers.
            conj: Conj::Entire, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::Other,
            constants: Constants::Folded,
        };
    }
    lib {
        // ── Integer sequences and combinatorial counts ────────────────────────
        /// Double factorial `n!!`.
        Factorial2 => FuncSpec {
            name: "factorial2", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("factorial2"),
            // Integers (SymPy's extension to ℂ is not evaluated here); `(−2k)!!`
            // is infinite.
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Subfactorial (derangement count) `!n`.
        Subfactorial => FuncSpec {
            name: "subfactorial", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("subfactorial"),
            // SymPy's extension `Γ(n + 1, −1)/e` sits on the cut of `Γ(a, ·)`.
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Rising factorial (Pochhammer symbol) `(x)_n = x (x+1) ⋯ (x+n−1)`.
        RisingFactorial => FuncSpec {
            name: "rising_factorial", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("rising_factorial"),
            // `Γ(x + n)/Γ(x)` (DLMF §5.2(iii)): a polynomial in `x` for an
            // integer `n ≥ 0`.
            conj: Conj::Entire, real_on: RealOn::Polynomial { degree: 1 }, parity: Neither,
            poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Falling factorial `x^(n) = x (x−1) ⋯ (x−n+1)`.
        FallingFactorial => FuncSpec {
            name: "falling_factorial", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("falling_factorial"),
            // `Γ(x + 1)/Γ(x − n + 1)`.
            conj: Conj::Entire, real_on: RealOn::Polynomial { degree: 1 }, parity: Neither,
            poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Fibonacci number `F_n`.
        Fibonacci => FuncSpec {
            name: "fibonacci", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("fibonacci"),
            // Binet's `(φˣ − cos(πx)φ⁻ˣ)/√5` at real `x` (`evalf`).
            conj: Conj::No, real_on: RealOn::RealLine, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Lucas number `L_n`.
        Lucas => FuncSpec {
            name: "lucas", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("lucas"),
            conj: Conj::No, real_on: RealOn::RealLine, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Bernoulli number `B_n`.
        Bernoulli => FuncSpec {
            name: "bernoulli", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("bernoulli"),
            // `−s·ζ(1 − s)` at real `s` (`evalf`), entire, is `+1/2` at `s = 1`,
            // but the exact `bernoulli(1)` is `−1/2` (SymPy 1.14: `1/2`): not
            // claimed real off the integers, where a limit would cross the
            // jump (`limₓ→₀ li(bernoulli(x + 1))` came out `li(−1/2)`).
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Harmonic number `H_n`.
        Harmonic => FuncSpec {
            name: "harmonic", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("harmonic"),
            // `ψ(x + 1) + γ`: poles at the negative integers.
            conj: Conj::No, real_on: RealOn::NonNegativeReals, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Catalan number `C_n`.
        Catalan => FuncSpec {
            name: "catalan", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("catalan"),
            // `Γ(2x + 1)/(Γ(x + 1)Γ(x + 2))`: poles at `x = −1/2, −3/2, …`.
            conj: Conj::No, real_on: RealOn::NonNegativeReals, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Bell number `B_n`.
        Bell => FuncSpec {
            name: "bell", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("bell"),
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Euler number `E_n`.
        EulerNumber => FuncSpec {
            name: "euler_number", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("euler_number"),
            // By Hurwitz zeta functions at real `s` (`evalf`), entire.
            conj: Conj::No, real_on: RealOn::RealLine, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Signed Stirling number of the first kind `s(n, k)`.
        Stirling1 => FuncSpec {
            name: "stirling1", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("stirling1"),
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Stirling number of the second kind `S(n, k)`.
        Stirling2 => FuncSpec {
            name: "stirling2", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("stirling2"),
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Integer partition count `p(n)`.
        PartitionCount => FuncSpec {
            name: "partition_count", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("partition_count"),
            conj: Conj::No, real_on: RealOn::NonNegativeIntegers, parity: Neither,
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Lambert W, `lambertw(x, k)`: the branch `W_k` (`k` an integer) of the
        /// inverse of `w·eʷ`, as SymPy's `LambertW(x, k)`.  The principal branch
        /// `k = 0` is the dedicated `ExprNode::LambertW(x)` node, which
        /// `Arena::lambertw_branch` and `eval` build for `lambertw(x)` and
        /// `lambertw(x, 0)`; an `Apply` carries only the other branches.
        LambertW => FuncSpec {
            name: "lambertw", parse: &["w"], arity: Between { min: 1, max: 2 }, sort: Named,
            tex: Tex::Layout(&[
                Lit(r"\operatorname{W}_{"), Arg(1), Lit(r"}\left("), Arg(0), Lit(r"\right)"),
            ]),
            // `W_k(z̄) = conj W_{−k}(z)`, another branch; `W_{−1}` is real on
            // `[−1/e, 0)`; `W_k(0) = −∞` for `k ≠ 0` (DLMF §4.13).
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };

        // ── Bessel functions `(order, x)` ─────────────────────────────────────
        /// Bessel function of the first kind `J_ν(x)`.
        BesselJ => FuncSpec {
            name: "besselj", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("besselj"),
            // Entire in `x` for an integer order, else `(x/2)^ν·(entire)`
            // (DLMF §10.2(ii)); infinite at 0 for some orders.
            conj: Conj::IntegerOrderOffCut { cut: NEG1, nonnegative: false },
            real_on: RealOn::BesselOrder, parity: Neither, poles: Poles::Zero(1),
            constants: Constants::Evaluated,
        };
        /// Bessel function of the second kind `Y_ν(x)`.
        BesselY => FuncSpec {
            name: "bessely", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("bessely"),
            conj: Conj::OffCut(NEG1), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(1),
            constants: Constants::Evaluated,
        };
        /// Modified Bessel function of the first kind `I_ν(x)`.
        BesselI => FuncSpec {
            name: "besseli", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("besseli"),
            conj: Conj::IntegerOrderOffCut { cut: NEG1, nonnegative: false },
            real_on: RealOn::BesselOrder, parity: Neither, poles: Poles::Zero(1),
            constants: Constants::Evaluated,
        };
        /// Modified Bessel function of the second kind `K_ν(x)`.
        BesselK => FuncSpec {
            name: "besselk", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("besselk"),
            conj: Conj::OffCut(NEG1), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(1),
            constants: Constants::Evaluated,
        };

        // ── Classical orthogonal polynomials `(n, x)` ─────────────────────────
        /// Legendre polynomial `P_n(x)`.
        Legendre => FuncSpec {
            name: "legendre", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("legendre"),
            // A polynomial for an integer degree `n ≥ 0`; `₂F₁(−ν, ν + 1; 1;
            // (1 − x)/2)`, infinite at `x = −1`, otherwise.
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Chebyshev polynomial of the first kind `T_n(x)`.
        ChebyshevT => FuncSpec {
            name: "chebyshev_t", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("chebyshev_t"),
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Chebyshev polynomial of the second kind `U_n(x)`.
        ChebyshevU => FuncSpec {
            name: "chebyshev_u", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("chebyshev_u"),
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Physicists' Hermite polynomial `H_n(x)`.
        Hermite => FuncSpec {
            name: "hermite", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("hermite"),
            // Entire in `x` for every degree (DLMF §12.7, §18.5).
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Laguerre polynomial `L_n(x)`.
        Laguerre => FuncSpec {
            name: "laguerre", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call("laguerre"),
            // `₁F₁(−ν; 1; x)`, entire in `x` for every degree.
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };

        // ── Error-function family and integrals (0.9) ─────────────────────────
        /// Imaginary error function `erfi(x)`.
        Erfi => FuncSpec {
            name: "erfi", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{erfi}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Coefficient),
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Inverse error function `erf⁻¹(y)`.
        ErfInv => FuncSpec {
            name: "erfinv", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{erf}^{-1}"),
            // Defined on `(−1, 1)` here (the continuation of the inverse of
            // `erf` is many-valued); `±∞` at `±1`.
            conj: Conj::No, real_on: RealOn::UnitInterval { closed: false },
            parity: Odd(Coefficient), poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Inverse complementary error function `erfc⁻¹(y)`.
        ErfcInv => FuncSpec {
            name: "erfcinv", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{erfc}^{-1}"),
            // Real on `(0, 2)`, which the assumption system cannot express;
            // `±∞` at 0 and 2.
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Generalised exponential integral `E_n(x)`, as `expint(n, x)`.
        ExpInt => FuncSpec {
            name: "expint", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Layout(&[
                Lit(r"\operatorname{E}_{"), Arg(0), Lit(r"}\left("), Arg(1), Lit(r"\right)"),
            ]),
            // `E_n(0)` is infinite for `n ≤ 1` (DLMF §8.19).
            conj: Conj::OffCut(NEG1), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(1),
            constants: Constants::Evaluated,
        };
        /// Hyperbolic sine integral `Shi(x)`.
        Shi => FuncSpec {
            name: "Shi", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{Shi}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Coefficient),
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Hyperbolic cosine integral `Chi(x)`.
        Chi => FuncSpec {
            name: "Chi", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{Chi}"),
            // `Chi(−x) = Chi(x) + iπ` for `x > 0` (DLMF §6.2).
            conj: Conj::OffCut(NEG0), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(0),
            constants: Constants::Evaluated,
        };
        /// Fresnel sine integral `S(x)`.
        FresnelS => FuncSpec {
            name: "fresnels", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("S"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Coefficient),
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Fresnel cosine integral `C(x)`.
        FresnelC => FuncSpec {
            name: "fresnelc", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("C"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Odd(Coefficient),
            poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Lower incomplete gamma `γ(s, x)`.
        LowerGamma => FuncSpec {
            name: "lowergamma", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call(r"\gamma"),
            // `γ(s, x) = xˢ·(entire)`, poles at `s = 0, −1, …` (DLMF §8.2).
            conj: Conj::OffCut(NEG1), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::NonPositiveIntegers(&[0]),
            constants: Constants::Evaluated,
        };
        /// Upper incomplete gamma `Γ(s, x)`.
        UpperGamma => FuncSpec {
            name: "uppergamma", parse: &[], arity: Exactly(2), sort: Named, tex: Tex::Call(r"\Gamma"),
            // Entire in `s` for `x ≠ 0`; `Γ(s, 0) = Γ(s)`.
            conj: Conj::OffCut(NEG1), real_on: RealOn::PositiveReals, parity: Neither,
            poles: Poles::Zero(1),
            constants: Constants::Evaluated,
        };
        /// Polylogarithm `Li_s(z)`, as `polylog(s, z)`.
        PolyLog => FuncSpec {
            name: "polylog", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Layout(&[
                Lit(r"\operatorname{Li}_{"), Arg(0), Lit(r"}\left("), Arg(1), Lit(r"\right)"),
            ]),
            // Cut along `z ∈ [1, ∞)` (DLMF §25.12); `Li_s(1) = ζ(s)`.
            conj: Conj::OffCut(Cut { arg: 1, line: CutLine::AtLeastOne }),
            real_on: RealOn::BelowOne, parity: Neither, poles: Poles::One(1),
            constants: Constants::Evaluated,
        };
        /// Dirichlet eta `η(s)`.
        DirichletEta => FuncSpec {
            name: "dirichlet_eta", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\eta"),
            // `(1 − 2^{1−s})·ζ(s)`, entire.
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };

        // ── Airy functions ────────────────────────────────────────────────────
        /// Airy function `Ai(x)`.
        AiryAi => FuncSpec {
            name: "airyai", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{Ai}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Airy function `Bi(x)`.
        AiryBi => FuncSpec {
            name: "airybi", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{Bi}"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Derivative `Ai′(x)`.
        AiryAiPrime => FuncSpec {
            name: "airyaiprime", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{Ai}^\prime"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Derivative `Bi′(x)`.
        AiryBiPrime => FuncSpec {
            name: "airybiprime", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call(r"\operatorname{Bi}^\prime"),
            conj: Conj::Entire, real_on: RealOn::Reals, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };

        // ── Elliptic integrals (parameter `m = k²`, as in SymPy) ──────────────
        /// Complete elliptic integral of the first kind `K(m)`.
        EllipticK => FuncSpec {
            name: "elliptic_k", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("K"),
            // Cut along `m ∈ [1, ∞)`, `K(1) = ∞` (DLMF §19.2(i)).
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::AtLeastOne }),
            real_on: RealOn::BelowOne, parity: Neither, poles: Poles::One(0),
            constants: Constants::Evaluated,
        };
        /// Complete elliptic integral of the second kind `E(m)`.
        EllipticE => FuncSpec {
            name: "elliptic_e", parse: &[], arity: Exactly(1), sort: Named, tex: Tex::Call("E"),
            conj: Conj::OffCut(Cut { arg: 0, line: CutLine::AtLeastOne }),
            real_on: RealOn::BelowOne, parity: Neither, poles: Poles::None,
            constants: Constants::Evaluated,
        };
        /// Incomplete elliptic integral of the first kind `F(φ | m)`.
        EllipticF => FuncSpec {
            name: "elliptic_f", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Layout(&[Lit(r"F\left("), Arg(0), Lit(r"\middle| "), Arg(1), Lit(r"\right)")]),
            // The cuts in `φ` are not tabulated; real for real `φ` and `m < 1`.
            conj: Conj::No, real_on: RealOn::BelowOne, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Complete elliptic integral of the third kind `Π(n | m)`.
        EllipticPi => FuncSpec {
            name: "elliptic_pi", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Layout(&[Lit(r"\Pi\left("), Arg(0), Lit(r"\middle| "), Arg(1), Lit(r"\right)")]),
            // Cut in both arguments; real for `n, m < 1` (two bounds).
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };

        // ── Orthogonal polynomials with parameters ────────────────────────────
        /// Gegenbauer polynomial `C_n^{(α)}(x)`, as `gegenbauer(n, α, x)`.
        Gegenbauer => FuncSpec {
            name: "gegenbauer", parse: &[], arity: Exactly(3), sort: Named,
            tex: Tex::Layout(&[
                Lit("C_{"), Arg(0), Lit(r"}^{\left("), Arg(1), Lit(r"\right)}\left("), Arg(2),
                Lit(r"\right)"),
            ]),
            // A polynomial in `α` and `x` for an integer `n ≥ 0` (DLMF §18.5);
            // not entire for `n < 0` (mpmath: a `₂F₁` cut at `x ≤ −1`).
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Jacobi polynomial `P_n^{(α,β)}(x)`, as `jacobi(n, α, β, x)`.
        Jacobi => FuncSpec {
            name: "jacobi", parse: &[], arity: Exactly(4), sort: Named,
            tex: Tex::Layout(&[
                Lit("P_{"), Arg(0), Lit(r"}^{\left("), Arg(1), Lit(","), Arg(2),
                Lit(r"\right)}\left("), Arg(3), Lit(r"\right)"),
            ]),
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Associated Legendre function `P_n^m(x)`, as `assoc_legendre(n, m, x)`.
        AssocLegendre => FuncSpec {
            name: "assoc_legendre", parse: &[], arity: Exactly(3), sort: Named,
            tex: Tex::Layout(&[
                Lit("P_{"), Arg(0), Lit(r"}^{\left("), Arg(1), Lit(r"\right)}\left("), Arg(2),
                Lit(r"\right)"),
            ]),
            // The factor `(1 − x²)^{m/2}`: for an odd `m` real on `[−1, 1]` only.
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Generalised Laguerre polynomial `L_n^{(α)}(x)`, as `assoc_laguerre(n, α, x)`.
        AssocLaguerre => FuncSpec {
            name: "assoc_laguerre", parse: &[], arity: Exactly(3), sort: Named,
            tex: Tex::Layout(&[
                Lit("L_{"), Arg(0), Lit(r"}^{\left("), Arg(1), Lit(r"\right)}\left("), Arg(2),
                Lit(r"\right)"),
            ]),
            conj: Conj::Polynomial { degree: 0 }, real_on: RealOn::Polynomial { degree: 0 },
            parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };

        // ── Generalised incomplete beta (0.12), SymPy order `(a, b, x1, x2)` ──
        /// Incomplete beta `B_{(x₁, x₂)}(a, b)`.
        BetaInc => FuncSpec {
            name: "betainc", parse: &[], arity: Exactly(4), sort: Named,
            tex: Tex::Layout(&[
                Lit(r"\operatorname{B}_{("), Arg(2), Lit(", "), Arg(3), Lit(r")}\left("), Arg(0),
                Lit(", "), Arg(1), Lit(r"\right)"),
            ]),
            // `∫ t^{a−1}(1 − t)^{b−1} dt` from `x₁` to `x₂`: real for `x₁, x₂ ∈ [0, 1]`.
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// Regularised incomplete beta `I_{(x₁, x₂)}(a, b)`.
        BetaIncRegularized => FuncSpec {
            name: "betainc_regularized", parse: &[], arity: Exactly(4), sort: Named,
            tex: Tex::Layout(&[
                Lit(r"\operatorname{I}_{("), Arg(2), Lit(", "), Arg(3), Lit(r")}\left("), Arg(0),
                Lit(", "), Arg(1), Lit(r"\right)"),
            ]),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
    }
    internal {
        // Heads of Gruntz's asymptotic rewrite (`calculus/series.rs` reads
        // its `*_ASYMPTOTIC` names from here); each exists only inside a
        // limit computation, where the limit engine knows them: the table
        // claims nothing about them.
        /// `erfcx(z) = e^{z²} erfc(z)` for `z → +∞` (SymPy's `_erfs`).
        ErfcxAsym => FuncSpec {
            name: "__erfcx_asym", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("__erfcx_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `e^{−z} Ei(z)` for `z → ±∞` (SymPy's `_eis`).
        EiAsym => FuncSpec {
            name: "__ei_asym", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("__ei_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `√v·e^{−v} erfi(√v)`, a function of `v = z²`.
        Erfix2Asym => FuncSpec {
            name: "__erfix2_asym", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("__erfix2_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `√v·e^{v} erfc(√v)`, a function of `v = z²`.
        Erfcx2Asym => FuncSpec {
            name: "__erfcx2_asym", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("__erfcx2_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `√(2πz) e^{−z} Iν(z)`, arguments `(ν, z)`.
        BesselIAsym => FuncSpec {
            name: "__besseli_asym", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("__besseli_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `√(2z/π) e^{z} Kν(z)`, arguments `(ν, z)`.
        BesselKAsym => FuncSpec {
            name: "__besselk_asym", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("__besselk_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `z^{1−s} e^{z} Γ(s, z)`, arguments `(s, z)`.
        UpperGammaAsym => FuncSpec {
            name: "__uppergamma_asym", parse: &[], arity: Exactly(2), sort: Named,
            tex: Tex::Call("__uppergamma_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
        /// `2^z (ζ(z) − 1)`.
        ZetaAsym => FuncSpec {
            name: "__zeta_asym", parse: &[], arity: Exactly(1), sort: Named,
            tex: Tex::Call("__zeta_asym"),
            conj: Conj::No, real_on: RealOn::Unclaimed, parity: Neither, poles: Poles::Other,
            constants: Constants::Evaluated,
        };
    }
}

// ---------------------------------------------------------------------------
// The view and the constructor
// ---------------------------------------------------------------------------

impl ExprNode {
    /// The function this node applies and its arguments, in node order;
    /// `None` for a node that is not a function application (a number, a
    /// sum, a relation, …), for a user function, and for an `Apply` whose
    /// head names a library or internal function with an argument count it
    /// does not accept.
    ///
    /// [`Arena::func`] of the result builds this node again (for a
    /// canonical node).  The match is exhaustive over `ExprNode`: a new
    /// variant must say here whether it is a function.
    pub(crate) fn func(&self, arena: &Arena) -> Option<(Func, SmallVec<[ExprId; 4]>)> {
        let one = |f: Func, x: &ExprId| Some((f, smallvec![*x]));
        let two = |f: Func, a: &ExprId, b: &ExprId| Some((f, smallvec![*a, *b]));
        match self {
            ExprNode::Min(xs) => Some((Func::Min, xs.clone())),
            ExprNode::Max(xs) => Some((Func::Max, xs.clone())),
            ExprNode::Floor(x) => one(Func::Floor, x),
            ExprNode::Ceiling(x) => one(Func::Ceiling, x),
            ExprNode::Sin(x) => one(Func::Sin, x),
            ExprNode::Cos(x) => one(Func::Cos, x),
            ExprNode::Tan(x) => one(Func::Tan, x),
            ExprNode::Exp(x) => one(Func::Exp, x),
            ExprNode::Ln(x) => one(Func::Ln, x),
            ExprNode::Abs(x) => one(Func::Abs, x),
            ExprNode::Asin(x) => one(Func::Asin, x),
            ExprNode::Acos(x) => one(Func::Acos, x),
            ExprNode::Atan(x) => one(Func::Atan, x),
            ExprNode::Atan2(y, x) => two(Func::Atan2, y, x),
            ExprNode::Sinh(x) => one(Func::Sinh, x),
            ExprNode::Cosh(x) => one(Func::Cosh, x),
            ExprNode::Tanh(x) => one(Func::Tanh, x),
            ExprNode::Asinh(x) => one(Func::Asinh, x),
            ExprNode::Acosh(x) => one(Func::Acosh, x),
            ExprNode::Atanh(x) => one(Func::Atanh, x),
            ExprNode::Sign(x) => one(Func::Sign, x),
            ExprNode::Heaviside(x) => one(Func::Heaviside, x),
            ExprNode::DiracDelta(x) => one(Func::DiracDelta, x),
            ExprNode::Re(x) => one(Func::Re, x),
            ExprNode::Im(x) => one(Func::Im, x),
            ExprNode::Conjugate(x) => one(Func::Conjugate, x),
            ExprNode::Arg(x) => one(Func::Arg, x),
            ExprNode::Gamma(x) => one(Func::Gamma, x),
            ExprNode::LogGamma(x) => one(Func::LogGamma, x),
            ExprNode::Digamma(x) => one(Func::Digamma, x),
            ExprNode::Erf(x) => one(Func::Erf, x),
            ExprNode::Erfc(x) => one(Func::Erfc, x),
            ExprNode::LambertW(x) => one(Func::LambertW0, x),
            ExprNode::Beta(a, b) => two(Func::Beta, a, b),
            ExprNode::Si(x) => one(Func::Si, x),
            ExprNode::Ci(x) => one(Func::Ci, x),
            ExprNode::Ei(x) => one(Func::Ei, x),
            ExprNode::Li(x) => one(Func::Li, x),
            ExprNode::Zeta(x) => one(Func::Zeta, x),
            ExprNode::Polygamma(n, x) => two(Func::Polygamma, n, x),
            ExprNode::KroneckerDelta(i, j) => two(Func::KroneckerDelta, i, j),
            ExprNode::Factorial(x) => one(Func::Factorial, x),
            ExprNode::Binomial(n, k) => two(Func::Binomial, n, k),
            ExprNode::Apply(head, args) => {
                let f = Func::of_head(arena, *head)?;
                f.spec()
                    .arity
                    .accepts(args.len())
                    .then(|| (f, args.iter().copied().collect()))
            }
            ExprNode::Num(_)
            | ExprNode::Symbol(_)
            | ExprNode::Pi
            | ExprNode::E
            | ExprNode::ImaginaryUnit
            | ExprNode::EulerGamma
            | ExprNode::Catalan
            | ExprNode::GoldenRatio
            | ExprNode::PhysicalConstant(..)
            | ExprNode::Infinity
            | ExprNode::NegInfinity
            | ExprNode::ComplexInfinity
            | ExprNode::NaN
            | ExprNode::Add(_)
            | ExprNode::Mul(_)
            | ExprNode::Pow(..)
            | ExprNode::Neg(_)
            | ExprNode::BoolTrue
            | ExprNode::BoolFalse
            | ExprNode::Gt(..)
            | ExprNode::Ge(..)
            | ExprNode::Eq_(..)
            | ExprNode::Ne(..)
            | ExprNode::And(_)
            | ExprNode::Or(_)
            | ExprNode::Not(_)
            | ExprNode::Piecewise(_)
            | ExprNode::Derivative(..)
            | ExprNode::Integral(..)
            | ExprNode::DefiniteIntegral(..)
            | ExprNode::Sum(..)
            | ExprNode::Product_(..)
            | ExprNode::Limit(..)
            | ExprNode::Series(..)
            | ExprNode::LaplaceTransform(..)
            | ExprNode::InverseLaplaceTransform(..)
            | ExprNode::Residue(..)
            | ExprNode::RootOf(..)
            | ExprNode::RootSum(..)
            | ExprNode::DSolve(..)
            | ExprNode::ConditionSet(..)
            | ExprNode::EmptySet
            | ExprNode::UniversalSet
            | ExprNode::Interval(..)
            | ExprNode::FiniteSet(_)
            | ExprNode::SetUnion(_)
            | ExprNode::SetIntersection(_)
            | ExprNode::SetComplement(..)
            | ExprNode::Subs(..)
            | ExprNode::ImageSet(..) => None,
        }
    }
}

impl Func {
    /// Is `name` the head of an internal function (`__ei_asym`, …)?  Such
    /// heads are reserved: user input must not build them.
    pub(crate) fn is_internal_name(name: &str) -> bool {
        Func::internal_named(name).is_some()
    }

    /// The library or internal function an `Apply` head names (by its
    /// interned text, as [`Arena::lib_fn`] resolves library names).
    fn of_head(arena: &Arena, head: SymbolId) -> Option<Func> {
        let name = arena.symbol_name(head);
        match LibFn::from_name(name) {
            Some(lib) => Some(Func::from(lib)),
            None => Func::internal_named(name),
        }
    }
}

/// The error for a call of `f` with `n` arguments.
fn arity_error(f: Func, n: usize) -> SymplexError {
    let spec = f.spec();
    SymplexError::invalid_argument(
        "Arena::func",
        format!("{} takes {}, got {n}", spec.name, spec.arity),
    )
}

/// The `N` arguments of a call of `f` with exactly `N`.
fn fixed<const N: usize>(f: Func, args: &[ExprId]) -> Result<[ExprId; N], SymplexError> {
    <[ExprId; N]>::try_from(args).map_err(|_| arity_error(f, args.len()))
}

impl Arena {
    /// Builds `f(args)` exactly as today's constructor for `f` does — the
    /// canonical folds included (`Si(0)` is `0`, `abs(−2·x)` is `2·abs(x)`,
    /// `KroneckerDelta` orders its arguments, `lambertw(x, 0)` is the
    /// principal-branch node).
    ///
    /// # Errors
    ///
    /// [`SymplexError::InvalidArgument`] when `f` does not take
    /// `args.len()` arguments.
    pub(crate) fn func(&mut self, f: Func, args: &[ExprId]) -> Result<ExprId, SymplexError> {
        if !f.spec().arity.accepts(args.len()) {
            return Err(arity_error(f, args.len()));
        }
        match f.family() {
            Family::Node => self.node_func(f, args),
            Family::Lib => {
                let Some(lib) = f.as_lib() else {
                    return Err(arity_error(f, args.len()));
                };
                Ok(match (lib, args) {
                    (LibFn::LambertW, [x]) => self.lambertw(*x),
                    (LibFn::LambertW, [x, k]) => self.lambertw_branch(*x, *k),
                    _ => self.lib_apply(lib, args),
                })
            }
            Family::Internal => {
                let head = self.symbols.intern(f.spec().name);
                Ok(self.intern(ExprNode::Apply(head, args.iter().copied().collect())))
            }
        }
    }

    /// [`Arena::func`] of a node-backed function, arity already checked.
    fn node_func(&mut self, f: Func, args: &[ExprId]) -> Result<ExprId, SymplexError> {
        let one = |args: &[ExprId]| fixed::<1>(f, args).map(|[x]| x);
        Ok(match f {
            Func::Min => self.intern(ExprNode::Min(args.iter().copied().collect())),
            Func::Max => self.intern(ExprNode::Max(args.iter().copied().collect())),
            Func::Floor => self.floor(one(args)?),
            Func::Ceiling => self.ceiling(one(args)?),
            Func::Sin => self.sin(one(args)?),
            Func::Cos => self.cos(one(args)?),
            Func::Tan => self.tan(one(args)?),
            Func::Exp => self.exp(one(args)?),
            Func::Ln => self.ln(one(args)?),
            Func::Abs => self.abs(one(args)?),
            Func::Asin => self.asin(one(args)?),
            Func::Acos => self.acos(one(args)?),
            Func::Atan => self.atan(one(args)?),
            Func::Atan2 => {
                let [y, x] = fixed(f, args)?;
                self.atan2(y, x)
            }
            Func::Sinh => self.sinh(one(args)?),
            Func::Cosh => self.cosh(one(args)?),
            Func::Tanh => self.tanh(one(args)?),
            Func::Asinh => self.asinh(one(args)?),
            Func::Acosh => self.acosh(one(args)?),
            Func::Atanh => self.atanh(one(args)?),
            Func::Sign => self.sign(one(args)?),
            Func::Heaviside => self.heaviside(one(args)?),
            Func::DiracDelta => self.dirac_delta(one(args)?),
            Func::Re => self.re(one(args)?),
            Func::Im => self.im(one(args)?),
            Func::Conjugate => self.conjugate(one(args)?),
            Func::Arg => self.arg(one(args)?),
            Func::Gamma => self.gamma(one(args)?),
            Func::LogGamma => self.log_gamma(one(args)?),
            Func::Digamma => self.digamma(one(args)?),
            Func::Erf => self.erf(one(args)?),
            Func::Erfc => self.erfc(one(args)?),
            Func::LambertW0 => self.lambertw(one(args)?),
            Func::Beta => {
                let [a, b] = fixed(f, args)?;
                self.beta(a, b)
            }
            Func::Si => self.si(one(args)?),
            Func::Ci => self.ci(one(args)?),
            Func::Ei => self.ei(one(args)?),
            Func::Li => self.li(one(args)?),
            Func::Zeta => self.zeta(one(args)?),
            Func::Polygamma => {
                let [n, x] = fixed(f, args)?;
                self.polygamma(n, x)
            }
            Func::KroneckerDelta => {
                let [i, j] = fixed(f, args)?;
                self.kronecker_delta(i, j)
            }
            Func::Factorial => self.factorial(one(args)?),
            Func::Binomial => {
                let [n, k] = fixed(f, args)?;
                self.binomial(n, k)
            }
            non_node_funcs!() => {
                return Err(SymplexError::computation_failed(
                    "Arena::func",
                    format!("{} is not a node-backed function", f.spec().name),
                ));
            }
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::api::context::Context;
    use crate::api::expr::Ex;
    use crate::base::assumptions::{Assumption, Props};

    /// Symbols for argument slots, in sort-key order.
    const SLOTS: [&str; 4] = ["t", "x", "y", "z"];

    /// A typical argument count for `f` (two for the variadic `Min`/`Max`,
    /// which fold a single argument to itself; two for `lambertw(x, k)`,
    /// whose one-argument call is the principal-branch node).
    fn sample_count(f: Func) -> usize {
        match f.spec().arity {
            ArgCount::Exactly(n) => usize::from(n),
            ArgCount::Between { max, .. } => usize::from(max),
            ArgCount::AtLeast(n) => usize::from(n).max(2),
        }
    }

    /// A context, its slot symbols, and `f` of the first `n` of them built
    /// by [`Arena::func`].
    fn built(f: Func, n: usize) -> (Context, Vec<Ex>, Ex) {
        let ctx = Context::new();
        let syms: Vec<Ex> = SLOTS[..n].iter().map(|s| ctx.symbol(s)).collect();
        let ids: Vec<ExprId> = syms.iter().map(Ex::raw_id).collect();
        let id = ctx
            .with_arena_mut(|a| a.func(f, &ids))
            .unwrap_or_else(|e| panic!("{f:?}: {e}"));
        let e = syms[0].wrap(id);
        (ctx, syms, e)
    }

    fn render_tex(tex: Tex, args: &[String], atom: bool) -> String {
        match tex {
            Tex::Call(head) => format!(r"{head}\left({}\right)", args.join(", ")),
            Tex::Layout(pieces) => pieces
                .iter()
                .map(|p| match *p {
                    TexPiece::Lit(s) => s.to_owned(),
                    TexPiece::Arg(i) => args[usize::from(i)].clone(),
                })
                .collect(),
            Tex::Postfix(op) if atom => format!("{}{op}", args[0]),
            Tex::Postfix(op) => format!(r"\left({}\right){op}", args[0]),
        }
    }

    #[test]
    fn the_list_has_every_function_once_in_discriminant_order() {
        let count = |fam: Family| Func::ALL.iter().filter(|f| f.family() == fam).count();
        assert_eq!(
            (
                count(Family::Node),
                count(Family::Lib),
                count(Family::Internal)
            ),
            (43, 50, 8)
        );
        assert_eq!(Func::ALL.len(), Func::SPECS.len());
        for (i, f) in Func::ALL.iter().enumerate() {
            assert_eq!(*f as usize, i, "{f:?}");
        }
        let mut names: Vec<&str> = Func::ALL.iter().map(|f| f.spec().name).collect();
        names.sort_unstable();
        names.dedup();
        assert_eq!(names.len(), Func::ALL.len(), "two entries with one name");
    }

    #[test]
    fn lib_fn_is_the_library_part_of_func() {
        let libs: Vec<Func> = Func::ALL
            .iter()
            .copied()
            .filter(|f| f.family() == Family::Lib)
            .collect();
        assert_eq!(libs.len(), LibFn::ALL.len());
        for (lib, f) in LibFn::ALL.iter().zip(&libs) {
            assert_eq!(Func::from(*lib), *f);
            assert_eq!(f.as_lib(), Some(*lib));
            assert_eq!(lib.name(), f.spec().name);
            assert_eq!(LibFn::from_name(lib.name()), Some(*lib));
            assert!(!matches!(f.spec().arity, ArgCount::AtLeast(_)), "{lib:?}");
            for n in 0..6 {
                assert_eq!(
                    lib.arity().accepts(n),
                    f.spec().arity.accepts(n),
                    "{lib:?} {n}"
                );
            }
        }
        for f in Func::ALL.iter().filter(|f| f.family() != Family::Lib) {
            assert_eq!(f.as_lib(), None);
            assert_eq!(LibFn::from_name(f.spec().name), None, "{f:?}");
        }
    }

    /// (a) The node `Arena::func` builds has exactly the sort key that the
    /// spec's sub-rank predicts, followed by its arguments' keys: the bytes
    /// of `sort_key.rs` by construction, for every function.
    #[test]
    fn sort_keys_follow_the_spec() {
        for &f in Func::ALL {
            let (ctx, syms, e) = built(f, sample_count(f));
            let mut expected: Vec<u8> = match f.spec().sort {
                SortSub::Function(b) => vec![100, b],
                SortSub::Rank(r) => vec![r],
                SortSub::Named => {
                    let mut k = vec![100, 17];
                    k.extend_from_slice(f.spec().name.as_bytes());
                    k.push(0);
                    k
                }
            };
            ctx.with_arena_mut(|a| {
                for s in &syms {
                    expected.extend_from_slice(a.sort_key(s.raw_id()).as_bytes());
                }
                assert_eq!(a.sort_key(e.raw_id()).as_bytes(), &expected[..], "{f:?}");
            });
        }
    }

    /// The function sub-rank bytes are distinct, except the one historical
    /// duplicate.
    #[test]
    fn sort_bytes_are_unique_but_for_binomial_and_asin() {
        let mut seen: Vec<(u8, Func)> = Vec::new();
        for &f in Func::ALL {
            if let SortSub::Function(b) = f.spec().sort {
                for &(c, g) in &seen {
                    if c == b {
                        assert_eq!((g, f), (Func::Asin, Func::Binomial), "byte {b}");
                    }
                }
                seen.push((b, f));
            }
        }
        assert_ne!(seen.len(), 0);
    }

    /// (b) `Display` prints `name(args)`, but for the two documented
    /// exceptions.
    #[test]
    fn display_uses_the_spec_name() {
        for &f in Func::ALL {
            let n = sample_count(f);
            let (_ctx, _syms, e) = built(f, n);
            let expected = match f {
                Func::Factorial => "t!".to_owned(),
                Func::LambertW => "W(t, x)".to_owned(),
                _ => format!("{}({})", f.spec().name, SLOTS[..n].join(", ")),
            };
            assert_eq!(e.to_string(), expected, "{f:?}");
        }
    }

    /// (c) Parsing the display builds the same node; so do the name in
    /// lower case and every further parse name.  Internal functions are not
    /// parseable (in a context that has no such node: the parser reads a
    /// call of a head some `Apply` already has as that function).
    #[test]
    fn parse_of_display_and_of_every_name_builds_the_same_node() {
        for &f in Func::ALL {
            let n = sample_count(f);
            let (ctx, _syms, e) = built(f, n);
            if f.family() == Family::Internal {
                assert!(Context::new().parse(&e.to_string()).is_err(), "{f:?}");
                continue;
            }
            let back = ctx
                .parse(&e.to_string())
                .unwrap_or_else(|err| panic!("{f:?}: {err}"));
            assert_eq!(back.raw_id(), e.raw_id(), "{f:?}: {e}");
            let spec = f.spec();
            let mut names: Vec<String> = spec.parse.iter().map(|s| (*s).to_owned()).collect();
            names.push(spec.name.to_owned());
            if spec.name != "H" {
                names.push(spec.name.to_ascii_lowercase());
            }
            for name in names {
                let src = format!("{name}({})", SLOTS[..n].join(", "));
                let back = ctx.parse(&src).unwrap_or_else(|err| panic!("{src}: {err}"));
                assert_eq!(back.raw_id(), e.raw_id(), "{src}");
            }
        }
    }

    /// (d) The LaTeX of every function is its spec's layout.
    #[test]
    fn latex_is_the_spec_layout() {
        for &f in Func::ALL {
            let n = sample_count(f);
            let (_ctx, syms, e) = built(f, n);
            let args: Vec<String> = syms.iter().map(Ex::to_latex).collect();
            assert_eq!(e.to_latex(), render_tex(f.spec().tex, &args, true), "{f:?}");
        }
        // The postfix layout of a compound argument.
        let ctx = Context::new();
        let x = ctx.symbol("x");
        let x1 = &x + 1;
        let id = ctx.with_arena_mut(|a| a.func(Func::Factorial, &[x1.raw_id()]));
        let fact = x.wrap(id.unwrap_or_else(|e| panic!("{e}")));
        assert_eq!(
            fact.to_latex(),
            render_tex(Func::Factorial.spec().tex, &[x1.to_latex()], false)
        );
    }

    /// (e) Arena::func accepts exactly the spec's argument counts.
    #[test]
    fn arity_errors_for_wrong_argument_counts() {
        for &f in Func::ALL {
            let ctx = Context::new();
            let syms: Vec<ExprId> = ["t", "x", "y", "z", "u", "v"]
                .iter()
                .map(|s| ctx.symbol(s).raw_id())
                .collect();
            for n in 0..=syms.len() {
                let r = ctx.with_arena_mut(|a| a.func(f, &syms[..n]));
                match r {
                    Ok(_) => assert!(f.spec().arity.accepts(n), "{f:?} accepted {n}"),
                    Err(SymplexError::InvalidArgument { reason, .. }) => {
                        assert!(!f.spec().arity.accepts(n), "{f:?} refused {n}: {reason}");
                        assert!(reason.starts_with(f.spec().name), "{reason}");
                    }
                    Err(e) => panic!("{f:?} {n}: {e}"),
                }
            }
        }
    }

    /// The view names the function `Arena::func` built, with its arguments.
    #[test]
    fn view_inverts_the_constructor() {
        for &f in Func::ALL {
            let n = sample_count(f);
            let (ctx, syms, e) = built(f, n);
            let ids: SmallVec<[ExprId; 4]> = syms.iter().map(Ex::raw_id).collect();
            ctx.with_arena_mut(|a| {
                let node = a.node(e.raw_id()).clone();
                assert_eq!(node.func(a), Some((f, ids.clone())), "{f:?}");
            });
        }
    }

    /// `f(args)` built by [`Arena::func`], or `None` when the constructor
    /// folded it to another node (`acosh(cosh x)`, `li(1)`).
    fn build_f(ctx: &Context, f: Func, args: &[Ex]) -> Option<Ex> {
        let ids: Vec<ExprId> = args.iter().map(Ex::raw_id).collect();
        let id = ctx
            .with_arena_mut(|a| a.func(f, &ids))
            .unwrap_or_else(|e| panic!("{f:?}: {e}"));
        let e = ctx.zero().wrap(id);
        let same = ctx.with_arena_mut(|a| {
            let node = a.node(id).clone();
            node.func(a).is_some_and(|(g, _)| g == f)
        });
        same.then_some(e)
    }

    fn declared(ctx: &Context, name: &str, facts: &[Assumption]) -> Ex {
        ctx.symbol_with(name, facts)
            .unwrap_or_else(|e| panic!("{name}: {e}"))
    }

    /// The parity facet is today's sign extraction — at construction
    /// (`canon.rs`) or by `eval` (`eval.rs`) — for every function of one
    /// argument.
    #[test]
    fn parity_is_todays_sign_extraction() {
        for &f in Func::ALL {
            if f.spec().arity != ArgCount::Exactly(1) {
                assert_eq!(f.spec().parity, Parity::Neither, "{f:?}");
                continue;
            }
            let ctx = Context::new();
            let z = ctx.symbol("z");
            let two = ctx.int(2);
            let two_z = &two * &z;
            let one = |arg: &Ex| {
                let id = ctx
                    .with_arena_mut(|a| a.func(f, &[arg.raw_id()]))
                    .unwrap_or_else(|e| panic!("{f:?}: {e}"));
                z.wrap(id)
            };
            let (f_z, f_neg_z) = (one(&z), one(&-&z));
            let (f_2z, f_neg_2z) = (one(&two_z), one(&-&two_z));
            let (f_2, f_neg_2) = (one(&two), one(&-&two));
            let (odd, sign) = match f.spec().parity {
                Parity::Odd(s) => (true, s),
                Parity::Even(s) => (false, s),
                Parity::Neither => {
                    assert_eq!(f_neg_z.eval(), f_neg_z, "{f:?}");
                    continue;
                }
            };
            let signed = |e: &Ex| if odd { -e } else { e.clone() };
            match sign {
                AutoSign::Canonical => assert_eq!(f_neg_z, signed(&f_z), "{f:?}"),
                AutoSign::Coefficient => {
                    assert_ne!(f_neg_z, signed(&f_z), "{f:?} at construction");
                    assert_eq!(f_neg_2z.eval(), signed(&f_2z), "{f:?}");
                }
                AutoSign::Negation => {
                    assert_eq!(f_neg_z.eval(), signed(&f_z), "{f:?}");
                    assert_eq!(f_neg_2z.eval(), f_neg_2z, "{f:?}");
                    assert_eq!(f_neg_2.eval(), signed(&f_2), "{f:?}");
                }
                AutoSign::SymbolFree => {
                    assert_eq!(f_neg_z.eval(), f_neg_z, "{f:?}");
                    assert_eq!(f_neg_2.eval(), signed(&f_2.eval()), "{f:?}");
                }
                AutoSign::Never => assert_eq!(f_neg_z.eval(), f_neg_z, "{f:?}"),
            }
        }
    }

    /// Every function is real on its `real_on` domain — by the table's
    /// handler or by its own — and no function of complex arguments but the
    /// real-valued ones is claimed real.
    #[test]
    fn real_on_is_what_the_assumption_system_claims() {
        use Assumption::{Integer, Negative, NonNegative, Positive, Real};
        for &f in Func::ALL {
            let real_on = f.spec().real_on;
            if real_on == RealOn::Custom {
                continue;
            }
            let n = sample_count(f);
            let ctx = Context::new();
            let mut args: Vec<Ex> = (0..n)
                .map(|i| declared(&ctx, &format!("r{i}"), &[Real]))
                .collect();
            let last = n - 1;
            let x = declared(&ctx, "x", &[Real]);
            match real_on {
                RealOn::PositiveReals => args[last] = declared(&ctx, "p", &[Positive]),
                RealOn::NonNegativeReals => args[last] = declared(&ctx, "u", &[Real, NonNegative]),
                RealOn::BelowOne => args[last] = declared(&ctx, "q", &[Negative]),
                RealOn::UnitInterval { closed: true } => args[last] = x.sin(),
                RealOn::UnitInterval { closed: false } => args[last] = x.tanh(),
                RealOn::AtLeastOne => args[last] = x.cosh(),
                RealOn::Polynomial { degree } => {
                    args[usize::from(degree)] = declared(&ctx, "k", &[Integer, NonNegative]);
                }
                RealOn::BesselOrder => args[0] = declared(&ctx, "m", &[Integer]),
                RealOn::NonNegativeIntegers => {
                    for (i, a) in args.iter_mut().enumerate() {
                        *a = declared(&ctx, &format!("k{i}"), &[Integer, NonNegative]);
                    }
                }
                _ => {}
            }
            if let Some(e) = build_f(&ctx, f, &args) {
                let real = ctx.query(&e, Props::REAL);
                if real_on == RealOn::Unclaimed {
                    assert_ne!(real, Some(true), "{f:?}: {e}");
                } else {
                    assert_eq!(real, Some(true), "{f:?}: {e}");
                }
                if real_on == RealOn::IntegerValued {
                    assert_eq!(ctx.query(&e, Props::INTEGER), Some(true), "{f:?}: {e}");
                }
            }
            let plain: Vec<Ex> = (0..n).map(|i| ctx.symbol(&format!("c{i}"))).collect();
            if real_on != RealOn::Everywhere
                && let Some(e) = build_f(&ctx, f, &plain)
            {
                assert_ne!(ctx.query(&e, Props::REAL), Some(true), "{f:?}: {e}");
            }
        }
    }

    /// A function whose special values at constants are not all folded
    /// ([`Constants::Evaluated`]) gets no claim at constant arguments —
    /// `B(1/2, −1/2)`, `subfactorial(1)`, `chebyshev_t(3, 0)` are unfolded
    /// zeros — while a folded one keeps its claims there, and both claim for
    /// symbols.
    #[test]
    fn constants_facet_decides_claims_at_constant_arguments() {
        use crate::base::assumptions::AssumptionCache;
        let ctx = Context::new();
        ctx.symbol_with("x", &[Assumption::Real])
            .unwrap_or_else(|e| panic!("{e}"));
        for (src, want) in [
            ("beta(1/2, -1/2)", None),
            ("subfactorial(1)", None),
            ("chebyshev_t(3, 0)", None),
            ("erfi(2)", None),
            ("beta(x, -1/2)", Some(true)),
            ("erfi(x)", Some(true)),
            ("Gamma(1/3)", Some(true)),
            ("lambertw(2)", Some(true)),
            ("factorial(5/2)", Some(true)),
        ] {
            let e = ctx.parse(src).unwrap_or_else(|err| panic!("{src}: {err}"));
            let got =
                ctx.with_arena_mut(|a| AssumptionCache::new().query(a, e.raw_id(), Props::REAL));
            assert_eq!(got, want, "{src}: {e}");
        }
    }

    /// An argument known to be at a pole withholds the claims "real" and
    /// "finite complex".
    #[test]
    fn no_claim_at_a_known_pole() {
        use Assumption::{Integer, NonPositive, Real, Zero};
        for &f in Func::ALL {
            let n = sample_count(f);
            let ctx = Context::new();
            let mut args: Vec<Ex> = (0..n)
                .map(|i| declared(&ctx, &format!("r{i}"), &[Real]))
                .collect();
            match f.spec().poles {
                Poles::NonPositiveIntegers(which) => {
                    for &i in which {
                        args[usize::from(i)] = declared(&ctx, "np", &[Integer, NonPositive]);
                    }
                }
                Poles::Zero(i) => args[usize::from(i)] = declared(&ctx, "o", &[Zero]),
                Poles::One(i) => args[usize::from(i)] = ctx.int(1),
                Poles::None | Poles::Other => continue,
            }
            if let Some(e) = build_f(&ctx, f, &args) {
                assert_ne!(ctx.query(&e, Props::REAL), Some(true), "{f:?}: {e}");
                assert_ne!(ctx.query(&e, Props::COMPLEX), Some(true), "{f:?}: {e}");
            }
        }
    }

    /// `conjugate` pushes the conjugate into `f(args)` exactly where the
    /// table's rule holds by the assumptions: always for `Entire`, for an
    /// imaginary (finite, non-real) cut argument for `OffCut`, for an
    /// integer order or degree; never for `No`.
    #[test]
    fn conjugate_follows_the_reflection_facet() {
        use Assumption::{Imaginary, Integer, NonNegative, Real};
        for &f in Func::ALL {
            let n = sample_count(f);
            let ctx = Context::new();
            let plain: Vec<Ex> = (0..n).map(|i| ctx.symbol(&format!("c{i}"))).collect();
            let with = |i: u8, e: Ex| {
                let mut args = plain.clone();
                args[usize::from(i)] = e;
                args
            };
            let off_cut = |cut: Cut| {
                if cut.line == CutLine::ImaginaryOutsideUnit {
                    declared(&ctx, "r", &[Real])
                } else {
                    declared(&ctx, "w", &[Imaginary])
                }
            };
            let integer = |nonnegative: bool| {
                if nonnegative {
                    declared(&ctx, "k", &[Integer, NonNegative])
                } else {
                    declared(&ctx, "m", &[Integer])
                }
            };
            // (arguments, whether the rule holds for them by the assumptions)
            let cases: Vec<(Vec<Ex>, bool)> = match f.spec().conj {
                Conj::Entire => vec![(plain.clone(), true)],
                Conj::OffCut(cut) => {
                    vec![(plain.clone(), false), (with(cut.arg, off_cut(cut)), true)]
                }
                Conj::IntegerOrderOffCut { cut, nonnegative } => vec![
                    (plain.clone(), false),
                    (with(cut.arg, off_cut(cut)), true),
                    (with(0, integer(nonnegative)), true),
                ],
                Conj::Polynomial { degree } => {
                    vec![(plain.clone(), false), (with(degree, integer(true)), true)]
                }
                Conj::No => vec![(plain.clone(), false)],
            };
            for (args, holds) in cases {
                let Some(e) = build_f(&ctx, f, &args) else {
                    continue;
                };
                if ctx.query(&e, Props::REAL) == Some(true) {
                    continue;
                }
                let ids: Vec<ExprId> = if holds {
                    args.iter().map(|a| a.conjugate().raw_id()).collect()
                } else {
                    Vec::new()
                };
                let want = ctx.with_arena_mut(|a| {
                    if holds {
                        a.func(f, &ids).unwrap_or_else(|err| panic!("{f:?}: {err}"))
                    } else {
                        a.intern(ExprNode::Conjugate(e.raw_id()))
                    }
                });
                assert_eq!(e.conjugate(), e.wrap(want), "{f:?}: conjugate({e})");
            }
        }
    }

    /// User functions, wrong-arity library calls and non-functions have no
    /// `Func`.
    #[test]
    fn view_of_non_functions_is_none() {
        let ctx = Context::new();
        let x = ctx.symbol("x");
        let three = ctx.int(3);
        let user = ctx.apply("f", std::slice::from_ref(&x)).unwrap();
        let shi2 = ctx.apply("Shi", &[x.clone(), three]).unwrap();
        let sum = &x + 1;
        ctx.with_arena_mut(|a| {
            for e in [&user, &shi2, &sum, &x] {
                let node = a.node(e.raw_id()).clone();
                assert_eq!(node.func(a), None, "{node:?}");
            }
        });
    }
}