Dear all, (I'm sending this also to Bertfried, since he was interested at some point)
C Y writes: > > (Well, that is Aldor syntax, but I hope in can be understood.) > > Well, about as well as I understand Axiom's syntax... :-/. I might as well > ask this up front, and I'm sorry in advance if I missed something obvious > and/or am proving myself as intelligent as your average rock: Never ever say something like this. It is *good* to ask questions, and it is also good to ask stupid questions. Moreover, it is impossible to tell beforehand whether a question is stupid or not. In my opinion, there are no stupid questions. (The reason for my saying that stupid questions are good questions is that very likely 10 other people in the audience will secretely hope that somebody else will be asking their "stupid" questions. But noone dares.) Elsewhere you wrote: > I'm quite aware these [questions] are an indicator I haven't read and > understood something I need to, so if someone can point me to the correct > "Axiom for Dummies" file I'll be only too glad to fade away until I > understand it properly. PLEASE DON'T FADE AWAY. WE NEED YOU! ------------------------------------------------------------------------------- > Is there a tutorial or some such that takes a Category->Domains set of code > and dissects it essentially character by character, answering all the dumb > questions? There is the Aldor user guide: http://www.aldor.org/docs/HTML/index.html which is very thorough but maybe a little steep, so I think the following approach is better for a beginning: > Here are some of the ones floating around in my head which I don't know > quite how to answer at the moment. > Taking this example: > > Units(R: Field): Exports == Implementation where > U == Fraction Polynomial Integer > > 1) The syntax (R: Field) - what does this actually denote? R I guess is all > Rings? No. R is a identifier, a variable in the computer language sense. So the syntax is Name0(Name1: Type1, Name2: Type2, ...): NameA == NameB where and Type1, Type2, ... are Types like * Field, Ring, ... which are categories, in this case Name1 will be taken by axiom to denote a domain of category Type1. Example: ------------------------------------------------ Units(R: Field): Exports == Implementation where ------------------------------------------------ R will be some Field from now on. I.e., you can multiply, add and take inverses of the elements in R. * Integer, Polynomial Integer, PrimeField 5, ... which are domains, in which case Name1 will be taken by axiom to denote an element of Type1. Example: ----------------------------------------------------- SquareMatrix(ndim,R): Exports == Implementation where ndim : NonNegativeInteger R : Ring ----------------------------------------------------- ndim will be a NonNegativeInteger and R a Ring. A valid call would be 0$SquareMatrix(5, Polynomial Integer) which will give a 0 matrix of dimension 5 with entries (all zero) which are Polynomials with Integer coefficients. Note that you are allowed to put the type declaration also after the keyword "where". Another example ------------------------------------------------ PrimeField(p:PositiveInteger): Exp == Impl where ------------------------------------------------ Here p will be a PositiveInteger. A valid call would be characteristic()$PrimeField(5) an invalid call would be characteristic()$PrimeField(x) unless x *is* an integer at the time of evaluation. > 2) Exports == Implementation - what is actually being exported here, and > where is it being exported to? "Exports" and "Implementation" are just two identifiers. If you read the sources, you will sometimes also find Cat == Capsule or Cat == Definition It seems that writing Category == is reserved for categories. So the complete syntax is (incomplete, but useful) Name0(Name1: Type1, Name2: Type2, ...): NameA == NameB where NameA == with op1Declaration op2Declaration op3Declaration NameB == add op1Definition op2Definition op3Definition The keyword * "==" means: here comes a macro definition * ":" means: here comes a type declaration * ":=" means: here comes an assignment. So we could also write Name0(Name1: Type1, Name2: Type2, ...): with op1Declaration op2Declaration op3Declaration == add op1Definition op2Definition op3Definition except the indentation is then less clear. The keyword "with" means: here come declarations the user will see. Note that the with part may be missing. See below. The keyword "add" means: here come definitions, declarations and assignments the user will not see. > 4) What is the significance of "%" within a domain definition? It means: I am an element of this domain. > 5) ... > > If "Domains" are to be part of a "Category", what responsibilities do the > Domains have to a) label themselves as being part of a category This comes just before the "with" part. (If it is present...). An example is PrimeField(p:PositiveInteger): Exp == Impl where Exp ==> Join(FiniteFieldCategory,FiniteAlgebraicExtensionField($),_ ConvertibleTo(Integer)) Impl ==> InnerPrimeField(p) add if not prime?(p)$IntegerPrimesPackage(Integer) then error "Argument to prime field must be a prime" Thus: PrimeField will be an element of the categories FiniteFieldCategory, FiniteAlgebraicExtensionField($), and ConvertibleTo(Integer) (all quite reasonable, isn't it? "$" is the same as "%", as far as I know) It does not have any additional operations exported -- apart from the operations it inherits from FiniteFieldCategory, FiniteAlgebraicExtensionField and ConvertibleTo(Integer). > b) ... Can a Category demand certain abilities or actions be defined for a > Domain in order for it to be a legal part of the Category? Yes. ALL operations defined by the category must be implemented. However, you can define a default implementation in the category itself. For example: SemiGroup(): Category == SetCategory with --operations "*": (%,%) -> % ++ x*y returns the product of x and y. "**": (%,PositiveInteger) -> % ++ x**n returns the repeated product ++ of x n times, i.e. exponentiation. "^": (%,PositiveInteger) -> % ++ x^n returns the repeated product ++ of x n times, i.e. exponentiation. add import RepeatedSquaring(%) x:% ** n:PositiveInteger == expt(x,n) _^(x:%, n:PositiveInteger):% == x ** n Here you find a default declaration of taking the n-th power that is valid for SemiGroups. It will be overridden (i.e., implemented differently) by some domains, of course. > > The full blown thing would then be > > a category Units, that has as domains Mass, Time, Length, ... I > > suppose. > > From what little I do understand, I like this idea the best of any so far. > I would call the category Dimensions, since that's what Mass, Time and > Length denote - they are not units until a specific quantity like 1 kg, 1 > sec and 1 meter is defined. To define a * b where a is of domain Mass and b of domain Time you probably need the Product domain. The signature will be (I forgot to say: "++", "+++" and "--" are three different kinds of comments... )abb category DIM Dimension Dimension(F: Field): Category == with "+": (%, %) -> % ++ elements of units can always be added "*": (F, %) -> % ++ elements of units can always be multiplied with a scalar )abb package PRODDIM ProductDimension ProductDimension(A: Dimension, B: Dimension): Exports == Implementation where "*": (A, B) -> Product(A, B) But I'm not yet sure how you can define a / b where a is of domain Mass and b of domain Time... Martin _______________________________________________ Axiom-developer mailing list Axiom-developer@nongnu.org http://lists.nongnu.org/mailman/listinfo/axiom-developer
