104 distinct primes, consisting of the output of

eight equations that alternate sequentially within

a procedural expression of a single polynomial.

The equations are either subsequences of

x^2 - 79x + 1601 or transforms

with one exception: 100x^2 -2260x + 12959

The other four distinct equations are

Euhler-derived.:

25x^2 -1185x + 14083,

25x^2 -775x + 6047,

100x^2 -2280x + 13159,

100x^2 -4160x +43427

14083, 14087, 6047, 13159, 12923, 43427,

5297, 12959, 11813, 11827, 4597,

10979, 10753, 39367, 3947, 10799,

9743, 9767, 3347, 8999 ,8783,

35507, 2797, 8839, 7873, 7907,

2297, 7219, 7013, 31847, 1847,

7079, 6203, 6247, 1447, 5639

5443, 28387, 1097, 5519, 4733

4787, 797, 4259 4073, 25127,

547, 4159, 3463, 3527, 347,

3079, 2903, 22067, 197, 2999,

2393, 2467, 97, 2099, 1933,

19207, 47, 2039, 1523, 1607,

47, 1319, 1163, 16547, 97,

1279, 853, 947, 197, 739,

593, 14087, 347, 719, 383,

487, 547, 359, 223, 11827,

797, 359, 113, 227, 1097,

179, 53, 9767, 1447, 199,

43, 167, 1847, 199, 83,

7907, 2297, 239, 173, 307,

2797, 419, 313, 6247, 3347,

479, 503, 647, 3947, 839,

743, 4787, 4597, 919, 1033,

1187, 5297, 1459, 1373, 3527,

6047, 1559

Perhaps its obvious, but I think that I should mention that the

basis for this prime chain in my little procedure at bottom is

the difference equation stack concept. This allows one to

generate all of the values of a polynomial without knowing the

equation providing the first few outputs are known. A simple example

can be illustrated. For instance, if one has the outputs 41, 43, 47

then a difference equation pyramid can be developed that will

generate the same sequence as x^2 - x + 41:

2

2 4

41 43 47

Using my procedure, I would begin with the stack on the

left-hand side of the pyramid and start a "repeat loop".

2 2 2 2

2 + 2 = 4 + 2 = 6 + 2 = 8

41 + 2 = 43 + 4 = 47 + 6 = 53 etc.

A more complex difference equation pyramid is necessary to

generate the rest of the sequence for 11, 61, 281, 911,2311...

(5x^4 - 10x^3 + 20x^2 -15x + 11). The procedure is easily

adjustable to do this for any degree polynomial.

120

240 360

170 410 770

50 220 630 1400

11 61 281 911 2311

Sarting with the left-hand stack as before, the calculations proceed:

120 120 120 120

240 + 120 = 360 + 120 = 480 + 120 = 600

170 + 240 = 410 + 360 = 770 + 480 = 1250

50 + 170 = 220 + 410 = 630 + 770 = 1400

11 + 50 = 61 + 220 = 281 + 630 = 911 etc.

I believe that concept of the difference equation stack probably

predates polynomial nomenclature, though my number theory books

fail to mention the idea at all. The melding of several polynomials

at once with a difference equation stack is not mentioned either,

but it may be easily observed that success in that endeavor will

surely depend heavily on the initial pieces of equations and

transforms chosen, and their ordering, and that certainly,without

modification, the difference equation pyramid will always go to

infinity in that situation and be useless.

I have found that the use of the sign change of the absolute value

function on selected rows can often be salutory in that regard,

and resolve the pyramid to a constant at its apex.

At each row from bottom to top one must experiment with changing

all negative terms to positive with an eye to causing the next row

to be smaller in size, less erratic in pattern, and for the last

digit of all terms to be identical. There may be several ways to get

the pyramid to resolve to a constant,or none at all, and it is

quite possible that there are smaller initial left-hand stacks for

our present polynomial (abs denotes rows to be modified by the

absolute value function)

than this one:

abs 160

0

abs 1820

0

abs 1760

abs 0

abs 59160

abs 0

-1090

abs 125806

62518

abs 29414

16284

-696

abs 23196

-804

4

14083

The Pascal procedure below should run as an import in several

programming

environments as is.

procedure Ndegrees5;

var a : array[0..32] of extended;

ct: longint;

n,nh ,i,j : integer;

ab1,ab2 : extended;

begin

for i := 0 to 32 do

a[i] := 0;

N := 17;

a[0] := 14083{ FIRST TERM OF PRIME CHAIN};

writeln('1');

writeln(trunc(a[0]));

writeln;

nh := 1;

a[1] := 14087 ;a[2] := 6047;

a[3] := 13159 ; a[4] :=12923 ; a[5] := 43427; a[6] := 5297 ;

a[7] := 12959 ; a[8] :=11813 ; a[9] :=11827 ;a[10] := 4597 ;

a[11] :=10979 ; a[12] := 10753 ; a[13] := 39367 ;a[14] := 3947;

a[15] :=10799 ;a[16] := 9743 ;a[17] := 9767 ;

repeat

for i := N downto nh do

begin

a[i] := a[i] - a[i-1] ;

IF NH = 3 THEN A[I] := abs(A[I]); {}

iF NH = 6 THEN A[I] := abs(A[I]); {}

iF NH = 8 THEN A[I] := abs(A[I]); {}

iF NH = 10 THEN A[I] := abs(A[I]); {}

iF NH = 11 THEN A[I] := abs(A[I]); {}

iF NH = 12 THEN A[I] := abs(A[I]); {}

iF NH = 13 THEN A[I] := abs(A[I]); {}

iF NH = 15 THEN A[I] := abs(A[I]); {}

iF NH = 17 THEN A[I] := abs(A[I]); {}

end;

nh := nh + 1;

until nh = n + 2;

ct := 0;

repeat

ct := ct + 1;

ab1 := a[n] + a[n-1];

for i := N-1 downto 1 do

begin

if i = 15 then if ct mod 2 = 0 then a[15] := -a[15];{}

if i = 14 then if ct mod 4 = 0 then a[14] := -a[14];{}

if i = 13 then if ct mod 2 = 0 then a[13] := -a[13];{}

if i = 12 then if ct mod 4 = 0 then a[12] := -a[12];{}

if i = 11 then if ct mod 2 = 0 then a[11] := -a[11];{}

if i = 10 then if ct mod 8 = 2 then a[10] := -a[10];{}

if i = 10 then if ct mod 8 = 0 then a[10] := -a[10];{}

if i = 8 then if ct mod 2 = 1 then a[8] := -a[8];{}

if i = 6 then if ct mod 4 = 2 then a[6] := -a[6];{}

if i = 6 then if ct mod 4 = 3 then a[6] := -a[6];{}

if i = 3 then if ct mod 2 = 0 then a[3] := -a[3];{}

ab2 := a[i] + a[i-1] ;

a[i] := ab1;

ab1 := ab2;

end;

if odd(ct) then a[17] := -a[17];

a[0] := ab1;

writeln(ct + 1);

writeln(trunc(a[0]));{}

READLN;

until 1<0;

Aldrich Stevens