[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Axiom-developer] [#84 conjugate(c)] (new)

From: Tim Daly
Subject: [Axiom-developer] [#84 conjugate(c)] (new)
Date: Fri, 28 Jan 2005 00:09:49 -0600

root address@hidden wrote:
> Clearly you're right and I agree with you.
> The problem, as I see it, is that there are subtle degrees of meaning
> that are easily stepped around when you work on paper but must be
> clarified in computational mathematics.

Why cannot we allow *all*?  I expect I should be able to coerce 'A+1' to
an Integer, Polynomial Integer, Expression Integer, etc.  The default
seems to be Integer, which seems fine.

The error seems to be in the Polynomial domain:
    (16) -> c:Complex Integer           
    (17) -> conjugate(c)     
       c is declared as being in Complex Integer but has not been given a 
    (17) -> c:Complex Polynomial Integer
    (18) -> conjugate(c)

       (18)  c
                                                 Type: Complex Polynomial 

Adding the Polynomial to its domain causes this to go wrong...

    (19) -> c:Polynomial Complex Integer
    (20) -> conjugate(c)
       There are 4 exposed and 1 unexposed library operations named 
          conjugate having 1 argument(s) but none was determined to be 

I'm surprised this doesn't work.  A Polynomial on a Ring is still a
member of that ring and should inherit its functions.  (in this case,
conjugate)  It also strikes me that Polynomial Complex Integer is the
proper type here, not Complex Polynomial Integer...clearly they are

> A: Integer
> might mean that 1) 'A' will hold a value which is an integer
> under interpretation (1)
> A+1 
> is an error since 'A' has no value. But what does the type of
> an unbound thing mean? Lisp assigns types to the values, not
> the boxes. This is like labeling a box 'television'.

This is the approach taken by Integer, Complex, and Float it seems.

> or perhaps that 2) 'A' is an indefinite object of type integer
> under interpretation (2)
> A+1
> is another indeterminant integer, where '+' comes from Integer.
> or perhaps that 3) 'A' obeys the laws applied to integers
> under interpretation (3)
> A+1
> is a polynomial with 2 integers, representing a constant, where
> '+' comes from Polynomial.

I cannot seem to construct an example of type (3).  Given: c:Integer and
I want to construct a Polynomial Integer containing 'c', how would I do

> or perhaps that 4) 'A' is a symbol which hold integers
> under interpretation (4)
> A+1
> is a polynomial in A with integer coefficients ignoring 'A's type
> where '+' comes from Polynomial.

The type of 'A' cannot be ignored since 'A+1' must Polynomial must have
a Field such as Integer in its constructor.

> or perhaps that 5) 'A' is an element of a Ring and theorems can be applied
> under interpretation (5)
> A+1
> is 'B', a new member of the Ring since '+' is a ring operator and both
> 'A' and '1' are ring elements. Ideally Axiom's types would be decorated
> with axioms, like the ring axioms making reasoning about unbound but
> typed objects possible. The '+' comes from the Category axioms of Integer.

Now this truly is a research project.  ;)

> The exact interpretation chosen appears to be dictated by the 
> underlying code and is not the same everywhere.
> Axiom is the product of many people, some of whom have chosen
> different interpretations. Indeed, some of the interpretations
> didn't exist before the computational aspects of mathematics
> came into play.

I think this *must* be clarified, and a unifying set of assumptions be
applied across all domains.

> There are quite a few areas of research that could be followed.
> Indeed, working out the implications of the several meanings of 
> 'A' is a PhD topic, and a rather hard one at that. The issue 
> heads off into questions of provisos, questions of reasoning with
> theorems and axioms, etc.

This does not seem so hard, but maybe I am being naive.

forwarded from

reply via email to

[Prev in Thread] Current Thread [Next in Thread]