# [seqfan] Re: Falling factorials divided by rising factorials

David Applegate david at bcda.us
Mon Feb 21 17:23:52 CET 2022

```A few comments and suggestions:
(1) The editors of the OEIS are busy volunteers.  It isn't their job to
figure out what you really meant.  If you really care about a sequence,
take the time to pay close attention to the style guide
(https://oeis.org/wiki/Style_Sheet), and to look for standard notation
and terminology.
(2) In this case, a quick search turns up the wikipedia page on falling
and rising factorials:
https://en.wikipedia.org/wiki/Falling_and_rising_factorials. There you
would have learned that
(2a) Rising factorials don't necessarily start at 1. The denominators in
your sequence are just ordinary factorials. Referring to them as rising
factorials just confuses the issue, and raises the question of why the
row for 5 doesn't include 40 ((5)_4 / (3)_1))?
(2b) although (n)_k is a common notation for a falling factorial, it
means n * (n-1) * (n-2) * ... * (n-k+1) (i.e., k terms, not ending at
k), or equivalently, n! / (n-k)!, not n! / (k-1)!.  It is very confusing
to use standard notation to mean something completely different than the
standard definition.
(3) In your description, there wasn't a requirement that falling
factorial and the factorial in the denominator can't overlap - that is,
as described the entries for 5 should also include a second entry for 20
from (5)_4 / 3! = (5*4*3*2) / (3*2*1) = 20.  I suspect this is what led
to an editor noting that you skipped duplicates in some cases and not in
others.
(4) From https://oeis.org/wiki/Style_Sheet#Data, "If the terms are
fractions, then the numerators and denominators should be entered as
separate sequences, labeled with the Keyword 'frac', and with
cross-references connecting the two sequences." Deleting the fractional
values makes the sequence much less meaningful - there is no way to
connect the entry to what term it gives.  There are sequences that are
just a list of values, which are usually given in increasing order,
which I suspect is why an editor wondered about sorting the rows, since
you were treating them as just a list of values.  Taking a 3-dimensional
table and just deleting the entries you don't like tends towards nonsense.
(5) I haven't looked at the history of the sequence, but from history
you give in this post, it looks like your original submission didn't
include an example.  From https://oeis.org/wiki/Style_Sheet#Example,
sequences that are tables should always include an example illustrating
the first few rows. Omitting this makes it much harder for editors (and
(6) The cleaner you can make the definition of your sequence, the
better, even if this means including "trivial" values. For example,
consider A007318 <https://oeis.org/A007318> (Pascal's triangle, or
binomial coefficients). It is obvious that binomial(n,0) = binomial(n,n)
= 1, so you could try to eliminate all the 1s by just defining it to be
binomial(n,k) for 1 <= k < n (or, going one step further, binomial(n,1)
= binomial(n-1) = n is also obvious, so why not just use 2 <= k <=
n-2?).  In this case, I think trying to avoid some trivial terms made
the definition much messier. Another example is A068424
<https://oeis.org/A068424>, falling factorials, which doesn't try to
skip (n)_n even though it is always equal to (n)_n-1.

One simpler version would be "Three-dimensional table of falling
factorials divided by factorials (numerators)" (and denominators),
giving (n)_k/j! for n, k=1..n, j=1..n, and also giving the alternate
formula n! / ((n-k)! j!).

An alternative definition would just be "three-dimensional table of
factorials divided by products of two factorials (numerators)" giving
n!/(j!k!) for j=1..n, k=1..j (or perhaps j=1..n, k=1..n).

I'm not going to chime in on whether or not this is useful, but it seems
like a better starting point.

Also, please note that because of your plea for help, I spent a lot more
time digging into this and trying to sort out what was going on than I'd
expect an editor to do.

-Dave

On 2/20/2022 2:26 PM, jnthn stdhr wrote:
> Dear seqfans,
>
>    Please forgive the length of this post, but I am a bit peeved.
>
>    I am looking for help naming a sequence. This is my second attempt at
> finding a concise and understandable name.
>
>     This sequence derives from an irregular triangle, where each row is
> built by taking integer results from divisions of falling factorials by
> rising factorials.
>
>    The first row begins with n=2, because 2! is the first factorial that
> allows for a non-empty numerator (the falling factorial) and a non-empty
> denominator (the rising factorial); {[2], [1]}, and [2]/[1]=2,
>
>    The first seven rows are:
>
> 2;
>
> 6, 3;
>
> 24, 12, 6, 4, 2;
>
> 120, 60, 30, 20, 10, 5;
>
> 720, 360, 180, 120, 60, 20, 30, 15, 5, 6, 3, 1;
>
> 5040, 2520, 1260, 840, 420, 140, 210, 105, 35, 42, 21, 7, 7;
>
> 40320, 20160, 10080, 6720, 3360, 1120, 1680, 840, 280, 70, 336, 168, 56,
> 14, 56, 28, 8, 4;
>
>    Here is an example of of the fractions being considered, with the rising
> and falling factorials presented as sets, rather than products. For n=5,
>
> n, falling factorial/rising factorial = x
>
> 5, [5, 4, 3, 2] / [1] = 120
> 5, [5, 4, 3] / [1] = 60
> 5, [5, 4, 3] / [2, 1] = 30
> 5, [5, 4] / [1] = 20
> 5, [5, 4] / [2, 1] = 10
> 5, [5, 4] / [3, 2, 1] = 3.333333
> 5, [5] / [1] = 5
> 5, [5] / [2, 1] = 2.5
> 5, [5] / [3, 2, 1] = 0.833333
> 5, [5] / [4, 3, 2, 1] = 0.208333,
>
> which is why row four of the triangle contains 6 integers.
>
>    The motivation for this sequence arose from the question: when one
> removes a central sequential product from n!, and then divides the
> remaining falling factorial by the remaining rising factorial, when do we
> get an integer result?
>
>    Using the notation (n)_k for the falling factorial (as suggested by an
> editor), and the standard notation n! for the rising factorial, the
> elements of each row are determined by starting with the maximal falling
> factorial (i.e., k=2), (n)_2=n*(n-1)*...*2, and then dividing that number
> by all rising factorials i! in increasing order, with i ranging from 1 to
> (k-1), and updating the row with each integer result. Then the next smaller
> falling factorial, (n)_3, is then divided by all i! where 0<i<3. And so on,
> until we end by testing the fractions: (n)_(n)=n / 1!; n / 2!; ...; n /
> (n-1)!
>
>   To (hopefully) further clarify was is going on, I'll point out that, when
> viewed as a set of integers, the cardinality of the sequencial product
> being removed ranges from 0 to n-2, so that we always have a valid fraction
> to test -- e.g in the example with n=5 above, the cardinality of the
> central sequential product removed from 5! in the first fraction is zero,
> while the cardinality of the central sequential product removed in the
> seventh fraction is n-2.
>
>    My first attempt at finding a good name was scuttled by an editor,
> because the name that was provided by another well-intentioned editor was,
> apparently, too confusing. The ordering of the row elements was different
> in that attempt, but I don't believe that is relevant.
>
>    They asked, "Please can you sort the terms in each row in ascending
> order. Otherwise you need to properly define the ordering and explain why
> the ordering you have chosen is a natural choice."
>
>    Questions:
>     (1) Does asking to sort the terms make sense?
>
>    (2). Is there a "natural choice" of ordering of the row elements?
>    (3) Is there a *concise* and straight forward way to explain why the
> elements of the rows will never be well-ordered (see last row of example
> triangle)?
>
>    This indicated to me that the editor didn't understand what was going on.
>
>    Further, they stated "you seem to be removing duplicates and sometimes
> not."
>
>    I provided an example similar to n=5 above, and responed that they seemed
> to not understand what was going on, and that I didn't understand what they
> meant by "duplicates", so could they please explain, using my example, what
> they meant by "duplicates." Their response was: " I'm not sure it is for me
> to be understanding what is going on. Suggest to reject. Poorly prepared
> nonsense."
>
>    How can one edit , or meaningfully comment on, a sequence that they don't
> feel the need to understand?
>
>    Is this sequence nonsense?
>
>    Moving on, we can change the order of the row elements in various ways.
> For example, we could begin by dividing the least falling factorial (n)_(n)
> by all i!, and proceeding on up to the greatest falling factorial (n)_2. In
> doing so, we produce a (somewhat) different sequence, where the values
> found in each row never change, just their order. Is there a "natural
> choice" of ordering these row elements, as implied by the editor?
>
>    Since reordering the row elements changes the sequence, would there be
> any reason to add any/all of these other sequences?
>
>    If this sequence, or the family of sequences, is worthy of submission, I
> will allocated a block of A-numbers based on comments to this post.
>
>    Apologies for the rant.
>
> Sincerely,
> -jnthn
>
> P.S.
>
>    For anyone familiar with python:
>
>   def fallingFactorialList(n,k):
>    f=[]
>    for k in range(n,k,-1):
>      f.append(k)
>    return f
>
> def risingFactorialList(n):
>    f=[]
>    for k in range(n,0,-1):
>      f.append(k)
>    return f
>
> def prod(lst):
>    product=1
>    for d in lst:
>      product*=d
>    return product
>
> tri=[]
> for n in range(2,11):
>      row=[]
>      risingFactorials=[]
>      for j in range(1,n):
>          risingFactorials.append(risingFactorialList(j))
>      fallingFactorials=[]
>      for k in range(1,n):
>          fallingFactorials.append(fallingFactorialList(n,k))
>      for numerator in fallingFactorials:
>          for denominator in risingFactorials:
>              if numerator[-1]==denominator[0]:
>                  break
>              fraction=prod(numerator)/prod(denominator)
>              print(n, fraction, numerator, denominator)
>              if fraction.is_integer():
>                  row.append(int(fraction))
>      tri.append(row)
> seq=[]
> for r in tri:
>      print(r)
>      for m in r:
>           seq.append(m)
> print(seq)
>
> --
> Seqfan Mailing list -http://list.seqfan.eu/

```