Laguerre polynomials have many neat definitions; I am partial to because it’s so easy to remember:

- Begin with
- Repeat “subtract the derivative” times
- Normalize so the constant term is 1.

For example, for n=3 this process goes as to to to , which normalizes to . This would make a mean exercise on differentiating polynomials: every mistake snowballs throughout the computation.

What would happen if we **added** the derivative instead? Nothing really new: this change is equivalent to reversing the direction of the x-axis, so we’d end up with . Incidentally, this shows that the polynomial has positive coefficients, which means the behavior of for negative is boring: the values go up as becomes more negative. Laguerre polynomials are all about the interval on which they are orthogonal with respect to the weight and therefore change sign often.

But when I look at the plot shown above, it’s not the zeros that draw my attention (perhaps because the x-axis is not shown) but the horizontal line , the zero-degree polynomial. The coefficients of have alternating signs; in particular, and . So, nonconstant Laguerre polynomials start off with the value of 1 and immediately dive below it. All except the linear one, , eventually recover and reach 1 again (or so it seems; I don’t have a proof).

The yellow curve that is the first to cross the blue line is the 5th degree Laguerre polynomial. Let’s see if any of the other polynomials rises about 1 sooner…

Still, nobody beats (and the second place is held by ). By the way, the visible expansion of oscillations is approximately exponential; multiplying the polynomials by turns the envelopes into horizontal lines:

Back to the crossing of y=1 line. The quantity to study is the **smallest positive root** of , denoted from now on. (It is the second smallest root overall; as discussed above, this polynomial has a root at x=0 and no negative roots.) For n=2,3,4,5,6, the value of is which evaluates to 4, 3, 2.536…, 2.377…, and 6 respectively. I got these with Python / SymPy:

from sympy import * x = Symbol('x') [Poly(laguerre(n, x) - 1).all_roots()[1] for n in range(2, 7)]

For higher degrees we need numerics. SymPy can still help (applying `.evalf()`

to the roots), but the process gets slow. Switching to NumPy’s `roots`

method speeds things up, but when it indicated than and a few others are in double digits, I became suspicious… a closer check showed this was a numerical artifact.

**Conjecture:** for all . Moreover, when .

Here is a closer look at the exceptional polynomials of degrees 3, 4, 5 and 6, with 1 subtracted from each:

The first local maximum of shifts down and to the left as the degree n increases. The degree n=5 is the last for which exceeds 1 on the first attempt, so it becomes the quickest to do so. On the other hand, n=6 fails on its first attempt to clear the bar, and its second attempt is later than for any subsequent Laguerre polynomial; so it sets the record for maximal .

Evaluating high-degree Laguerre polynomials is a numerical challenge: adding large terms of alternating signs can reduce accuracy dramatically. Here is a plot of the degree 98 polynomial (minus 1): where is its first positive root?

Fortunately, SymPy can evaluate Laguerre polynomials at rational points using **exact arithmetics** since the coefficients are rational. For example, when it evaluates the expression `laguerre(98, 5) > 1`

to True, that’s a (computer-assisted) proof that , which one could in principle "confirm" by computing the same rational value of by hand (of course, in this situation a human is far less trustworthy than a computer) . Evaluation at the 13 rational points 3, 3.25, 3.5, … , 5.75, 6 is enough to certify that for up to 200 (with the aforementioned exception of ).

The lower bounds call for Sturm’s theorem which is more computationally expensive than sampling at a few rational points. SymPy offers a root-counting routine based on this theorem (it counts the roots within the given closed interval):

for n in range(2, 101): num_roots = count_roots((laguerre(n,x)-1)/x, 0, 3) print('{} roots for n = {}'.format(num_roots, n))

Division by x eliminates the root at 0, so we are left with the root count on (0,3] — which is 1 for n=3,4 and 2 for n=5. The count is zero for all other degrees up to 100, confirming that for .

So, the conjecture looks solid. I don’t have a clue to its proof (nor do I know if it’s something known). The only upper bound on that I know is Szegő’s for , which is not helping here.