You can subscribe to this list here.
2007 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}
(73) 
_{Sep}
(57) 
_{Oct}
(138) 
_{Nov}
(91) 
_{Dec}
(99) 

2008 
_{Jan}
(91) 
_{Feb}
(53) 
_{Mar}
(37) 
_{Apr}
(125) 
_{May}
(176) 
_{Jun}
(23) 
_{Jul}
(135) 
_{Aug}
(119) 
_{Sep}
(26) 
_{Oct}
(38) 
_{Nov}
(46) 
_{Dec}
(11) 
2009 
_{Jan}
(4) 
_{Feb}
(2) 
_{Mar}
(5) 
_{Apr}
(15) 
_{May}
(4) 
_{Jun}
(18) 
_{Jul}
(1) 
_{Aug}
(4) 
_{Sep}
(17) 
_{Oct}
(9) 
_{Nov}
(14) 
_{Dec}
(11) 
2010 
_{Jan}
(9) 
_{Feb}
(6) 
_{Mar}
(1) 
_{Apr}
(1) 
_{May}
(4) 
_{Jun}
(3) 
_{Jul}

_{Aug}
(10) 
_{Sep}
(7) 
_{Oct}
(7) 
_{Nov}
(36) 
_{Dec}
(23) 
2011 
_{Jan}
(2) 
_{Feb}
(1) 
_{Mar}
(1) 
_{Apr}
(11) 
_{May}
(5) 
_{Jun}
(17) 
_{Jul}
(2) 
_{Aug}
(26) 
_{Sep}
(14) 
_{Oct}
(51) 
_{Nov}
(39) 
_{Dec}
(7) 
2012 
_{Jan}
(24) 
_{Feb}
(7) 
_{Mar}
(9) 
_{Apr}
(2) 
_{May}
(9) 
_{Jun}
(7) 
_{Jul}
(3) 
_{Aug}
(1) 
_{Sep}
(8) 
_{Oct}
(12) 
_{Nov}
(1) 
_{Dec}

2013 
_{Jan}

_{Feb}

_{Mar}

_{Apr}
(35) 
_{May}
(28) 
_{Jun}
(14) 
_{Jul}
(10) 
_{Aug}
(3) 
_{Sep}
(6) 
_{Oct}

_{Nov}
(1) 
_{Dec}

2014 
_{Jan}

_{Feb}

_{Mar}

_{Apr}
(4) 
_{May}
(3) 
_{Jun}
(2) 
_{Jul}
(2) 
_{Aug}
(2) 
_{Sep}
(1) 
_{Oct}
(3) 
_{Nov}
(5) 
_{Dec}
(8) 
2015 
_{Jan}
(3) 
_{Feb}
(2) 
_{Mar}

_{Apr}

_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}
(1) 
2016 
_{Jan}
(5) 
_{Feb}
(10) 
_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}
(5) 
2017 
_{Jan}
(2) 
_{Feb}
(2) 
_{Mar}
(5) 
_{Apr}
(1) 
_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 

1

2
(1) 
3
(1) 
4
(2) 
5
(1) 
6

7

8

9
(1) 
10

11
(2) 
12

13

14

15

16

17

18
(7) 
19
(1) 
20

21

22
(1) 
23

24

25

26
(1) 
27
(3) 
28

29

30
(2) 





From: Bill Page <bill.page@ne...>  20080630 17:18:54

On Mon, Jun 30, 2008 at 10:27 AM, Francois Maltey wrote: > > Gabriel and Bill discuss about : > > draw(sin(x), x=1..10, title=="sin function") > ... > all theses optional parameters might occur in a list : > > draw(sin(x), x=1..10, [title="sin function"]), > draw(sin(x), x=1..10, []) or > draw(sin(x), x=1..10, [title="sin function", numberOfPoints = 100, > drawAxes=false, viewWindows=[%pi..%pi,1..1]]) > > The type of this list contains terms of a new domain > OptionalParameters, described by : > identificator = an Any object, it looks like other cas... > If you wish, you can call the Axiom draw command in the manner you describe above, avoiding the use of == draw(sin(x), x=1..10, [title("sin function")), draw(sin(x), x=1..10, []) draw(sin(x), x=1..10, [title("sin function"), var1Steps(100), clip(false), range([%pi..%pi,1..1])]) There is no need to invent a new type of parameter, although not all options in your example seem to be available. Regards, Bill Page. 
From: Francois Maltey <fmaltey@ne...>  20080630 14:27:42

Gabriel and Bill discuss about : draw(sin(x), x=1..10, title=="sin function") I [Bill] realized the interpreter does something rather clever but probably quite unexpected. I don't find it so clever. I understand only after your mails that this == isn't the definition of the function title, but a trick about lists of arguments. And [Gaby] I don't like it : The problem is that SPAD does not provide builtin support for calling functions with optional arguments. I don't like this ==, too. Axiom operates over one list of arguments when there are a lot of arguments, try : concat ([1,2], [3,4]) or concat [[1,2],[3,4],[5,6]]. The second concat is reduce (concat, L, []). It may be useful to have a lot of functions as this one : min / max / horizConcat / vertConcat / + / * and remain reduce only for the rare cases. draw(sin(x), x=1..10, title=="sin function") all theses optional parameters might occur in a list : draw(sin(x), x=1..10, [title="sin function"]), draw(sin(x), x=1..10, []) or draw(sin(x), x=1..10, [title="sin function", numberOfPoints = 100, drawAxes=false, viewWindows=[%pi..%pi,1..1]]) The type of this list contains terms of a new domain OptionalParameters, described by : identificator = an Any object, it looks like other cas... F. 
From: Bill Page <bill.page@ne...>  20080627 12:19:57

On Fri, Jun 27, 2008 at 4:59 AM, Gabriel Dos Reis wrote: > > Bill Page writes: > >  panAxiom developers, >  >  I just wanted to mention something here that I just learned about how >  the Axiom interpreter handles option arguments. When discovering how >  the 'draw' operations in Axiom processes optional arguments, e.g. >  >  draw(sin(x), x=1..10, title=="sin function") > > Hmm, I thought I already mentioned this in discussions with Ralf ;/ > Sorry I missed it. Can you please tell me wihich list? When? >  >  I realized the interpreter does something rather clever but probably >  quite unexpected. > > It is the post parser doing it. And I don't like it  the irony is > that I made Boot do the same. > >  The problem is that (unlike Aldor) SPAD does not >  provide builtin support for calling functions with optional >  arguments. Instead what it does is collect all the arguments >  containing == into a List *and* then it applies the name to the >  left of == as a function to the value on the right. So much to >  my surprize: > > Quite disgusting, no? >... Weird at least, but oddly effective as a representatio. Too bad it increases the distance between the interpreter and compiler languages. >  What do you think? Do you like that, or is this something that >  should be implemented in a deeper way? > > I don't like it: For example, I cannot '==' to mean `definition' > in expressions  but I already had that debate with Ralf. > Perhaps it would be better to provide a function to which == maps, e.g. x == y ==> OPTARG(x,y) which does by default what the interpreter wants for now but which allows customization? Regards, Bill Page. 
From: Gabriel Dos Reis <gdr@cs...>  20080627 08:59:28

"Bill Page" <bill.page@...> writes:  panAxiom developers,   I just wanted to mention something here that I just learned about how  the Axiom interpreter handles option arguments. When discovering how  the 'draw' operations in Axiom processes optional arguments, e.g.   draw(sin(x), x=1..10, title=="sin function") Hmm, I thought I already mentioned this in discussions with Ralf ;/   I realized the interpreter does something rather clever but probably  quite unexpected. It is the post parser doing it. And I don't like it  the irony is that I made Boot do the same.  The problem is that (unlike Aldor) SPAD does not  provide builtin support for calling functions with optional  arguments. Instead what it does is collect all the arguments  containing == into a List *and* then it applies the name to the left  of == as a function to the value on the right. So much to my surprize: Quite disgusting, no?   (1) > (x+>x)(sin==x,cos==y)   (1) [sin(x),cos(y)]   Type: List Expression Integer   is equivalent to:   (2) > (x+>x)([sin(x),cos(y)])   (2) [sin(x),cos(y)]   Type: List Expression Integer   The list of optional arguments is always passed as the last argument  to the function. This is completely general so one can write for  example:   (3) > ((x,y)+>[x,y])(sin==x,n,cos==y)   (3) [n,[sin(x),cos(y)]]   Type: List Any   What do you think? Do you like that, or is this something that should  be implemented in a deeper way? I don't like it: For example, I cannot '==' to mean `definition' in expressions  but I already had that debate with Ralf.  Gaby 
From: Bill Page <bill.page@ne...>  20080627 04:50:27

panAxiom developers, I just wanted to mention something here that I just learned about how the Axiom interpreter handles option arguments. When discovering how the 'draw' operations in Axiom processes optional arguments, e.g. draw(sin(x), x=1..10, title=="sin function") I realized the interpreter does something rather clever but probably quite unexpected. The problem is that (unlike Aldor) SPAD does not provide builtin support for calling functions with optional arguments. Instead what it does is collect all the arguments containing == into a List *and* then it applies the name to the left of == as a function to the value on the right. So much to my surprize: (1) > (x+>x)(sin==x,cos==y) (1) [sin(x),cos(y)] Type: List Expression Integer is equivalent to: (2) > (x+>x)([sin(x),cos(y)]) (2) [sin(x),cos(y)] Type: List Expression Integer The list of optional arguments is always passed as the last argument to the function. This is completely general so one can write for example: (3) > ((x,y)+>[x,y])(sin==x,n,cos==y) (3) [n,[sin(x),cos(y)]] Type: List Any What do you think? Do you like that, or is this something that should be implemented in a deeper way? Regards, Bill Page. 
From: Bill Page <bill.page@ne...>  20080626 14:35:38

Alasdair, On Wed, Jun 25, 2008 at 8:18 PM, you wrote: > Actually, while axiom under windows still seems to be in a state of flux, > it would be nice to have a plotusinggnuplot interface as an alternative > to axiom's graphics subsystem, which is not yet ported as a windows > binary. > On several different Windows systems I have been running the binary version of FriCAS compiled and packaged for Windows by Alfredo without any serious problems. It only requires that you also install the native Xming program in order to display hyperdoc and graphics. The (minor) problems I have occur when I try to run this on a system which is already otherwise occupied running other memory hungry applications like Microsoft Virtual PC. In that case I sometimes get a error when starting Axiom due to already known issues with Windows memory management. Reducing the number of running applications usually cures the problem. However, I do agree that having Axiom generate gnuplot graphics on Windows would also be desirable. I think the code displayed at: http://axiomwiki.newsynthesis.org/PlotMathAction will work in the Windows environment. This code however, only implements a small part of the overall graphics capabilities of Axiom using gnuplot. Both Axiom graphics and gnuplot are able to do many more exciting things. I would be very happy if other people were also interested in extending the Axiom gnuplot interface to make more of this available to the user. Regards, Bill Page. > Alasdair > > On Thu, Jun 26, 2008 at 9:56 AM, Bill Page wrote: >> >> David, >> >> I have spent a little time polishing your work from last year on the >> interface for gnuplot in mathaction. This page is based on you >> original work but I have added new SPAD code to create gnuplot scripts >> from Axiom graphics (draw) output. See: >> >> http://axiomwiki.newsynthesis.org/PlotMathAction >> >> The main difference from what you were doing is that I have >> incorporated gnuplottex into the wiki. This allows the LaTeX >> postprocessor to handle the presentation of the gnuplot graphics. I >> would be very pleased if you had a few minutes to comment on this >> approach and if time permits, to contribute a few more tests and/or >> modifications to the code. >> >> Cc: Of course this also applies to all Axiom, FriCAS and OpenAxiom users! >> >> Cheers, >> Bill Page. >> >> >> _______________________________________________ >> Axiommail mailing list >> Axiommail@... >> http://lists.nongnu.org/mailman/listinfo/axiommail > > > >  > Blog: http://amca01.wordpress.com 
From: Ralf Hemmecke <ralf@he...>  20080622 21:29:44

To whoever knows about the history of the aldoraxiom connection, Important in the build of the aldoraxiom connection are the files axlit.as and axextend.as that can be found at https://svn.origo.ethz.ch/algebraist/trunk/aldor/lib/libax0/ I roughly understand why they exist. What I don't understand is their actual contents. It seems clear to me that Literal and Generator have to be made available and that I should be able to use [...], i.e., the function "bracket" to construct lists. But what I don't understand is, for example, why Bit ==> Boolean; extend SingleInteger : with { ... =: (%, %) > Bit; <: (%, %) > Bit; } == add { Rep ==> SInt; asBool(x) ==> x pretend Boolean; ... import { ... SIntEQ: (SInt, SInt) > Bool; SIntLT: (SInt, SInt) > Bool; ... } from Builtin; ... (a: %) = (b: %): Bit == asBool(SIntEQ(rep a, rep b)); (a: %) < (b: %): Bit == asBool(SIntLT(rep a, rep b)); ... } appears in axextend.as. Axiom's SingleInteger already exports IntegerNumberSystem, which clearly should also contain = and <. It would be very helpful if sombody could explain the content of those two files (not only the example that I've given above. However, I appreciate any helpful comment. Please come forward. Thank you Ralf 
From: Ralf Hemmecke <ralf@he...>  20080619 04:46:44

Taken from sal_list.as: List(T:Type): ListType T == add { Rep == Record(elt:T, next:%); ... if T has PrimitiveType then { (l1:%) = (l2:%):Boolean == {...} ... }} It leads to an unspecified behaviour for L: List OutputType := [Integer, String]; Ralf > The reason is that there are two separate concepts: > > D \in C and C' \subset C > > It is reasonable to want the second, but that is not what "has" does. > Do you have some concrete examples? 
From: Ralf Hemmecke <ralf@he...>  20080618 17:21:50

Dear Stephen, could you say a few words to the topic why Aldor only allows <domain> has <category> instead of <domain or category> has <category> ? Ralf >> See AUG page 96: >> >> Has expressions >> A "has" expression has the following form: >> dom has cat >> where dom is a domainvalued expression, and cat is a categoryvalued >> expression. >> >> So at least "has" is different in the Axiom interpreter or in SPAD. >> > > You are right, there is a difference between Aldor and OpenAxiom. In > Aldor Type is not a category  it is a domain! > > root@...:~# cat mylibs.as > #include "aldor" > #include "aldorinterp" > #include "algebra" > > root@...:~# aldor gloop > Aldor > > Copyright (c) 19902007 Aldor Software Organization Ltd (Aldor.org). > > Release: Aldor(C) version 1.1.0 for LINUX(glibc2.3) > Type "#int help" for more details. > %1 >> #include "mylibs" > Comp: 260 msec, Interp: 0 msec > %2 >> Type > () @ > with > == add () > > And subtypes of Type are categories, so like in OpenAxiom Category is > also a domain  the domain of subtypes of Type. > > %3 >> Category > () @ > with > == add () > > Domains are the members of Type and therefore also are members of one > or more Category. > > For example, in > > http://www.csd.uwo.ca/~watt/pub/reprints/2003cahandaldor.pdf > > Stephen Watt wrote: > > "Each value belongs to some unique type, known as its domain, and the > domains of expressions can be inferred statically. Each domain is > itself a value belonging to the domain Type. Domains may additionally > belong to some number of subtypes (of Type), known as categories." > >> %8 >> Cat:Category == with; >> >> %11 >> Integer >> () @ Join( >> PrimitiveType with >> coerce: BInt > % >> coerce: % > BInt >> == add () >> , >> IntegerType with export to IntegerSegment(%) >> == add () >> ) > > http://www.aldor.org/docs/HTML/chap7.html#7 > > Aldor does not use the name 'Domain' to refer to any type. So far I > have not found any explicit name for the category > > with {} > > so I guess it is a cruel little comedy that 'Domain' seems like a good > name for the top of the *category* hierachy in Aldor though it is > called 'Type' in Axiom. Meanwhile 'Domain' in Axiom corresponds to > 'Type', and 'Type' in Aldor is a domain... ;( > >> ... > > Ralf, you are also right that 'has' has a more restricted meaning in > Aldor than in Axiom. In Axiom we can write: > > <domain> or <category> has <category> or <attribute> > > an <attribute> is just a named category with no exports. > > In the Axiom interpreter > > <category 1> has <category 2> > > is true if <category 1> is a subtype of <category 2> > > <domain> has <category> > > is true if <category> appears in the a 'Join' expression or to the > left of the keyword 'with'. This is described in 
From: Bill Page <bill.page@ne...>  20080618 17:06:28

On Wed, Jun 18, 2008 at 7:53 AM, Ralf Hemmecke wrote: > On 06/18/2008 01:37 PM, Bill Page wrote: >> >> On 6/18/08, Ralf Hemmecke wrote: >>> >>> ... >>> Bill Page wrote: >>>> >>>> That category that plays this role in Axiom is called Type >>>> (1) > )sh Type >>>> Type is a category constructor >>> >>> Hmmm, maybe I mix again Aldor and SPAD... >>> >>> See section 7.7 AUG: >>> Type: A type S satisfies the languagedefined type Type if S is >>> the type of a domain or category. In other words, all domains >>> and categories are types. >>> >>> Is this really different for SPAD? (I am not saying anything about >>> the interpreter.) >> >> No, I think it is the same. Both domains and categories satisfy >> Type, e.g. >> >> (1) > SetCategory has Type >> >> (1) true >> Type: Boolean >> (2) > Integer has Type >> >> (2) true >> Type: Boolean > > See AUG page 96: > > Has expressions > A "has" expression has the following form: > dom has cat > where dom is a domainvalued expression, and cat is a categoryvalued > expression. > > So at least "has" is different in the Axiom interpreter or in SPAD. > You are right, there is a difference between Aldor and OpenAxiom. In Aldor Type is not a category  it is a domain! root@...:~# cat mylibs.as #include "aldor" #include "aldorinterp" #include "algebra" root@...:~# aldor gloop Aldor Copyright (c) 19902007 Aldor Software Organization Ltd (Aldor.org). Release: Aldor(C) version 1.1.0 for LINUX(glibc2.3) Type "#int help" for more details. %1 >> #include "mylibs" Comp: 260 msec, Interp: 0 msec %2 >> Type () @ with == add () And subtypes of Type are categories, so like in OpenAxiom Category is also a domain  the domain of subtypes of Type. %3 >> Category () @ with == add () Domains are the members of Type and therefore also are members of one or more Category. For example, in http://www.csd.uwo.ca/~watt/pub/reprints/2003cahandaldor.pdf Stephen Watt wrote: "Each value belongs to some unique type, known as its domain, and the domains of expressions can be inferred statically. Each domain is itself a value belonging to the domain Type. Domains may additionally belong to some number of subtypes (of Type), known as categories." > %8 >> Cat:Category == with; > > %11 >> Integer > () @ Join( > PrimitiveType with > coerce: BInt > % > coerce: % > BInt > == add () > , > IntegerType with export to IntegerSegment(%) > == add () > ) http://www.aldor.org/docs/HTML/chap7.html#7 Aldor does not use the name 'Domain' to refer to any type. So far I have not found any explicit name for the category with {} so I guess it is a cruel little comedy that 'Domain' seems like a good name for the top of the *category* hierachy in Aldor though it is called 'Type' in Axiom. Meanwhile 'Domain' in Axiom corresponds to 'Type', and 'Type' in Aldor is a domain... ;( > ... Ralf, you are also right that 'has' has a more restricted meaning in Aldor than in Axiom. In Axiom we can write: <domain> or <category> has <category> or <attribute> an <attribute> is just a named category with no exports. In the Axiom interpreter <category 1> has <category 2> is true if <category 1> is a subtype of <category 2> <domain> has <category> is true if <category> appears in the a 'Join' expression or to the left of the keyword 'with'. This is described in The Axiom book, APPENDIX B. GLOSSARY, especiall page #1064, headings: 'category' and 'Category'. Also page #1083, headings 'type' and 'Type'. Refer also to 'domain' and 'attribute' in this section. OpenAxiom still has some oddities inherited from Axiom. For example, although as you pointed out Category is formally defined in the OpenAxiom library and you can write: (3) > x := IntegerNumberSystem (3) IntegerNumberSystem Type: Category but this fails: (4) > x:Category := IntegerNumberSystem Category is a category, not a domain, and declarations require domains. and one can also write: (4) > Integer has Category (4) true Type: Boolean Given this dual personality of Category, your earlier comment about the use of 'Domain' to define domains in SPAD also makes sense to me. In fact, in the OpenAxiom interpreter one can write: (5) > I:Domain:=Integer (5) Integer Type: Domain (6) > i:I := 1 (6) 1 Type: Integer By analogy in SPAD I think it might also be useful to be able to write (for example): NewInteger():Domain with <public> == Integer add <private> Here 'Domain' would refer to the category expression from the domain to the left of the keyword 'add'. It is a little awkward to extend domains in this way now in Axiom because there is currently no way to directly reference the category of a domain. Regards, Bill Page. 
From: Ralf Hemmecke <ralf@he...>  20080618 11:53:49

On 06/18/2008 01:37 PM, Bill Page wrote: > On 6/18/08, Ralf Hemmecke wrote: >> ... >> Bill Page wrote: >>> That category that plays this role in Axiom is called Type >>> (1) > )sh Type >>> Type is a category constructor >> Hmmm, maybe I mix again Aldor and SPAD... >> >> See section 7.7 AUG: >> Type: A type S satisfies the languagedefined type Type if S is >> the type of a domain or category. In other words, all domains >> and categories are types. >> >> Is this really different for SPAD? (I am not saying anything about the >> interpreter.) > > No, I think it is the same. Both domains and categories satisfy Type, e.g. > > (1) > SetCategory has Type > > (1) true > Type: Boolean > (2) > Integer has Type > > (2) true > Type: Boolean See AUG page 96: Has expressions A "has" expression has the following form: dom has cat where dom is a domainvalued expression, and cat is a categoryvalued expression. So at least "has" is different in the Axiom interpreter or in SPAD. %8 >> Cat:Category == with; %11 >> Integer () @ Join( PrimitiveType with coerce: BInt > % coerce: % > BInt == add () , IntegerType with export to IntegerSegment(%) == add () ) %12 >> Integer has Cat F @ Boolean %12 >> Integer has Cat F @ Boolean Comp: 0 msec, Interp: 160 msec %13 >> PrimitiveType has Cat ^ [L18 C1] #1 (Error) No meaning for identifier `PrimitiveType'. There is actually a hidden bug in the List constructor if it works over categories. L: List OutputType := [Integer, String] because the List constructor is defined as something like List(T: Type): with { if T has Output then ... } == add { ... } and that is undefined according to the AUG if T is a category. Ralf 
From: Bill Page <bill.page@ne...>  20080618 11:37:26

On 6/18/08, Ralf Hemmecke wrote: > ... > Bill Page wrote: >> That category that plays this role in Axiom is called Type > >> (1) > )sh Type >> Type is a category constructor > > Hmmm, maybe I mix again Aldor and SPAD... > > See section 7.7 AUG: > Type: A type S satisfies the languagedefined type Type if S is > the type of a domain or category. In other words, all domains > and categories are types. > > Is this really different for SPAD? (I am not saying anything about the > interpreter.) No, I think it is the same. Both domains and categories satisfy Type, e.g. (1) > SetCategory has Type (1) true Type: Boolean (2) > Integer has Type (2) true Type: Boolean > Is there a definition for SPAD somewhere besides the one > given by ")sh Type"? > I wish ... >> But the structure of Type is quite different than the structure of a >> domain. > > Sorry I don't know about the internals. > I meant the logical structure. Regards, Bill Page. 
From: Ralf Hemmecke <ralf@he...>  20080618 11:01:05

> But in this case unless we assert it, not every domain has Domain. That's true, but the only thing that must be extended is a few basic categories like, for example SetCategory. > Declaring X:Domain or X:Domain with ..., or X:Join(Domain, ...) is > just making this assertion. It does not provide X with the > characteristics of an "object", which by definition is an instance of > some domain. > That category that plays this role in Axiom is called Type > (1) > )sh Type > Type is a category constructor Hmmm, maybe I mix again Aldor and SPAD... See section 7.7 AUG: Type: A type S satisfies the languagedefined type Type if S is the type of a domain or category. In other words, all domains and categories are types. Is this really different for SPAD? (I am not saying anything about the interpreter.) Is there a definition for SPAD somewhere besides the one given by ")sh Type"? > But the structure of Type is quite different than the structure of a domain. Sorry I don't know about the internals. Ralf 
From: Bill Page <bill.page@ne...>  20080618 10:38:52

On Wed, Jun 18, 2008 at 3:15 AM, Ralf Hemmecke wrote: > ... > I must admit that I like the idea of Saul Youssef > http://physics.bu.edu/~youssef/homepage/talks/categories/21.html > > Domain: Category == with; > > An object X: Domain would be called a "domain" that is similar > to C: Category where we call C a category (in the Aldor sense). > But in this case unless we assert it, not every domain has Domain. Declaring X:Domain or X:Domain with ..., or X:Join(Domain, ...) is just making this assertion. It does not provide X with the characteristics of an "object", which by definition is an instance of some domain. That category that plays this role in Axiom is called Type (1) > )sh Type Type is a category constructor Abbreviation for Type is TYPE This constructor is exposed in this frame. Issue )edit /usr/local/lib/openaxiom/i386pcsolaris2.10/1.2.020080528/src/algebra/TYPE.spad to see algebra source code for TYPE  Operations  No exported operations When treated as values, all domains and categories must belong to some domain that provides as a minimum at least a coercion of these values to OutputForm. E.g. (1) > x:=SetCategory (1) SetCategory Type: Category (2) > y:=Integer (2) Integer Type: Domain (3) > )show Category Category is a domain constructor Abbreviation for Category is CATEGORY This constructor is not exposed in this frame. Issue )edit /usr/local/lib/openaxiom/i386pcsolaris2.10/1.2.020080528/src/algebra/CATEGORY.spad to see algebra source code for CATEGORY  Operations  coerce : % > OutputForm (3) > Category has Type (3) true Type: Boolean (4) > )sh Domain Domain is a domain constructor Abbreviation for Domain is DOMAIN This constructor is not exposed in this frame. Issue )edit /usr/local/lib/openaxiom/i386pcsolaris2.10/1.2.020080528/src/algebra/DOMAIN.spad to see algebra source code for DOMAIN  Operations  coerce : % > OutputForm reflect : ConstructorCall > % reify : % > ConstructorCall showSummary : % > Void (4) > Domain has Type (4) true Type: Boolean I think that what Saul is saying about Domain can be applied to Type. The idea is that Type can be viewed as a mathematical category whose objects (in the categorical sense) are domains and whose morphisms are Axiom functions. We get Product, Union and Exponentiation for free. I think it makes sense to claim that Axiom also provides a Natural Numbers Object (e.g. PositiveInteger) and subobjects (subdomain and Boolean), although their connection to category theory is not so well developed. So a strengthened form of Saul's thesis would be that Type is a Topos. But the structure of Type is quite different than the structure of a domain. > Oooops, now I see that Gaby has also written in domain.spad.pamphlet: > > Category(): Public == Private where > Public ==> CoercibleTo OutputForm > Private ==> add > coerce x == > outputDomainConstructor(x)$Lisp > > Isn't "Category" part of the SPAD language? I am a bit confused > and unfortunately the documentation in that file does not help me > out. There is at least a reference to "further reading" missing. > Yes. Category is the domain of categories, i.e. categories as values. Category constructors create these values. Operations like 'Join' and 'with' also construct new categories from old categories thereby defining the category lattice. Type is the top category in this lattice. > What I see in syntax.spad.pamphlet all looks like adding reflection > to SPAD. Is that the intention? Anyway I find > > Category(): Public == Private where ... > > somewhat confusing without any proper explanation of why it can and > should be done this way. > Since we want to treat all Types as firstorder objects I do not see any other possibilities. The only extension of this that I can imagine is to allow "domain comprehension". By that I mean that we could also treat categories as subdomains of Domain. Then writing X:C := D where C is a category, could denote those domains that satisfy C Union(d for d in Domain  d has C) E.g. X:IntegerNumberSystem := Romain but right now this still returns an error (5) > X:IntegerNumberSystem:=Roman IntegerNumberSystem is a category, not a domain, and declarations require domains. Regards, Bill Page.b 
From: Ralf Hemmecke <ralf@he...>  20080618 07:15:56

http://axiomwiki.newsynthesis.org/428EquationDomainCoerceToOutputFormAndBoolean On 06/17/2008 11:56 PM, Bill Page wrote: > Putting 'Domain' in 'SetCategory' is one possible solution to this problem: > \begin{spad} > )abbrev domain DOMAIN Domain > ++ Author: Gabriel Dos Reis > ++ Date Create: October 18, 2007. > ++ Modified: Bill Page > ++ Date Last Updated: June 17, 2008. > ++ Basic Operations: coerce, reify > ++ Related Constructors: Type, Syntax, OutputForm > ++ Also See: Type, ConstructorCall > Domain(): Public == Private where > Public ==> SetCategory with ... > Private ==> add ... I must admit that I like the idea of Saul Youssef http://physics.bu.edu/~youssef/homepage/talks/categories/21.html Domain: Category == with; An object X: Domain would be called a "domain" that is similar to C: Category where we call C a category (in the Aldor sense). Oooops, now I see that Gaby has also written in domain.spad.pamphlet: Category(): Public == Private where Public ==> CoercibleTo OutputForm Private ==> add coerce x == outputDomainConstructor(x)$Lisp Isn't "Category" part of the SPAD language? I am a bit confused and unfortunately the documentation in that file does not help me out. There is at least a reference to "further reading" missing. What I see in syntax.spad.pamphlet all looks like adding reflection to SPAD. Is that the intention? Anyway I find Category(): Public == Private where ... somewhat confusing without any proper explanation of why it can and should be done this way. Ralf 
From: Bill Page <bill.page@ne...>  20080611 13:02:56

On Wed, Jun 11, 2008 at 7:15 AM, Ralf Hemmecke wrote: > > is there somewhere a short summary that helps to understand .boot files? > > What does, for example, the colon in > > axFormatOpList ops == ['Sequence,:[axFormatOp o for o in ops]] > > stand for? > Have you taken a look at? http://axiomwiki.newsynthesis.org/BootProgramming In particular refer to the link: Boot Language http://axiomwiki.newsynthesis.org/axiomtest1/src/boot/Makefile It would appear the 'axFormatOpList' is a function that appends the symbol 'Sequence to the beginning of the list 'ops'. Regards, Bill Page. 
From: Ralf Hemmecke <ralf@he...>  20080611 11:15:47

Hello, is there somewhere a short summary that helps to understand .boot files? What does, for example, the colon in axFormatOpList ops == ['Sequence,:[axFormatOp o for o in ops]] stand for? Ralf 
From: Ralf Hemmecke <ralf@he...>  20080609 21:19:24

The file xpoly.spad.pamphlet (LIECAT.spad) contains LieAlgebra(R: CommutativeRing): Category == Module(R) with attributes NullSquare JacobiIdentity ... but I don't see NullSquare or JacobiIdentity listed in src/interp/daase.lisp. Actually, I should ask: why is *attributes* hardcoded in daase.lisp? Shouldn't that be inferred from the .spad files? And what is the relation to the AttributeRegistry in /src/algebra/attreg.spad.pamphlet? What should be considered the original source? Ralf 
From: Arthur Ralfs <arthur@ma...>  20080605 00:10:10

Tim, Waldek, Gaby, Thank you very much for allaying my fears about creeping aldorization. Arthur 
From: Gabriel Dos Reis <gdr@cs...>  20080604 22:13:20

Arthur Ralfs <acralfs@...> writes:  Tim, Waldek, Gaby,   It should be clear by now that I am only interested in working  with software which is completely free in the sense of Stallman.  For this reason I have not touched aldor.   This recent quote from Tim has me concerned:    "If we were to rethink by recoding it would make a lot more sense  to rewrite the algebra into Aldor."    so I put the question if any of you are 100% committed to maintaining  your project as a free software project. I do not object to supporting  aldor  for the end user but I will not continue using axiom/fricas/openaxiom if  aldor becomes an essential component. OpenAxiom is a free software and will remain so. OpenAxiom is under the BSD license and will remain so. OpenAxiom will support libraries written in Aldor, but OpenAxiom's own algebra will not depend on Aldor.  Gaby 
From: Arthur Ralfs <arthur@ma...>  20080604 20:08:40

Tim, Waldek, Gaby, It should be clear by now that I am only interested in working with software which is completely free in the sense of Stallman. For this reason I have not touched aldor. This recent quote from Tim has me concerned: "If we were to rethink by recoding it would make a lot more sense to rewrite the algebra into Aldor." so I put the question if any of you are 100% committed to maintaining your project as a free software project. I do not object to supporting aldor for the end user but I will not continue using axiom/fricas/openaxiom if aldor becomes an essential component. Arthur 
From: Gabriel Dos Reis <gdr@in...>  20080603 22:52:04

 Forwarded message  From: "David Joyner" <wdjoyner@...> To: axiommath <axiommath@...>, fricasdevel@..., openaxiomdevel@... Date: Tue, 3 Jun 2008 18:08:39 0400 Subject: Axiom survey article Hi: I'm told my SIGSAM Bull (now called Comm in Comp Alg) survey on Axiom will appear very soon. The latest version (which is a year old) is at http://sage.math.washington.edu/home/wdj/sigsam/oscascca2.pdf I know there are several updates which should be made but I wanted to email the axiom/fricas/openaxiom lists in case anyone has suggestions or announcements they wanted included. Please let me know ASAP if you do, since I only have today and tomorrow to make changes.  David Joyner 
From: Waldek Hebisch <hebisch@ma...>  20080602 23:32:12

Ralf Hemmecke wrote: > > src/interp/ax.boot > > contains the function > > makeAxExportForm(filename, constructors) == <snip> > > PS: Why is there a parameter "filename" if it is not used in the > function? (Well I don't understand boot, so that may be a stupid question.) > Above makeAxExportForm is makeAxFile which is almost identical to makeAxExportForm but prints the result to a file (named by the filename argument).  Waldek Hebisch hebisch@... 