SOME PRIVATE REMARKS ON
ALGEBRAIC SPECIFICATION A LA EHRIG/MAHR


I. THE FREE CONSTRUCTOR REQUIREMENT 

The free constructor requirement for consistent extensions 
(we do not explain what this means and do this on purpose
 because we are dealing with a B. Gramlich-like meta-level
 which exists before it is defined)
of specifications
is the following:

For each consistent extension bigspec of a specification spec
and each element A in the (homomorphism) category of models of spec
there is an initial element (bigA, univ::A-->FORG_{Obj}(bigA))
in the category of objects FORG-under A.
Here FORG is the forgetful functor from the category of models of bigspec
to the category of models of spec.
This initality means that there is a single object in the category
of models of bigspec which adds least confusion and least junk to A.
 
Thus, the free constructor requirement has four main aspects:

1. (bigA, univ::A-->FORG_{Obj}(bigA)) 
   is semi-initial 
   in the category of objects FORG-under A.
   Semi-initial means: For each object (bigB, u::A-->FORG_{Obj}(bigB))
   there is at most one morphism 
   h :: (bigA, univ::A-->FORG_{Obj}(bigA)) --> (bigB, u::A-->FORG_{Obj}(bigB)).
   This is a kind of least-junk requirement for our free constructor.
   Semi-initiality is a very good idea.

2. (bigA, univ::A-->FORG_{Obj}(bigA)) 
   is minimal 
   in the category of objects FORG-under A
   w.r.t. the morphism quasi-ordering
   where an object a is smaller than another object b 
   iff there is a morphism m::a-->b.
   Together with (1.), this means that all objects smaller than
   (bigA, univ::A-->FORG_{Obj}(bigA)) are isomorphic to 
   (bigA, univ::A-->FORG_{Obj}(bigA)).
   This is a kind of least-confusion requirement for our free constructor.
   Minimality is a very good idea, too.

3. The free constructor provides only one object of the category of 
   of objects FORG-under A 
   that is minimum w.r.t. the morphism quasi-ordering
   instead of a covering set of minimal objects.
   Note that (3.) implies (2.), but while the latter is fine, 
   the former is dubious:
   If the extension of the specification allows some choices
   (e.g. a=b \vee c=d) and we have no means of establishing
   preference of one of the choices, then it is more appropriate to
   give a covering set of minimal (and semi-initial) objects FORG-under a.

4. The free constructor is always defined 
   (for each object A in the category of models of spec).
   this is a severe restriction:
   Maybe A wantonly identifies two domain objects UNDEFINED, CONSTRUCTOR.
   now this identification might break the neck of the free constructor for 
   two reasons:
   - the extension of the specification requires 
     UNDEFINED and CONSTRUCTOR to be unequal
   - our categories of models have an additional restriction
     (e.g. constructor-minimality) that cannot be 
     kept during extension because of this wanton identification; e.g.:
     the extension specifies UNDEFINED and CONSTRUCTORRRRRRRRRRRRRRRRR
     to be equal.


II. THE FREE FUNCTOR REQUIREMENT

As if the free constructor requirement was not strong enough,
Ehrig/Mahr add another requirement 
(obviously driven by their want for category theory),
namely that the free constructor 
(taking as object functor FREE_{Obj}(A):=bigA)
allows the addition of some morphism functor FREE_{Arr} that makes
FREE := (FREE_{Obj},FREE_{Arr}) a functor from the category of
models of spec to the category of models of bigspec 
having the following property:
If we add some confusion or junk to A yielding badA
via a morphism bad::A-->badA
then (uniquely) 
FREE_{Arr}(bad) adds the 
perfectly analogous confusion/junk to FREE_{Obj}(A) yielding FREE_{Obj}(badA);
FREE_{Arr}(bad) :: FREE_{Obj}(A) --> FREE_{Obj}(badA);
and by nattrans(A) := univ::A-->FORG_{Obj}(FREE_{Obj}(A))
we get a natural transformation from the identity functor of the category of
models of spec to the functor FREE.FORG
which means 
  bad.nattrans(badA) = nattrans(A).(FREE.FORG)_{Arr}(bad) .

What are the reasons for such a requirement?
-  Having (1.)-(4.) in (I.) above, 
   this is not a requirement but an implication.
-  ????????????????????????????????????????????????????????

If give up (3.) of (I.) there cannot be an analogon to a free functor.
This is shown in [Wolter], p. 355, where the problem shown up is essentially
the following:
Let bad::A-->badA; verybad::badA-->verybadA, where badA wantonly identifies
a and b.
Now for some of the associated morphism in the category of models of bigspec
there it may be that FREE_{Arr}(bad.verybad) cannot be split into
FREE_{Arr}(bad).FREE_{Arr}(verybad) because the identification of a and b
in badA forces FREE_{Obj}(badA) to identify x differently than chosen in
FREE_{Obj}(A), thereby making FREE_{Arr}(bad) impossible.