```On 6 Dec 2005, at 19:25, Steven T. Hatton wrote:

>>
>> Well, actually the proofs for E and Pi are quite different.
>
> I believe you can derive Pi from E, so it should be possible to
> prove the
> former from the latter.

I have decided to give up discussing computer science issues (see
last remark at the  bottom) but this is a different matter. "Derive
Pi form E"? What on earth can you mean? Are you by any chance
referring to something like the Euler formula:

Exp[I Pi]==-1.

In that case would you say that you can also "derive" I form Pi and
E? What do you mean by deriving a number from another number? Every
real number is some power of E: are they all transcendental?
You assert that "It should be possible to derive the transcendence of
the Pi from the transcendence of E". Well, mathematics is not a
subject in which such vague claims have any place. Logically one can
also make the claim that "it should be possible to derive any true
statement from any other true statement" since in Logic True implies
True. But having what would be considered by most mathematicians as a
valid mathematical proof is quite another matter. Please note that
Lindemann proved the transcendence of Pi ten years after Hermite
proved the transcendence of E. I would speculate that all the
analysis you are familiar with was already familiar to Lindemann and
yet he, a really great mathematician, could not simply deduce the
transcendence of Pi form that of E. Moreover, Lindemann's proof is
still  considered one of the major achievements in mathematics. Now
you come along w assert that "it should be possible".  Don't you
think it is a little bit funny?

>
>> But in any case, all this has nothing to do with "types" in the sense
>> of computer science.
>
> I don't agree.  I believe what we are dealing with here fits into
> the notion
> of inheritance hierarchies as are found in OOP.  There are cases
> when one
> creates an inheritance hierarchy simply for the purpose of grouping
> objects
> conceptually.  The objects of the distinct classes may verywell have
> identical implementations.  The class of the object is merely a
> means of
> tagging it.
>
> Since we really don't have a way of modifying the implementation of
> such
> objects as Pi and E, we may accomplish the same functionality, at
> least on
> a limited scale, using predicates, and explicitly adding those
> items or
> features we are interested in to the predicate tests.  Thus RealQ
> might
> test for everything that is a number, and not Complex.
>

Hm. Are you aware of the following:

1. There is no known algorithm that can determine if a given
algebraic number is real or not.
2. Consider these simple examples:

IntegerQ[Cos[Pi/7]^2+Sin[Pi/7]^2]

False

and also try this:

Element[1 + I*(Cos[Pi/7]^2 + Sin[Pi/7]^2 - 1), Reals]

Do you still claim that

> Thus RealQ might
> test for everything that is a number, and not Complex.

As for the difference between the concept of _Real and Reals    I
think I will simply refer to much bigger authority than myself,
namely the professor of computer science at Berkley, R.J. Fateman,
who once quite mistakenly accused me on this list of not being aware
of this difference . If he is reading this perhaps he might like to
take up this debate.
I think I will stick to my own area which is mathematics.

Andrzej Kozlowski

```

• Prev by Date: Types in Mathematica
• Next by Date: Re: How would you evaluate this limit in Mathmatica