Re: [open-axiom-devel] understanding domain vectors, optimization etc.,

[Gabriel D. R. <gd...@cs...>]

Martin Rubey <mar...@un...> writes:

| Gabriel Dos Reis <gd...@cs...> writes:
| 
| > | So, my question is: how would you interpret an operation that is inherited from
| > | IndexedDirectProductAbelianGroup(R,S), when the representations are
| > | incompatible as they are here?
| > 
| > Of course when the data layout are not right, disaster.  But, that is beside
| > the fundamental point.  There are many domains that do not manipulate their
| > representations directly.
| > 
| > The fundamental point is that this particular semantics seriously inhibits
| > code reuse.  There is no way to extend a domain.  Spad seems to promote
| > copy-n-paste as way to add new domains.  That is contrary to established
| > software engineering practice.
| 
| Gaby, after some experiments, I could not find an example where "A add B", A
| and B sharing representation, exports an operation from A instead of from B,
| when the signature is present in both.

That is basically what my oiriginal example was about -- you just
needed to flip the component to match exact layout.  I'm reproducing
it below

)sys cat left.spad
)abbrev domain LFREEMOD LeftFreeModule
LeftFreeModule(R: Ring, S: OrderedSet):
     Join(LeftModule R, IndexedDirectProductCategory(R,S)) with
       linearCombination: List Pair(S,R) -> %
  == IndexedDirectProductAbelianGroup(R,S) add
    Rep == List Pair(S,R)
    linearCombination x ==
      per [u for u in x | second u ~= 0$R ]
    if R has EntireRing then
      (r: R) * (x: %) ==
        r = 0$R => 0$%
        r = 1$R => x
        messagePrint("from LeftFreeModule")$OutputForm
        per [pair(first u, r * second u) for u in rep x]
    else
      (r: R) * (x: %) ==
        r = 0$R => 0$%
        r = 1$R => x
        messagePrint("from LeftFreeModule")$OutputForm
        per [pair(first u,c) for u in rep x | (c := r *second u) ~= 0$R]
    coerce(x: %): OutputForm ==
      x' := rep x
      null x' => 0$R :: OutputForm
      res : List OutputForm := nil
      for u in reverse x' repeat
        second u = 1$R => res := cons(first(u)::OutputForm, res)
        res := cons(second(u)::OutputForm * first(u)::OutputForm, res)
      reduce("+",res)

)co left
x := 'x::OrderedVariableList ['x,'y]
x := 'y::OrderedVariableList ['x,'y]
2 * linearCombination([pair(x,2), pair(y,3)])


There is no 'from LeftFreeModule' printed out.

[...]

| In any case, I think that the compiler should complain when the Rep's don't
| match.

If you read the paper I referenced earlier, you'll see hat both BMT
and JHD have (had?) different opinions on this :-)

But, yes the compiler should warn about differing representations.
the problem is that in general, the cmpiler does not have that
information.  compounded by the heavy uses of `pretend'.

-- Gaby