Re: [Axiom-developer] a problem, maybe with strict typing

[William Sit]

Martin:

If I understand your question correctly, at least in the 
interpreter, there is no need to go to SUP F, especially 
for domains like F = EXPR INT. In the example you give, 

> Now let F be EXPR INT, or, in fact, any domain that has 
> TRANFUN. Already series
> as simple as g +-> sin g - sin 1, g(0) = 1 fail: 

it would be possible to "find g" with enough initial data 
using, with t standing for the next undetermined 
coefficient

taylor(sin(1+t*x)-sin(1),x=0)
    t cos(1)x - O(x^2)  

Now you want this to be zero, say. so t = 0.  You then 
iterate:

taylor(sin(1 + t*x^2) - sin(1), x=0)

and of course you get g = 1.  In general, you may want to 
use Puiseaux series.  For example, if you want sin(g(x))= 
sqrt(x), g(0) = 0, you would get

g(x) = sqrt(x)+(1/6)*x^(3/2)+(3/40)*x^(5/2)+t*x^(7/2) 

after a few iterations, which is the beginning terms of 
the series for asin(sqrt(x)) of course.

Now if you want to write a package, you do not want to fix 
the variable x (which a user of your package may use t, 
for example). However, assuming you are only using input 
functions (like z and initial data) that are univariate in 
EXPR INT, you can extract the main variable, and assign it 
to x (in your package). Let axiom generate a new symbol 
and assign it to t, which will be different from x (even 
if the user also uses t for his main variable, it will be 
a different t). Now you form your partial series for g 
involving t and x, and substitute g for x to form z g. 
Then compute the resulting series ending up in 
R:=UPXS(EXPR F,x,a) or UPS(EXPR F,x,a), where F can be 
simply INT. (If you require your user to give input 
functions directly from GR:=UPXS(F,x,a) or UPS(F,x,a), you 
will need to first "embed" gr to SGR:=UPXS(SUP F,x,a) or 
UPS(SUP F,x,a), and you can assign t to the main variable 
of SUP F; then you have to repack everything (just the 
normal part of the series up to the order you need) back 
into EXPR F before forming the series in R). In any case, 
you can now compute your undetermine coefficient one at a 
time using arithmetic in EXPR F. The series for g may be 
retracted to GR. The user of your package would not need 
to know anything about your auxilliary variable t.

Something similar to this can be found in IDEAL 
(PolynomialIdeals) package where we need an auxilliary 
variable (like your t) to turn inequations h \ne 0 into an 
equation of the form h*t-1 = 0 (here t must not be mixed 
up with user variables). A lot of type conversion is 
needed between different polynomial rings. So here, you 
need to write type conversion routines between EXPR INT 
and UPXS or UPS (one direction is given by series or 
taylor already).

William