OK, I think I understand what you and anderskaseorg mean by polynomial/non-polynomial sequences...

If we think about a polynomial, say 3x^2 + 2x + 1 -- then that's basically an algorithm that says "take x, raise it to the second power, muliply it by 3, take the result of that, add it to x multiplied by 2, and then take the result of that, and add one to it".

In other words, in that algorithmic definition,

a) There is no recursion

(note that factorials imply recursion in an algorithm -- even though they could be computed by using a simple look-up table)

and,

b) There is no division

(which could result in non-integer values)

So, in the formulas you give, you are using both recursion and division to form your sequences.

OK, so number tables / triangles / fans (call them what you will) -- don't work for things like that.

I am willing to buy into that, prima facie, but "with the proverbial grain of salt"...

You see, there's something deeper about math -- that we're not understanding here...

To understand what it is or may be (I don't know what it is, all that follows is mathematically speculative reasoning, and might be wrong, might be quite wrong indeed!), then I would suggest the following:

First, consider the Fibonnaci Sequence: https://oeis.org/A000045

Why?

Because this is the simplest (AFAIK) recurrence relationship (AKA recursive, "defined using recursion") integer sequence -- that can be produced.

To recap, its definition is:

F(n) = F(n-1) + F(n-2)

(with F(0) = 0 and F(1) = 1)

Now let's create that integer sequence -- and a corresponding number table / difference table / triangle / fan (again, call it what you will) -- and let's see if that works...

Now, I don't have Python all set up to do this -- all I have is pen and paper.

But I tried it -- and lo and behold, it works!

What's very interesting about the Fibonnaci Sequence -- is that if you create a number table for it -- you'll see that it repeats (although each row is shifted to the right!) in descending rows!

In other words, that number table -- if we can spot that pattern -- is in fact showing us the recurrence/recursive relationship!

In other words, it's still working(!) -- for this simple recurrence/recursive formula!

But we know that it fails -- somewhere between this simple recurrence algorithm -- and the one you have presented!

My challenge to you then, as a fellow Mathematician (I haven't done this by the way, I'm lazy! <g>) -- is to figure out when/where/why the number table / difference table / triangle / fan -- fails -- between the simplest of all recurrence relationship formula, the Fibonnaci sequence -- and this one!

Because you see, I'll bet there's some interesting mathematical knowledge there!.

I'd do it myself -- but no time!

Besides, you have Python already set up and running and everything... I don't!

Anyway, I think it would be interesting to know this!

Also -- once the exact failure criteria are understood -- next question is, is it possible to construct an n-dimensional table (like maybe 2 or more interlinked/interrelated number/difference tables) -- where one maps to others, and you can get the correct answer for deeply recursive algorithms -- which include division?