alphabet is a type specification =

sorts: alphabet

oprs: a: alphabet, . . . ,z: alphabet

end alphabet;

nat is a type specification =

sorts: nat

oprs: zerus: nat

succ: nat nat

add: nat nat nat

eqns: a,bnat;

add(a,b) = add(b,a)

add(a,zerus) = a

add(a, succ(b)) = succ(add(a,b))

end nat;

string(alphabet) is a type specification = alphabet +

sorts: string

oprs:

empty: string

make: alphabet string

concat: string string string

ladd: alphabet string string

radd: string alphabet string

eqns: x alphabet, s,s1,s2,s3string;

concat(s,empty) = s

concat(empty,s) = s

ladd(x,s)= concat(make(x),s)

radd(s,n)= concat(s,make(n))

end string;

string(alphabet, n: nat) is a type specification = parameters = alphabet + nat + exports = type sort: string

oprs: empty: stringmake: alphabet stringconcat: string string stringladd: alphabet string stringradd: string alphabet stringsize: string nat

eqns: d alphabet, s,s1,s2,s3string;

concat(s,empty) = sconcat(empty,s) = sladd(n,s)= concat(make(n),s)radd(s,n)= concat(s,make(n))size(empty) = zerussize(add(n,s)) = succ(size(s))size(add(n,s)) > n ladd(n,s) = " undefined "

end string;

Paraméterek szerepei az algebrák specifikációjában:

Objektum felépítése;

Korlátozás;

Objektum kiértékelése;

Kiértékelés.

Például:

alphabet = bool +

sorts: alphabet

opns : : alphabet alphabet bool [infix]

eq : alphabet alphabet bool

eqns: x,y,z alphabet

...

end alphabet;

Adattípus univerzális algebrai modellje.

obj

Interface

adattípus

absztrakt adattípus

adattípus konkretizálása

univerzális algebra

algebrák izomorfizmusra zártosztályának manifesztuma

algebrák közötti homomorfizmus

Interface = formális rész + tartalmi rész;

da = ( , E);

Szignatúra: = (S, OP), S: szortok halmaza; OP: konstans és operációs szimbólumok halmaza;

OP = Ks OPw,s ; s S;

Ks konstans szimbólumok halmaza;

OPw,s operációs szimbólumok halmaza;

w argument szort, w S+; s eredmény szort s S;

Ks ; OPw,s páronként diszjunktak.

K = Ks ; s S N Ks ; N: S;

OP+ = OPw,s ; w S+ , s S;

N OPw,s, w = s1...sn; N = s1...sn s;

OP = = K OP+;

Adott = (S,OP) szignatúrához tartozó - algebra (totális algebra).

A = (SA,OPA);

SA= (As )sS , As, A -algebra bázishalmazai

- Minden NKs : N : s , sS konstans szimbólumra

A(N : s) : NA : As;

- Minden N: s1...sn s OP; s1...sn S+; sS műveleti

szimbólumra: A(NA: s1...sn s): NA: As1

,...,Asn As;

Ha = (S1,...,Sn , N1,...,Nm); akkor A = (As1,...,Asn

, NA1,...,NAm

);

Példa. Szignatúra: = ({S1, S2}, {N1: S1 S2, N2: S2 S1 S2,

N3: S1 S2 S2, N4: S2 S1 S2 S2});

-algebra: A = ({alphabet, bintree}; {leaf : alphabet bintree,

left : bintree alphabet bintree, right : alphabet bintree bintree,

both : bintree alphabet bintree bintree});

Algebrai felírás formája:

Példa:bintree-base =

sorts: alphabetbintree

oprs: leaf: alphabet bintreeleft: bintree alphabet bintreeright: alphabet bintree bintreeboth: bintree alphabet bintree bintree

end bintree base;

Zilles, S. N. MIT Report 1974.

Szemantika felírása: kifejezéseket kell felírni!

Term:

Term szintaktikai definíciója.

Adott = (S,OP); Xs a szignatúrához tartozó változó.

T(X) = (T(X),s)sS definíciója:

Bázis termek:

- Xs T(X),s;

- n : s OP; akkor n T(X),s ;

Összetett termek:

n : s1...sk s, k1, n OP, ti T(X),s , 1ik;

n(t1,...,tk) T(X),s ;

T(X) más jelölései: TOP(X) ; T(X) ; T(X) ; T ; TOP;

Változó: Adott SIG = (S,OP), Az s szorthoz tartozó változók halmaza: Xs, s S.

A SIG szignatúrához tartozó változók halmaza: X = Xs,

sS

Deklaráció: x, y Xs;

Jelölésünk: eqns: x, y s;

Példa:

= (S,OP); S= {nat, bool};

Deklaráció:

n, m Xnat ; a, b, c Xbool

Jelölés:

eqns: n,m nat; a,b,c bool;

Példa.

nat0 is a type specification =

sorts: nat0

oprs: 0: nat0

succ: nat0 nat0

prec: nat0 nat0

eqns: nnat0;

prec(succ(0)) = "undefined"

prec(succ(n)) = n

end nat0;

0 Tnat0 ; n Tnat0

;

succ(k) Tnat0 ; k = 0,1,2,...

prec(k) Tnat0 ; k = 0,1,2,...

Példa: bintree.

Talph = {k1, . . . ,kn}; Minden a Talph : leaf(a) Tbin;

Ha t1,t2 Tbin; akkor

minden aalph : left(t1,a) Tbin; right(a,t1) Tbin; both(t1,a,t2) Tbin;

A term kiértékelése.Adott = (S,OP); és TOP; Legyen A egy -algebra.

eval: TopA kiértékelés rekurzív definíciója:

• eval(N) = NA; minden NK esetén;

• eval(N(t1,...,tn)) = NA(eval(t1),...,eval(tn)), minden N(t1,...,tn)Top

esetén.

Kiterjesztett értékadás:Adott = (S,OP); a szignatúrához tartozó X változókkal, Top ;

Legyen A egy -algebra.Adott ass: XA, ahol ass(x) As, xXs, sS;

ass: Top(x) A; kiterjesztett értékadás definíciója:• ass(x) = ass(x), minden x X változóra;• ass(N)= NA , minden N K konstans szimbólumra;

• ass(N(t1,...,tn)) = NA(ass(t1),...,ass(tn)), minden N(t1,...,tn) Top(X)

termre;

Példa:

1.) Advanat1 = nat0 +oprs: add: nat nat nat

Kiértékelés a IN természetes számokkörében:

eval(add(succ(0),succ(0))) =

eval(succ(0)) + eval(succ(0)) =

(eval(0) + 1) + (eval(0) +1) =

(0+1) + (0+1) = 1+ 1 = 2.

Példa:

Adva X={n,m}

ass(n) = 1; ass(m) = 5.

ass (add(succ(n)), m)) = ?

ass (add(succ(n)), m)) = ass (succ(n)) + ass (m) =

(ass(n) + 1 ) + ass(m)) = (1 + 1) + 5 = 7.

Egyenletek.

Adott = (S,OP); a szignatúrához tartozó X változókkal.

Egyenlet:Az e = (X,L,R) hármast, L,RTOP, s(X), sS mellett egyenletneknevezzük.

Helyes egyenlet.Az e = (X,L,R) egyenlet helyes a A -algebrában, ha mindenass : X A esetén:

ass(L) = ass(R)

Specifikáció.SPEC = (S,OP,E);= (S, OP); E = {e(x,L,R)}; xX, L=R;X változók halmaza, L, R, termek a X-ből vett változókkal.

típus neve( paraméterek listája ) is a type specification =

parameters = < átvett aktuális típusnév1 > + . . . +

< átvett aktuális típusnévk> +

sorts: < formális paraméterek nevei >;

oprs: < műveletek formái >;

eqns: < műveletek jelentésének leírása >

export =

type sort: < típushalmaz neve >;

oprs: < műveletek formái >;

eqns: < műveletek jelentésének leírása >; ...

end típus neve;

műveletek jelentésének leírása =deklaráció + szemantikát leíró egyenletek

Szemantikát leíró egyenletek (axiómák):

L = R ;

L: baloldali term; R: jobboldali term.

OP= {fc1,...,fck, fs1,...,fs/} ;

• fc1,...,fck : konstrukciós műveletek;

Pl. halmaz: empty, insert;

f0: A0; pl. empty: set; fc: A0A1...AnA0;

pl. insert: setelem set;

• fs1,...,fs/ : nem konstrukciós műveletek;

pl. has:set elem bool;

Axióma: fs(fc(a)) = h(a); Pl. has(insert(s,e),e) = "true";

has(insert(s,e1),e2) = if e1= e2 then "true" else has(s,e2) fi;

(a) fs(fc(a)) = h(a);

Korlátozás: (A,F,E); A = A0,A1,...,An); A0 = {a | l(a)};

Attribútum függvény: attr(a), Pl. size(s); length(s);

l(a) : 0 attr(a) n; n 0;

A0 elemei: a1= f0, a2= fc(a1), a3= fc(a2), ...

Korlátozás axiómája, az értelmezési tartomány meghatározása:

ai A0 (0 attr(ai ) n); ~(ai A0) attr(ai ) n;

attr(fc(a)) n fc(a) = "undefined" ;

Pl.: size(insert(s,e)) n insert(s,e) = "undefined" ;

Korlátozás formális paraméterének deklarációja:

típus neve( par list, korl. dekl. ) is a type specification =

korl. dekl. változó : változó típusának neve Pl. set( elem, n:nat ) is a type specification = . . .

-algebrák közötti homomorfizmus.

Adva = ( S, OP ), A = ( SA, OPA ) és B = ( SB, OPB ).

A h : A B homomorfizmus egy függvénycsalád

h = ( hs )s S,

Itt: hs : SA SB,

úgy, hogy:

• minden N: s OP és sS konstans szimbólumra:

hs(NA) = NB ;

• minden N: s1 ... sn s OP

és minden i = 1, ...,n -re és aiAsi esetén:

hs( NA (a1, . . . , an)) = NB ( hs1(a1) , . . . , hsn(an) ).

(homomorfikus feltétel).

Az f: AB homomorfizmust izomorfizmusnak nevezzük,

ha minden fs: AB függvény minden sS-re bijektív.

Jelölés: f: A B.

Az A és B -algebrákat izomorfikusnak nevezzük, ha létezik

f: A B, vagy g: B A izomorfizmus:

Jelölés: A B.

Megjegyzések:

• Homomorfizmusok kompozíciója szintén homomorfizmus.

• Ha hs izomorfizmus, akkor hs-1 is az.

Példa izomorfizmusra.

=(S,OP); OP = { k1: S, k2: S, N1: S S; N2: S S S })

A = (bool, {T: bool, F: bool, ~_ : bool bool,

: bool bool bool [infix]});

B = (bit, {1: bit, 0: bit, ch : bit bit, : bit bit bit [infix]});

Egy adott szignatúrához tartozó absztrakt adattípus

a -algebrák egy olyan osztálya, amely

az izomorfizmusra zárt:

azaz

C Alg ( );

A C;

A B B C.