# [seqfan] Re: Integer Sequence Analysis in Mathematica 7

Eric W. Weisstein eww at wolfram.com
Thu Nov 20 18:01:47 CET 2008

```On Thu, 20 Nov 2008, Mitch Harris wrote:

>> make it possible to take lists of sequence elements and
>> systematically find large classes of closed-form Mathematica formulas
>
> systematically -guess-, right? (for a finite list)

Technically yes, it is a guess.  But:

1) Note that FindSequenceFunction begins with Find*, and all Find*
functions in Mathematica are intended to be used on inputs that do not
necessarily have a unique (or any) solution

2) A result is only returned if it can be validated on some number terms
beyond those that were used to infer the functional form:

In[1]:= Options[FindSequenceFunction]
Out[1]= {FunctionSpace -> Automatic, Method -> Automatic,
TimeConstraint -> 10, ValidationLength -> Automatic}

> Anyway, it -is- excellent that it has a new guessing function, it will
> -considerably- help the experimental process (generate some numbers,
> hypothesize a function, check OEIS to see if it's already there and
> check the rest of the sequence).

I agree.  I have been using this new functionality in Mathematica for some
time already during the development stages, and while there remains some
room for improvement, it is very useful for me in much of my integer
sequence work.

> Sorry to turn back to the negative comments but (maybe Eric can pass
> this along to the mma

(Just a brief note for anyone interested that for certain historical
reasons, people in my neck of the woods prefer writing out Mathematica or
using M- (or M--, I actually can't remember which ;) instead of the
abbreviations mma or Mma.)

> designers), look at that first example for the determinant of a Hilbert
> matrix. How would one normally write that? With products of factorials.
> But the mma solution uses these special functions, Glaisher, BarnesG.

I assume you are referring to this example?

In[2]:= l = Table[1/Det[HilbertMatrix[n]], {n, 10}]
Out[2]= {1, 12, 2160, 6048000, 266716800000, 186313420339200000, \
2067909047925770649600000, 365356847125734485878112256000000, \
1028781784378569697887052962909388800000000, \
46206893947914691316295628839036278726983680000000000}

In[3]:= FindSequenceFunction[l][n]
Out[3]= (2^(-(1/12) - n + 2*n^2)*Glaisher^3*BarnesG[1/2 + n]*
BarnesG[3/2 + n])/(Pi^n*(E^(1/4)*BarnesG[1 + n]^2))

> First time I've -ever- seen these.

They're actually quite handy; see e.g.,

http://mathworld.wolfram.com/Glaisher-KinkelinConstant.html
http://www.research.att.com/~njas/sequences/A074962

http://mathworld.wolfram.com/BarnesG-Function.html
http://www.research.att.com/~njas/sequences/A000178

http://mathworld.wolfram.com/Hyperfactorial.html
http://www.research.att.com/~njas/sequences/A002109

(note very low A-numbers for the latter 2 ;)

> And lots of other manipulations that by hand would result in factorials
> and binomials, through mma result in opaque Gammas with sqrt(pi)-like
> coefficients. I understand that mma might be designed in the direction
> of people having more facility with analysis than me, but, hey, if a
> summation/product is not closed-form, then replacing it with a special
> function name is not really either,

Actually, it's quite beautiful that Mathematica now has Hyperfactorial and
BarnesG (as well as QPochhammer and friends) built in.  It greatly extends
the range of functions (and sequences) that can be represented in closed
form, and hence that can be operated on symbolically (and numerically as
well).  So a greatly extended class of sums, products, recurrences, ODEs,
etc. can now also be given in closed form.

Even better, once you have such a form, you can compute asymptotics,
recurrences, generating functions, etc. etc. *symbolically*.  You also
have a very nice, concise, and usually canonical way of writing the
functions (so many existing OEIS sequences could now have *very*
concise/shorter Mathematica representations that could be added).

A symbolic math program can't (or at least doesn't want to) return
unevaluated products because you can't *do* anything with them; they're
almost dead to further symbolic analysis. On the other have, it's trivial
to go from a named function to the product if you really want, e.g.,

In[4]:= BarnesG[n] BarnesG[n + 2] /.
BarnesG[n_] :> HoldForm[Product[k!, {k, 0, n - 2}]]
Out[4]= HoldForm[Product[k!, {k, 0, n - 2}]]*
HoldForm[Product[k!, {k, 0, (2 + n) - 2}]]

Yes, things are a bit more complicated for non-integer arguments (and
there's still some room for improvement in Mathematica's symbolic
simplification of some of its new functions).

> and the summation/product will say more about the combinatorics anyway.

That I'm not so sure about, though I have no trouble believing there could
be situations where it was the case.  Can you by any chance give such an
example?

I do understand your points.  But if I haven't been able to shed some
light onto why symbolic "super"-functions are/could be worth the cost of
having to learn about them, I'm certainly happy to discuss further.

Best wishes for happy holidays,
-Eric

```