A Simple Algorithm for Trimmed Multipoint Evaluation

Evaluating a polynomial on a set of points is a fundamental task in computer algebra. In this work, we revisit a particular variant called trimmed multipoint evaluation: given an $n$-variate polynomial with bounded individual degree $d$ and total degree $D$, the goal is to evaluate it on a natural class of input points. This problem arises as a key subroutine in recent algorithmic results [Dinur; SODA ‘21], [Dell, Haak, Kallmayer, Wennmann; SODA ‘25]. It is known that trimmed multipoint evaluation can be solved in near-linear time [van der Hoeven, Schost; AAECC ‘13] by a clever yet somewhat involved algorithm. We give a simple recursive algorithm that avoids heavy computer-algebraic machinery, and can be readily understood by researchers without specialized background.

💡 Research Summary

The paper addresses the problem of evaluating an n‑variate polynomial P over a field F when each variable has individual degree at most d and the total degree is bounded by D. The evaluation points form a “trimmed grid”: all tuples (ℓ₁,…,ℓₙ) with 0 ≤ ℓᵢ ≤ d and ℓ₁+⋯+ℓₙ ≤ D. The size of this set is the extended binomial coefficient ⎡n ≤ D⎤₍d₎, which coincides with the number of potentially non‑zero monomials of P. Consequently, evaluating P on the trimmed grid uniquely determines P, and the same algorithm can be used for interpolation.

Previously, van der Hoeven and Schost gave a near‑linear‑time algorithm for this task, but it relies on sophisticated algebraic machinery: Newton bases, truncated Fourier transforms, and intricate basis‑change operations. While optimal in asymptotic complexity, the method is difficult for researchers outside computer algebra.

The authors propose a dramatically simpler recursive algorithm that uses only elementary linear‑algebraic tools—specifically, Gaussian elimination to compute an LU decomposition of a Vandermonde matrix. The algorithm consists of eight logical steps:

1. Base case – if n = 0, return the constant polynomial.
2. Decompose in the last variable – write P as Σ_{i=0}^{d} P_i(X₁,…,X_{n‑1})·X_n^{i}, where each P_i has total degree ≤ D‑i.
3. Form the (d+1)×(d+1) Vandermonde matrix V = V(z_{n,0},…,z_{n,d}) built from the evaluation points of the last variable.
4. Compute LU decomposition V = L·U, where L is lower‑triangular and U is upper‑triangular.
5. Transform coefficient polynomials by multiplying the vector p = (P₀,…,P_d)ᵀ with U, obtaining Q = (Q₀,…,Q_d)ᵀ. Because U is upper‑triangular, each Q_j is a linear combination of P_i with i ≥ j, guaranteeing that deg(Q_j) ≤ D‑j.
6. Recursive evaluation – for each j = 0,…,d, recursively evaluate Q_j on the trimmed grid of dimension n‑1 with total degree bound D‑j.
7. Reconstruct original evaluations – for each (ℓ₁,…,ℓ_{n‑1}) in the appropriate trimmed set, compute the vector of values (P(ℓ,0),…,P(ℓ,k))ᵀ = L_{0..k,0..k}·(Q₀(ℓ),…,Q_k(ℓ))ᵀ, where k = min{d, D‑∑_{t=1}^{n‑1}ℓ_t}. This step uses the lower‑triangular matrix L to combine the recursively obtained Q‑values.
8. Return the full list of evaluations.

The recursion reduces the dimension by one at each level, but the number of recursive calls at depth i is d+1 with decreasing total‑degree bounds D, D‑1, …, D‑d. Using the extended Pascal identity ⎡n ≤ D⎤₍d₎ = Σ_{j=0}^{d} ⎡n‑1 ≤ D‑j⎤₍d₎, the total number of leaf evaluations equals exactly the size of the trimmed grid. Consequently, the overall running time is O⁎(⎡n ≤ D⎤₍d₎), i.e., linear (up to polylogarithmic factors) in the number of required evaluations. The extra cost of computing the LU decomposition is O(d³), negligible compared with the dominant term when the grid size is large.

The same framework yields a trimmed interpolation algorithm: by inverting the process (using U⁻¹·L⁻¹) one can recover the coefficient vector of P from its values on the trimmed grid, again in O⁎(⎡n ≤ D⎤₍d₎) time.

The paper contrasts this approach with the van der Hoeven‑Schost method. While the latter handles more general downward‑closed sets of monomials and achieves finer low‑order factor optimizations (e.g., O(n N log²N log log N) field operations with N = ⎡n ≤ D⎤₍d₎), it requires non‑trivial algebraic primitives. The presented LU‑based algorithm sacrifices these generalities and constant‑factor improvements for clarity, pedagogical value, and ease of implementation—qualities that are especially valuable for exponential‑time algorithm designers who need a reliable subroutine without delving into deep algebraic theory.

The authors also discuss applications. Trimmed multipoint evaluation appears as a core subroutine in recent exponential‑time algorithms for solving systems of polynomial equations, in parameterized algorithms for graph problems (e.g., computing chromatic numbers of bounded‑degree graphs via Zeta/Möbius transforms), and in cryptographic contexts where solving multivariate quadratic systems is a hardness assumption. In all these settings, a simple, implementable evaluation routine can significantly lower the barrier to practical experimentation and may lead to more widespread adoption of the underlying algorithmic ideas.

In summary, the paper delivers a conceptually straightforward, recursion‑based algorithm for trimmed multipoint evaluation and interpolation that runs in near‑optimal time, requires only elementary linear algebra, and is tailored for algorithmic researchers who prefer simplicity over maximal asymptotic refinement.