Kiterjesztések szemantikája: Szemantikai tartomány : Adatoknak, vagy értékeknek egy nem üres halmazát szemantikai tartománynak nevezzük. Jelölése: D. Egy eleme: d  D. Értelmezés (interpretáció): A D tartomány konstans elemeinek értelmezése egy l(c) leképezés, amely minden c konstanshoz hozzárendeli az l(c) értéket. Azt mondjuk a c jelentése, szemantikája: l(c). Egy rendszer szemantikai tartománya általában: D =  D T ; T : típus

Példa: D integer = {..., -1,0,1,...}; D boolean = {true, false}; D T1 ...  Tn  T = D T1 ...  D Tn  D T ; Az összes függvény halmaza, amelyek a D T1,...,D Tn halmazokból D T halmazra képeznek le. l(c) értelmezés: Az alaptípusok minden konstansa saját magának az értelmezett értéke: ha c alaptípusú, akkor l(c) = c. Példa: Az 1 integer konstans értelmezi az 1 integer számot. A true boolean konstans értelmezi a true boolean értéket.

Minden magasabb típusú konstansnak, amelyet op operációval előállítunk az értelmezése l(op). Példa:Boolean alaptípus. Legyen op: .  (true) = false;  (false) = true;

Állapotok. A konstans állapota annak értéke. A változó állapota annak mindenkori értéke. A változó mindenkori értékeit egy a szóba jöhető mindenkori értékeket tartalmazó halmazból veszi: set of proper states. Minden T típusú egyszerű és array változóhoz hozzárendelt értékek halmaza a mindenkori értékek: set of proper states. Jelölése: . Példa. Legyen  egy tömb. Típusa: integer  boolean  boolean; Legyen x egy integer típusú változó.

Példa. Legyen  egy tömb. Típusa: integer  boolean  boolean; Legyen x egy integer típusú változó.  (  ) : {...,-1,0,1,...}  {true, false}  {true, false}; x értékei: {...,-1,0,1,...}. Pl.:  (  )(1, true)  {true, false};  (  )(5,false)  {true, false}; (  x  {...,-1,0,1,...})(  (  )(  (x),false)  {true, false});

Szemantika definíciója. Egy T típusú s kifejezés szemantikája az S struktúrában (s  S) egy leképezés: S[  s  ] ;   D T ; ( s-hez rendeli az S[  s  ](  ) értéket D T halmazon belül). S[  s  ](  ) induktív definíciója. Ha s egyszerű változó: S[  s  ](  ) =  (s); Ha s egy alaptípusú konstans, amelynek értéke d. S[  s  ](  ) = d; Ha s  op(s 1,...,s n ), amelynek értékét f függvény adja: S[  s  ](  ) = f(S[  s 1  ](  ),...,S[  s n  ](  )); Ha s   [s 1,...,s n ], egy tömbváltozó: S[  s  ](  ) =  (  )(S[  s 1  ](  ),...,S[  s n  ](  ));

Ha s  if B then s 1 else s 2 fi egy feltételes elágazás: S[  s 1  ](  ) ha S[  B  ](  ) =T; S[  s  ](  ) = S[  s 2  ](  ) ha S[  B  ](  ) =T; Rövid jelölés: S[  s  ](  ) =  (s); Példa: (Ha s  op(s 1,...,s n ), amelynek értékét f függvény adja: S[  s  ](  ) = f(S[  s 1  ](  )),...,S[  s n  ](  )); Legyen a függvény: s  add(a,b); a,b  integer; S[  s  ](  ) = add(S[  a  ](  ),S[  b  ](  )) = add(a,b); s=a+b; S[  s  ](  ) = S[  a  ](  )+S[  b  ](  )) = (a+b);

Állapotok aktualizálása. Adva  állapot. Az állapot aktualizálása:  [u:=d]; u egy T típusú egyszerű változó, vagy indexes változó; d egy T típusú elem. Ha u egyszerű változó, akkor az eredmény d ha u  v,  [u:=d](v) =  (v) különben. Példa: x egy integer típusú változó,  megfelelő állapot.  [x:=1](x) = 1, Minden y =x esetén:  [x:=1](y) =  (y),

Ha indexes változókról van szó: u  A[t1,...,tn], akkor Egyszerű, vagy indexes: d; ha u  v  [u:=d](v) =  (v); ha u  v A-ra és az argumentum értékeire alkalmazandó. Jelölés: d =  (A), d i =  (t i ); minden i  {1,...,n};  [u:=d](A)(d 1,...,d n ) = d,ha d i =  (t i ); minden i  {1,...,n};  (A)(d 1,...,d n ); különben. Tehát a hatás az A tömb változónak az aktualizálása az argumentum változóknak az aktuálisa révén.

Példa. x  integer;  ;  [x:=1](x) =1; y=x:  [x:=1](y) =  (y); Hasonlóan: , amelynek típusa: T 1 ...  T n  T; és d i  D Ti, i  {1,...,n};  [x:=1](a)(d 1,...,d n ) =  (a)(d 1,...,d n );

Állítás, (assertion). Minden bool kifejezés állítás. Ha p,q állítás akkor  p, p  q, p  q, p  q, p  q szintén állítás. Ha x egyszerű változó és p(x) egy állítás, akkor  x:p(x);  x:p(x); szintén állítások. Relációk: , =, , , , . Relációkkal képezett kifejezések állítások. Error állapotok is állítások: , , fail; Benne foglaltatás, része, stb. is állítás: , , ,...

Példa. Legyen A bool típusú tömb: A : integer bool  bool; Legyen j,k  integer, b  bool, és  bool kifejezés. Ekkor logikai kifejezések a következők:   A[j+1, b];   A[ 2  j, A[k,~b]]; Alaphalmazok: (integer = {..., -1, 0, 1,2,...}; bool = {"true", "false"}, Az alaphalmazokon értelmezett szokásos kifejezések rekurzív definíciója: kifejezés e::= c  x  (e1 + e2)  (e1-e2)  (e1  e2); bool kifejezés b ::= (e1 = e2)  (e1  e2)  ~b  (e1  e2),

A p állítás szemantikája S[p] :   {true, false}; Jelölés: S[p](  ) : adott  mellett S[p] = true; {  p(  )  }; Röviden: {p(  )}; {p}; , , fail  {p}; Állítások szemantikája: {~p}=  \ {p}; {p  q}= {p}  {q}; {p  q}= {p}  {q}; p  q = true akkor és csak akkor, ha {p}  {q}; p  q = true akkor és csak akkor, ha {p} = {q}; S[p](  ) = true; helyett néha röviden:   p;

Behelyettesítés (substition). A behelyettesítés egy függvény, amely kifejezésről kifejezésre, állításról állításra képez le: Behelyettesítés: expression  expression; Legyen u egy egyszerű, vagy indexes változó, amely egy s kifejezés része. Az s kifejezésben az u helyettesítését a t kifejezéssel a következő jelöli: s[u:=t]. Példák: max(x,y)[x:=x+1]  max(x+1,y); max(a[1],y)[a[1]:=2]  max(2,y); max(a[x],y)[a[1]:=2]  if x=1 then max(2,y) else max(a[x],y) fi;

s[u:=t] formális definíciója. s  x, x egyszerű változó: t ha s  u; s[u:=t]  s különben; s  c, ahol c alaptípusú konstans: s[u:=t]  s; s  op(s 1,...,s n ): s[u:=t]  op(s 1 [u:=t],...,s n [u:=t]); s   [s 1,...,s n ]; ahol  tömb, u egyszerű, vagy indexes változó: s[u:=t]   [s 1 [u:=t],...,s n [u:=t]]; s  if B then s 1 else s 2 fi: s[u:=t]  if B[u:=t] then s 1 [u:=t] else s 2 [u:=t] fi;

Minden s, t kifejezésre, minden x egyszerű változóra és minden  (t 1,...,t n ) indexes változóra s[x :=t]  s ha s nem tartalmazza x-et; s[  (t 1,...,t n ) := t]  s ha s nem tartalmazza  -át; Példa. a,b integer  típusú tömbök és x integer típusú változó. a[b[x]][b[1]:=2] (def. s[u:=t] ha a=b) : a[b[x]][b[1]:=2]  (def. s[u:=t] alapján) a[if x[b[1]:=2] =1then 2 else b[x[b[1]:=2]] fi]  (x[b[1]:=2]  x szerint)  a[if x=1then 2 else b[x] fi];

A determinisztikus program: egy szimbólumokból képezett string. Kulcsszavak: if, then, else, fi, while, do, od. A programot generáló grammatika: S::= skip | u:= t | S 1 ; S 2 | if B then S 1 else S 2 fi | while B do S od. u: egyszerű, vagy indexes változó; t: kifejezés; u és t típusa megegyezik. B: kvantor-független logikai kifejezés; if B then S fi  if B then S else skip fi; Az S,S 1,S 2 programok változói: egyszerű, vagy indexes változók.

Az S determinisztikus program jelentése: A megfelelő (kezdő) állapotok halmazáról megfelelő (vég-)állapotok halmazára történő leképezés: M[S]. Hogyan definiáljuk? Denotációs szemantika-definíciós módszer. Operációs szemantika-definíciós módszer. (minden programtípusra kézenfekvő) Adva az absztrakt gép. Adva a program: S. Adva a megfelelő állapothalmaz: . Az absztrakt gép konfigurációja:  S,   ;  ; A program végrehajtása konfigurációk közötti átmenetek sorozata.

Konfigurációk közötti átmeneti reláció ( transition relation ):  Konfigurációk közötti átmenet: konf 1  konf 2  S,    R,  ; ,   ; R: maradék program; Befejeződés: A program végrehajtásának befejeződésének eredménye:  R,  ; R  E : üres program; A program befejeződik a  állapotban.