RE: [Axiom-mail] Defining piece-wise functions and drawing, integrating, ...

[Bill Page]

On June 2, 2007 10:21 PM Sumant S.R. Oemrawsingh wrote:
> 
> Thanks for your answer. It is now more clear to me what 
> happens. As I am completely new to Axiom, I probably don't
> understand the full philosophy behind it yet, so I wish to
> ask a bit more on this, if you don't mind.

That is the purpose of this email list. Everyone is free to
ask and to answer questions here but if we discuss philosophy
I am afraid not everyone will agree. I believe that Axiom was
designed with a certain overall philosophy but that it was
not necessarily always applied consistently or in the same
manner by different people. For sure not everyone is going
to agree with my personal opinions about exact what this
"Axiom philosophy" is. I think that to properly discuss some
issues of philosophy requires a deep and thorough understanding
of the subject but not everyone has the patience or skill to
work at this level. Many people have very pragmatic reasons
for wanting to use a computer for doing mathematics - they have
some job they want to do and do not care too much about the
subject from an abstract "computer science" point of view. But
in my opinion the designers of Axiom did try very hard to take
the more general view while the designers of most other
superficially similar systems (e.g. reduce, maxima, maple,
mathematica, etc.) did not.

> 
> > You said you expected the 'f(x)' would represent some kind
> > of expression defined in a piecewise manner, but Axiom does
> > not currently have any expressions of this kind.
> 
> This is very strange, since in the Axiom book, there is a 
> whole section on piece-wise functions. Why have them, if
> they are not supported, so to say?

You have a very good point. Yes Axiom does have piece-wise
defined *functions* but it does not have piece-wise *expressions*.
It is important to make the distinction between function and
expression. In fact going deeper one can see that Axiom uses
the concept of "expression" in two different ways. In my
opinion understanding this is also an important part of the
Axiom philosophy.

For example in Axiom you can write the expression:

  (1) -> if x>0 then 1 else 0

    (1)  1
                              Type: PositiveInteger

The result of evaluating this expression depends on the value
assigned to x. This is a "piece-wise" expression in the sense
we have been discussing *BUT* this is a part of the Axiom
programming language - it is not part of any mathematical
object currently implemented in the Axiom library. The Axiom
library includes things like polynomials and even the domain
'Expression' containing expressions like 'x+1' or 'sin(1)'
but there is currently no domain in which we can find an
expression like 'if x>0 then 1 else 0'.

> If it can be defined and yields correct answers when called 
> with integers or even expressions yielding specific values
> (say, sqrt(5) or cos(1/2)), why can't it be integrated over
> a domain where the variable takes on specific values for
> which all the definitions are required to be evaluated?
> 

Do you understand the difference between writing?

  draw(sin(x),x=-5..5)

and

  draw(sin, -5..5)

Martin showed how you could use draw in this way to display a
piecewise defined function. Unfortunately Axiom's symbol
integration operator does not currently allow a function as
argument but Martin did gave an example of using 'Romberg' to
do numerical integration of functions.

In principle it would be possible to extend Axiom's integration
and differentiation operators to work symbolically on functions
but this is a non-trivial problem. I believe one Axiom developer
(Gabriel Dos Reis one of his students) has done some work on
symbol differentiation of functions.

It is also possible in principle to deal with piece-wise
expressions as mathematical objects in Axiom. Tim Daly has
discussed the development of a general "proviso" feature in
Axiom that would make this possible. But even fairly extensions
of the existing 'Expression' domain could probably handle
simple cases of piece-wise expressions of the sort you have
discussed so far.

> Thanks to your explanation, I understand why x < 0 (Variable, 
> Polynomial Integer, Symbol,...) *does not* return true, but
> I do not understand why it *should* not return true (from a
> design point of view).

Perhaps you are objecting to the decision of the Axiom library
developers to define '<' in terms of lexical ordering for
polynomials. Although this is natural in a certain context,
I agree that that was probably a poor choice on their part.

> But from a mathematical point of view (imho), the expression
> x < 0 should not be false; it should be true by default,
> unless it has been specified that x is an element of some
> set, since if it is *not* defined, it can have *any* value,
> also negative. Therefore, when one expects to test the
> domain of x, such as in an expression like this, it should
> be true by default.

I strongly disagree with this. Most people would read 'x<0'
as a logical predicate. It is true or false depending on
the value and/or quantification associated with x. You are
right to be concerned about the domain of x but unfortunately
Axiom currently has no way to evaluate logical predicates of
that kind.

> 
> So, I wish to tell axiom that x is an element of, say, R.
> I understand that I should declare the type, in my example
> Float -> Float, like so:
> 
> (1) -> f: (Float) -> Float
>                                                               
>      Type: Void
> (2) -> f(x|x<=0)==-x**2   
>                                                               
>      Type: Void
> (3) -> f(x|x>0)==x**2     
>                                                               
>      Type: Void
> (4) -> f(5)
>    Compiling function f with type Float -> Float 
> 
>    (4)  - 25.0
> 
> (5) -> f(5**(1/3))

>    (5)  2.9240177382 128660655
>                                                               
>     Type: Float
>

Right.
 
> How do I get a symbolic answer now? I don't care what the 
> answer up to n digits is, I want to know the actual, exact
> answer.

But you specified the domain 'Float' that is a domain where
numbers are represented by an approximation. If you want
symbolic answers you need to specify a different domain,
e.g. Expression Integer.

> This is even worse:
> 
> (6) -> draw(f(x),x=-1..1)
>    Conversion failed in the compiled user function f .
>  
>    Cannot convert from type Symbol to Float for value
>    x
> 

Write it this way:

  draw(f,-1..1)

When you write 'f(x)' you are asking for a piece-wise
expression but that is not currently possible in Axiom. But
if you operate directly on the piece-wise function then you
can get what you want.

> (6) -> integrate(f(x),x=-1..1)
>    Conversion failed in the compiled user function f .
>  
>    Cannot convert from type Symbol to Float for value
>    x
>

Unfortunately you can not currently write:

  integrate(f, -1..1)

except in the case where you would like to do numerical
integration (e.g. Romberg).
 
> Granted, I really don't care that much about drawing the 
> function. It is more of a visual aid to see that I defined
> my function correctly. For the example, this is not really
> necessary, but some of the functions I wish to perform
> calculations with, have some wild definitions, with many
> pieces.

For drawing that is ok.

> However, integration is very important, since that is what
> I really want to do in the end. Even if it manages to give
> me an answer of the integral, I still don't want to know
> the answer estimated to n digits, I would like the exact
> answer.
>

I think that exact integration of piece-wise functions in
general is a rather difficult problem.
 
> So the real question I would like to ask is, how can I
> tell axiom that, during function definition, my variable
> belongs to R (or C), while all operations still remain
> symbolic?

Right now there is no way to do this in Axiom but that is
(more or less) what Tim Daly means by a 'proviso'. This is
still a research topic in Axiom.

> How can I get it to first evaluate the value of x, figure
> out which function to use, and then return the value
> symbolically again?
> 

I don't know.

> I have tried by using "numeric(x) > 0" in the conditions,
> but then integration won't work since numeric won't work on
> symbols etc. Thanks to your explanation, I already expected
> that before I even tried it. On a side note, f(%pi) will
> work correctly then.
> 
> Which leads me to the following: why is %e fundamentally 
> different from %pi? Or, since Martin sort of answered that
> question already, I should ask: why *should* %e be
> fundamentally different from %pi? 

I don't think it should be. This is just an accident of a
series of separate design decisions. As Martin said, this
should probably be corrected by a more or less complete
redesign of how Axiom handles constants. This would amount
to another Axiom research project.

> 
> But I digress. The most important question is, how to define
> a function such that it first evaluates the value of x, then
> chooses which case to use and then perform the action?
> 
> In integrate(), I would expect it would look at the limits,
> perform an indefinite integral of the relevant cases, and
> then fill in the limits for each case correctly.

Perhaps you could describe this algorithm in more detail.
Can you write some Axiom scripts that perform this sort
of computation?

> For draw, I would expect something similar.
> 
> I've been doing some other stuff with axiom (no problems 
> there!), and think it is really amazing. That is also the
> reason that I find this particular point so frustrating. So
> if you or any one could help, I would be very much obliged.
> 

I hope this reply is of some help even though for the most
part it is saying that what you want from Axiom you will
probably have to help build for yourself. :-)

Regards,
Bill Page