1 / 20

alphabet is a type specification = sorts : alphabet oprs : a:  alphabet, . . . ,z:  alphabet

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

kanoa
Télécharger la présentation

alphabet is a type specification = sorts : alphabet oprs : a:  alphabet, . . . ,z:  alphabet

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 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;

  2. 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,s3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;

  3. 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,s1,s2,s3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;

  4. 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;

  5. Adattípus univerzális algebrai modellje. Interface obj adattípus univerzális algebra absztrakt adattípus algebrák izomorfizmusra zárt osztályának manifesztuma adattípus konkretizálása algebrák közötti homomorfizmus Interface = formális rész + tartalmi rész; da = ( , E);

  6. 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+;

  7. Adott  = (S,OP) szignatúrához tartozó  - algebra (totális algebra). A = (SA,OPA); SA= (As )sS , As, A -algebra bázishalmazai - Minden NKs : N :  s , sS konstans szimbólumra A(N :  s) : NA :  As; - Minden N: s1...sn  s  OP; s1...sn S+; sS 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});

  8. 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 1974. Szemantika felírása: kifejezéseket kell felírni!

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

  10. 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, sS 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;

  11. Példa. nat0is a type specification = sorts: nat0 oprs: 0:  nat0 succ: nat0 nat0 prec: nat0 nat0 eqns: nnat0; 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 aalph : left(t1,a)  Tbin; right(a,t1)  Tbin; both(t1,a,t2)  Tbin;

  12. A term kiértékelése. Adott  = (S,OP); és TOP; Legyen A egy -algebra. • eval: TopA kiértékelés rekurzív definíciója: • eval(N) = NA; minden NK 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: XA, ahol ass(x)  As, xXs, sS; • 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;

  13. 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.

  14. 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.

  15. 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

  16. 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: A0A1...AnA0; • pl. insert: setelem  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= e2then "true" else has(s,e2) fi; (a)  fs(fc(a)) = h(a);

  17. 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 = . . .

  18. -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 sS konstans szimbólumra: hs(NA) = NB ; • minden N: s1 ... sn s  OP • és minden i = 1, ...,n -re és aiAsi esetén: hs( NA (a1, . . . , an)) = NB ( hs1(a1) , . . . , hsn(an) ). (homomorfikus feltétel).

  19. Az f: AB homomorfizmust izomorfizmusnak nevezzük, ha minden fs: 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 hs izomorfizmus, akkor hs-1 is az.

  20. 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.

More Related