Ralf Hemmecke <[email protected]> writes:
>>> ... you iterate over all n. n lives where exactly? Unspecified. Right?
>>
>> No, I do not iterate over all n. n is a non negative integer, we are
>> dealing with formal power series only, i.e., no Puiseux or Laurent
>> expansions are considered.
>
> So, why not making it explicit somewhere? In the paper and in the ++
> documentation.
I will. The reason we did not is that we didn't think about it.
>>> But your sequence is fully given, i.e. you could compute the
>>> coefficient up to any order n.
>
>> no, although that's one would hope for. But it may happen that the
>> equation does not determine a sequence completely.
>
>> Does this answer your question?
>
> Not really. You know, I want to have an exact specification of the function.
>
> So an input of guessADE is a list of rational numbers.
Well, it could also be a list of polynomials or algebraic numbers, etc.
> The output is? Not right.
The output is *very* difficult to describe.
> Next attempt. Given a formal power series f \in K[[x]]. (If I write
> that, it means that (in principle) I know every coefficient.) The
> input of guessADE is [f_0, ..., f_k], i.e. the first k+1 coefficients
> in the series expansion of f.
> The output is... ? You have to help me here. If you say it's an
> expression, that is rather unspecific. I would rather like to have
> something else than Expression Integer. You could (and I think you
> should) rather have
>
> guessADE: List(K) -> ADES(K)
>
> where ADES is a type of "system of algebraic differential equations
> over K". Actually, what you write in equation (7) on page 5, you
> could even say
>
> gusesADE: List(K) -> (SUP(K), INI(K))
>
> (I guess, it's easy enough to figure out what the type INI(K) for the
> initial conditions can be.)
>
> Why not simply returning a polynomial as described in (7)?
well, apart that it's not univariate, that's of course one possibility.
However, I wanted that
res := guessADE [n^n/factorial n for n in 0..12]
eval(first res, 'n=30)
works. Moreover, consider:
(1) -> res := guess([product(1+factorial k, k=0..n-1) for n in 0..6],
[guessPRec], [guessProduct])
n - 1
++-++
(1) [ | | [f(p ): f(p + 1) + (- p - 1)f(p ) + p = 0,f(0)= 2]]
| | 7 7 7 7 7
p = 0
7
(2) -> [eval(first res, 'n=n) for n in 1..10]
(2)
[2, 4, 12, 84, 2100, 254100, 183206100, 923541950100, 37238134969982100,
13513011656042074430100]
Finally, we have
(3) -> r(0)==1; r(1)==1; r(n)==q^(n-1)*r(n-1)+(n-2)*r(n-2);
Type: Void
(4) -> guessPRec(q)([r m for m in 0..7], maxMixedDegree==1, maxDegree==1,
homogeneous==true)
Compiling function r with type Integer -> Fraction(Polynomial(
Integer))
Compiling function r as a recurrence relation.
n
(4) [[f(n): q f(n + 1)q - f(n + 2) + n f(n)= 0,f(0)= 1,f(1)= 1]]
Type: List(Expression(Integer))
where the result is really a polynomial in f(n), f(n+1), ... with
coefficients in Z[q, q^n]. There is currently no domain in FriCAS I
know of to handle these...
I wanted to be able to use guessing routines in a uniform fashion and
possibly nested way. The easiest (the only?) way to allow that is to
use a common type. However, I actually want to introduce new domains
(eg. UnivariateHolonomicFormalPowerSeries) which cover specific classes
of functions, and it would then be good to also have guessing routines
that return an element of that domain. I think however that this
routine would then be an export of the domain
UnivariateHolonomicFormalPowerSeries and probably be called "recover" or
"reconstruct" or some such.
Unfortunately, although I have a toy implementation of a few such
domains (I posted it here some time ago, search the web for UHOLO1), a
lot of work remains to be done. It would be great if you could help -
you are surrounded by specialists in the field at RISC...
> Wouldn't that even make the result more accessible to further
> computation?
No, as explained above. Is the explanation above good enough?
> And, in fact, it would be easier to specify. All you
> would claim in the end is that this is a polynomial that works for
> the given input list. We all know that with a finite amount of input
> we can never be sure of the resulting polynomial. But what one can
> do, is, to clearly specify what the returned polynomial actually
> means.
> From what you say, that the result does not always specify the
> solution uniquely. OK, but as far as I understood, guessADE is not
> claiming that. It is just finding a possible polynomial p where, if
> the given f is entered, it vanishes up to order k+2 (at least). That
> is a clear specification. And if this is not fulfilled, the function
> returned garbage. By no means you can claim that your function
> figured out the "right" polynomial. That you have to do in an
> additional (manual proof) that involves *all* the coefficients of f.
exactly. It is for convenience that the output polynomial is wrapped up
as an expression also for guessADE, guessPRec, etc.
(guess, guessBinRat and guessExpRat do not return polynomials...)
Martin
--
You received this message because you are subscribed to the Google Groups
"FriCAS - computer algebra system" group.
To post to this group, send email to [email protected].
To unsubscribe from this group, send email to
[email protected].
For more options, visit this group at
http://groups.google.com/group/fricas-devel?hl=en.
