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,b  nat; 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,s 1,s 2,s 3  string; 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:  string make: alphabet  string concat: string string  string ladd: alphabet string  string radd: string alphabet  string size: string  nat eqns:d  alphabet, s,s 1,s 2,s 3  string; concat(s,empty) = s concat(empty,s) = s ladd(n,s)= concat(make(n),s) radd(s,n)= concat(s,make(n)) size(empty) = zerus size(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árt osztályának manifesztuma algebrák közötti homomorfizmus Interface = formális rész + tartalmi rész; d a = ( , E);

Szignatúra:  = (S, OP), S: szortok halmaza; OP: konstans és operációs szimbólumok halmaza; OP = K s  OP w,s ; s  S; K s konstans szimbólumok halmaza; OP w,s operációs szimbólumok halmaza; w argument szort, w  S + ; s eredmény szort s  S; K s ; OP w,s páronként diszjunktak. K =  K s ; s  S N  K s ; N:  S; OP+ =  OP w,s ; w  S +, s  S; N  OP w,s, w = s 1...s n ; N = s 1...s n  s; OP = = K  OP + ;

Adott  = (S,OP) szignatúrához tartozó  - algebra (totális algebra). A = (S A,OP A ); S A = (A s ) s  S, A s, A  -algebra bázishalmazai -Minden N  K s : N :  s, s  S konstans szimbólumra A(N :  s) : N A :  A s ; -Minden N: s 1...s n  s  OP; s 1...s n  S + ; s  S műveleti szimbólumra: A(N A : s 1...s n  s): N A : A s 1,...,A s n  A s ; Ha  = (S 1,...,S n, N 1,...,N m ); akkor A = (A s 1,...,A s n, N A 1,...,N A m ); 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:alphabet bintree oprs:leaf: alphabet  bintree left: bintree alphabet  bintree right: alphabet bintree  bintree both: bintree alphabet bintree  bintree end bintree base; Zilles, S. N. MIT Report Szemantika felírása: kifejezéseket kell felírni!

Term: Term szintaktikai definíciója. Adott  = (S,OP); X s a szignatúrához tartozó változó. T  (X) = (T  (X),s ) s  S definíciója: Bázis termek: - X s  T  (X),s ; - n :  s  OP; akkor n  T  (X),s ; Összetett termek: n : s 1...s k  s, k  1, n  OP, t i  T  (X),s, 1  i  k; n(t 1,...,t k )  T  (X),s ; T  (X) más jelölései: T OP(X) ; T  (X) ; T  (X) ; T  ; T OP ;

Változó: Adott SIG = (S,OP), Az s szorthoz tartozó változók halmaza: X s, s  S. A SIG szignatúrához tartozó változók halmaza: X =  X s, s  S Deklaráció: x, y  X s ; Jelölésünk: eqns: x, y  s; Példa:  = (S,OP); S= {nat, bool}; Deklaráció: n, m  X nat ; a, b, c  X bool Jelölés: eqns: n,m  nat; a,b,c  bool;

Példa. nat 0 is a type specification = sorts: nat 0 oprs: 0:  nat 0 succ: nat 0  nat 0 prec: nat 0  nat 0 eqns: n  nat 0 ; prec(succ(0)) = "undefined" prec(succ(n)) = n end nat 0 ; 0  T nat 0 ; n  T nat 0 ; succ(k)  T nat 0 ; k = 0,1,2,... prec(k)  T nat 0 ; k = 0,1,2,... Példa: bintree. T alph = {k 1,...,k n }; Minden a  T alph : leaf(a)  T bin ; Ha t 1,t 2  T bin ; akkor minden a  alph : left(t 1,a)  T bin ; right(a,t 1 )  T bin ; both(t 1,a,t 2 )  T bin ;

A term kiértékelése. Adott  = (S,OP); és TOP; Legyen A egy  -algebra. eval: T op  A kiértékelés rekurzív definíciója: eval(N) = N A ; minden N  K esetén; eval(N(t 1,...,t n )) = N A (eval(t 1 ),...,eval(t n )), minden N(t 1,...,t n )  T op esetén. Kiterjesztett értékadás: Adott  = (S,OP); a szignatúrához tartozó X változókkal, T op ; Legyen A egy  -algebra. Adott ass: X  A, ahol ass(x)  A s, x  X s, s  S; ass: T op (x)  A; kiterjesztett értékadás definíciója: ass(x) = ass(x), minden x  X változóra; ass(N)= N A, minden N  K konstans szimbólumra; ass(N(t 1,...,t n )) = N A (ass(t 1 ),...,ass(t n )), minden N(t 1,...,t n )  T op (X) termre;

Példa: 1.) Adva nat1 = nat0 + oprs: add: nat nat  nat Kiértékelés a IN természetes számok kö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,R  TOP, s(X), s  S mellett egyenletnek nevezzük. Helyes egyenlet. Az e = (X,L,R) egyenlet helyes a A  -algebrában, ha minden ass : X  A esetén: ass(L) = ass(R) Specifikáció. SPEC = (S,OP,E);  = (S, OP); E = {e(x,L,R)};  x  X, 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 = sorts: ; oprs: ; eqns: export = type sort: ; oprs: ; eqns: ;... 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= {f c1,...,f ck, f s1,...,f s/ } ; f c1,...,f ck : konstrukciós műveletek; Pl. halmaz: empty, insert; f 0 :  A 0 ; pl. empty:  set; f c : A 0  A 1 ...  A n  A 0 ; pl. insert: set  elem  set; f s1,...,f s/ : nem konstrukciós műveletek; pl. has:set elem  bool; Axióma:f s (f c (a)) = h(a); Pl. has(insert(s,e),e) = "true"; has(insert(s,e 1 ),e 2 ) = if e 1 = e 2 then "true" else has(s,e 2 ) fi;  (a)  fs(fc(a)) = h(a);

Korlátozás: (A,F,E); A = A 0,A 1,...,A n );A 0 = {a | l(a)}; Attribútum függvény: attr(a), Pl. size(s); length(s); l(a) : 0  attr(a)  n; n  0; A 0 elemei: a 1 = f 0, a 2 = f c (a 1 ), a 3 = f c (a 2 ),... Korlátozás axiómája, az értelmezési tartomány meghatározása: a i  A 0  (0  attr(a i )  n);~(a i  A 0 )  attr(a i )  n; attr(f c (a))  n  f c (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 = ( S A, OP A ) és B = ( S B, OP B ). A h : A  B homomorfizmus egy függvénycsalád h = ( h s ) s  S, Itt: hs : S A  S B, úgy, hogy: minden N:  s  OP és s  S konstans szimbólumra: h s (N A ) = N B ; minden N: s 1... s n  s  OP és minden i = 1,...,n -re és a i  A si esetén: h s ( N A (a 1,..., a n )) = N B ( h s1 (a 1 ),..., h sn (a n ) ). (homomorfikus feltétel).

Az f: A  B homomorfizmust izomorfizmusnak nevezzük, ha minden f s : A  B függvény minden s  S-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 h s izomorfizmus, akkor h s -1 is az.

Példa izomorfizmusra.  =(S,OP); OP = { k1 :  S, k 2 :  S, N 1 : S  S; N 2 : 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.