Polynomial (L = 37)

The polynomial

f(n) = n⁴ − 41n³ + 550n² − 2622n + 4099

This monic quartic integer polynomial produces a run of 37 consecutive prime values when evaluated at consecutive integers starting at n = 0. As usual in this context, primality is tested on the absolute value |f(n)|.

Run length: L = 37

Category: monic quartic prime-generating polynomial

The polynomial

f(n) = n⁴ − 41n³ + 550n² − 2622n + 4099

is a monic quartic polynomial, since the leading coefficient (the coefficient of n⁴) is equal to 1. This places it within the class of monic quartic prime-generating polynomials, a mathematically significant and more restrictive family than generic quartic polynomials.

In this stricter category, achieving a long consecutive prime run is notably difficult. The polynomial above attains a run length of:

L = 37

establishing an exceptionally long documented prime-generating run for a monic quartic polynomial.

From L = 33 to L = 37 via translation

The starting polynomial (L = 33)

The genealogy starts from the quartic

g(n) = n⁴ − 25n³ + 154n² + 66n + 43

which generates L = 33 consecutive primes starting at n = 0. Explicitly, |g(n)| is prime for n = 0, 1, …, 32, and the first composite value occurs at n = 33:

g(33) = 457423 = 103 × 4441.

The n → n − 1 translation method

Given a polynomial P(n) with a long prime run, one can construct a translated polynomial

Q(n) = P(n − 1).

If the newly introduced value P(−1) is also prime, then the prime run of Q(n) starting at n = 0 is extended by one:

• P(n) is prime for n = 0, …, L − 1,
• P(L) is composite,
• P(−1) is prime,

which implies that Q(n) = P(n − 1) is prime for n = 0, …, L, with the first composite at n = L + 1. Iterating this translation constructs a genealogical tree of quartic polynomials, each step corresponding to a shift by n → n − 1.

Structural nature of the record

Applying this method repeatedly to the starting polynomial with L = 33 yields the structural record

f(n) = n⁴ − 41n³ + 550n² − 2622n + 4099

with run length L = 37. The process cannot be extended further within this genealogy, as the next value on the negative side is composite (g(−5) = 7313 = 71 × 103), preventing another successful translation step that would increase L.

The genealogical tree (L = 37 → L = 1)

Starting from the structural record with L = 37, we obtain a full genealogical family of monic quartic polynomials by iterated translations. Each polynomial fL(n) has the form

fL(n) = n⁴ + a n³ + b n² + c n + d

and generates exactly L consecutive primes for n = 0, …, L − 1. For every entry in this family, the first composite appears at n = L and takes the same value:

f_L(L) = 457423 = 103 × 4441.

The complete genealogical table is:

Computational verification (sketch)

The structural record and all polynomials in the genealogical tree were verified by exhaustive evaluation and deterministic primality checks on 64-bit integers.

For the record polynomial

f(n) = n⁴ − 41n³ + 550n² − 2622n + 4099

we have:

• |f(n)| is prime for n = 0, 1, …, 36,
• the first composite appears at n = 37,
• f(37) = 457423 = 103 × 4441.

Minimal Python snippet

The following code reproduces the run length L = 37 for the structural record:

"""
Deterministic primality test for the structural monic quartic record:

    f(n) = n^4 - 41 n^3 + 550 n^2 - 2622 n + 4099
"""

A = -41
B = 550
C = -2622
D = 4099

def is_prime(n: int) -> bool:
    if n < 2:
        return False
    if n % 2 == 0:
        return n == 2
    d = 3
    while d * d <= n:
        if n % d == 0:
            return False
        d += 2
    return True

def f(n: int) -> int:
    return n**4 + A*n**3 + B*n**2 + C*n + D

def main():
    primes = []
    n = 0
    while True:
        v = f(n)
        if v < 2 or not is_prime(abs(v)):
            break
        primes.append((n, v))
        n += 1

    L = len(primes)
    print("Structural quartic record:")
    print(f"  (a, b, c, d) = ({A}, {B}, {C}, {D})")
    print("\\nLength of the consecutive prime run (L):", L)
    print(f"First composite at n = {L}: f(n) = {f(L)}")

if __name__ == "__main__":
    main()