Automaták És Formális Nyelvek II. - Dr. Hunyadvári László (2009)

1
Dr. Hunyadvari Laszl

o
Automaták és formális

nyelvek II.
Jegyzet programtervező matematikus és informatika tanári

szakos hallgatók számára
Technikai kivitelezés:
Tichler Krisztián
2
Jelen dokumentáció a Hunyadvári László egyetemi docens által a programtervező matematikus és informatika
tanári szakos hallgatók számára tartott Formális nyelvek és automaták 2. kurzus előadássorozata alapján
készült. Az anyag terjesztése, másolása engedélyezett, de a forrásállomány bárminemű változtatásának joga
kizárólagosan a szerzőket illeti meg.
Első kiadás, utolsó javı́tás dátuma: 2009. január 9.
Készült Donald E. Knuth TEX szövegszedő rendszerével.

Budapest, Eötvös Loránd Tudományegyetem, Informatikai Kar, 2009.
Tartalomjegyzék
1 K-korlátolt nyelvtanok, homomorfizmus lemma 2

1.1. Homomorfizmus lemma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. K-korlátolt nyelvtanok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3. Alkalmazások . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.3.1. Chomsky nyelvosztályok metszetre való zártsága . . . . . . . . . . . . 7
2 Programozott nyelvtanok 9
2.1. Előfordulásellenőrzés nélküli programozott nyelvtanok . . . . . . . . . . . . . 9
2.2. Előfordulásellenőrzéses programozott nyelvtanok . . . . . . . . . . . . . . . . 13
3 Mátrixnyelvtanok 23
4 Kontrollnyelvtanok 27
5 Indexelt nyelvtanok 30
6 Attribútumnyelvtanok 36
7 Kétszintű nyelvtanok 40
8 Párhuzamos nyelvtanok 43
8.1. Lindenmayer-rendszerek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
8.2. CD nyelvtani rendszerek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8.3. PC rendszerek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
1
1. K-korlátolt nyelvtanok,
homomorfizmus lemma
1.1. Homomorfizmus lemma
1.1. tétel. (Homomorfizmus lemma) Legyenek G1 = hT1 , N1 , P1 , S1 i és
G2 = hT2 , N2 , P2 , S2 i nyelvtanok. Legyen továbbá h : (T1 ∪ N1 ) → (T2 ∪ N2 )∗ homo-
∗
morfizmus, melyre
∗
1. minden p → q ∈ P1 esetén h(p) → h(q),
G2
2. h(T1 ) ⊆ T2∗ ,
3. h(S1 ) = S2 .
Ekkor h(L(G1 )) ⊆ L(G2 ).

∗
Bizonyı́tás. Először belátjuk, hogy ha α → β, akkor h(α) → h(β). Valóban, ha α → β,
G1 G2 G1
akkor létezik α1 , α2 ∈ (T1 ∪ N1 )∗ és p → q ∈ P1 , hogy α = α1 pα2 és β = α1 qα2 . Az 1.
feltétel és a homomorfizmus definı́ciója szerint
∗
h(α) = h(α1 pα2 ) = h(α1 )h(p)h(α2 ) → h(α1 )h(q)h(α2 ) = h(α1 qα2 ) = h(β).
G2
A fenti állı́tásból a levezetés hosszára vonatkozó egyszerű teljes indukcióval adódik, hogy
∗ ∗
ha α → β, akkor h(α) → h(β).
G1 G2
∗
Tegyük fel, hogy u ∈ L(G1 ), azaz S1 → u. Az előbbiek, valamint a 2. és 3. feltételek
G1
alapján
∗
S2 = h(S1 ) → h(u) ∈ T2∗ ,
G2
tehát h(u) ∈ L(G2 ). Mivel u tetszőleges volt, ezért h(L(G1 )) ⊆ L(G2 ). 2
1.2. K-korlátolt nyelvtanok

1.2. definı́ció. Egy G = hT, N, P, Si nyelvtanban egy
2
1. Példák 3
D : α0 → α1 → · · · → αn
G G G
levezetés munkaterülete, a levezetés leghosszabb mondatformájának hossza, melyet ws(D)-vel
jelölülünk, azaz
ws(D) := max `(αi ).

i=0,...,n
1.3. definı́ció. Legyen K ≥ 1 egész. A G nyelvtan K-korlátolt, ha minden u ∈ L(G)-hez

∗
van olyan D : S → u levezetés, melyre ws(D) ≤ K · `(u),
e ahol
G

1 ha u = ε
`(u)
e := .
`(u) ha u 6= ε
Jelölje a K-korlátolt nyelvtanok osztályát GKlb (K ≥ 1).
1.4. definı́ció. Egy L nyelv K-korlátolt, ha létezik olyan G ∈ GKlb nyelvtan, melyre
L(G) = L.
Jelölje a K-korlátolt nyelvek osztályát LKlb (K ≥ 1).

n
Példák L = {a2 | n ∈ N} ∈ L4lb .
Bizonyı́tás. A G = h{a}, {S, L, R, D, E}, {S → LEaR, Ea → aaE, aD → Daa, ER →

n
DR, LD → LE, LE → ε, DR → ε, L → ε, R → ε}, Si nyelvtanra L(G) = L. a2 egy D
levezetésére ws(D) = 2n + 3 = `(u) + 3 ≤ 4 · `(u) áll. 2
1.5. tétel. Ha L ∈ LKlb , akkor L ∪ {ε}, L \ {ε} ∈ LKlb .
Bizonyı́tás. Legyen G = hT, N, P, Si az L nyelvet generáló K-korlátolt nyelvtan (S 0 6∈ N ).

Ekkor a G0 = hT, N ∪ {S 0 }, P ∪ {S 0 → S | ε}, S 0 i nyelvtan szintén K-korlátolt és L(G0 ) =
L ∪ {ε}.
Legyen Pε = {p → q ∈ P| q = ε}. Továbbá minden P = p → ε ∈ Pε esetén legyen
PP = {Zp → Z, pZ → Z | Z ∈ T ∪ N }. Tekintsük a G00 = hT, N, P \ Pε ∪ P ∈Pε PP , Si
S
nyelvtant. L \ {ε} minden szavának egy G-beli levezetéséhez megfeleltethető egy olyan
levezetés G00 -ben, ahol a levezetés során kapott mondatformák ugyanazok, és ez G és G00
szerepét felcserélve is igaz. Tehát L(G00 ) = L \ {ε}, továbbá G00 is K-korlátolt, hiszen a
G-beli levezetésnek megfelelő G00 -beli levezetés ugyanazt a munkaterületet használja. 2
1.6. következmény. Ha ε 6∈ L, L ∈ LKlb , akkor létezik G ε-szabálymentes nyelvtan,

melyre G ∈ GKlb és L(G) = L.
Mivel GKlb ⊆ G(K+1)lb , ezért LKlb ⊆ L(K+1)lb (K ≥ 1).
1.7. tétel. Minden K ≥ 1 egész számra L1lb = LKlb .

4 1. K-korlátolt nyelvtanok, homomorfizmus lemma
Bizonyı́tás. A tétel előtti észrevétel alapján elegendő belátni, hogy LKlb ⊆ L1lb . Legyen
L ∈ LKlb . Feltehető, hogy ε 6∈ L, hiszen az 1.5 tétel szerint, ha ε-mentes nyelvekre igaz az
állı́tás, akkor L ∈ LKlb ⇒ L \ {ε} ∈ LKlb ⇒ L \ {ε} ∈ L1lb ⇒ L ∈ L1lb .
Legyen tehát G = hT, N, P, Si egy K-korlátolt nyelvtan, mely L-et generálja. 1.6
következmény szerint az is feltehető, hogy G-nek nincsenek ε-szabályai.
Legyen G0 = hT, N 0 , P 0 , Si, ahol N 0 = X ∪ Y , ahol X = {e α}α∈(T ∪N )K és Y =
{β}β∈ K (T ∪N )i . X elemeit hullámos, Y elemeit vonalas blokkoknak, mı́g X ∗ Y X ∗ elemeit
S
i=1
megengedett blokkosı́tásoknak nevezzük. Világos, hogy tetszőleges α ∈ (T ∪ N )∗ mondat-
formához van olyan ψe1 · · · ψer %ψer+1 · · · ψes megengedett blokkosı́tás, melyre
α = ψ1 · · · ψr %ψr+1 · · · ψs (általában több is van).
Továbbá legyen P 0 = P1 ∪ P2 ∪ P3 a következő szabályhalmaz.
P1 szabályai átblokkosı́tó szabályok.
0
αβe → α
e0 β ∈ P1 ⇔ αβ = α0 β 0 ,
βα
e → β0α
e0 ∈ P1 ⇔ βα = β 0 α0
Ezek a szabályok az ugyanahhoz az α ∈ (T ∪ N )∗ mondatformához tartozó megengedett
blokkosı́tások egymásba való átalakı́tására, átblokkosı́tására szolgálnak.
P2 szabályai a P-beli szabályoknak megfelelő blokkosı́tott szabályok.
τe1 · · · τe` γe
τ`+1 · · · τem → χ e1 · · · χ
ej δ χ
ej+1 · · · χ
er ∈ P2 ⇐⇒ létezik p → q ∈ P , hogy
p→q
τ1 · · · τ` γτ`+1 · · · τm −→ χ1 · · · χj δχj+1 · · · χr ,
G
továbbá p az összes τi -be belemetsz
(azaz τ1 · · · τ` γτ`+1 · · · τm = σ1 pσ2 és `(σ1 ) < K, `(σ2 ) < K.)
Végül P3 szabályai a deblokkosı́tó szabályok.
γ → γ ∈ P3 ⇔ γ ∈ T ∗ ,
te
γ → tγ ∈ P3 ⇔ t ∈ T, γ ∈ T ∗ ,
γ
et → γt ∈ P3 ⇔ t ∈ T, γ ∈ T ∗ .
Először belátjuk, hogy L(G0 ) ⊆ L(G). A h : (T ∪ N 0 )∗ → (T ∪ N )∗ homomorfizmust
T ∪ N 0 elemein a következőképpen definiáljuk.
PK
h(t) = t (t ∈ T ), h(eα) = α (α ∈ (T ∪ N )K ), h(β) = β (β ∈ i=1 (T ∪ N )i ).
A G0 , G nyelvtanokra és h homomorfizmusra teljesülnek a Homomorfizmus lemma (1.1
tétel) feltételei. Tehát
L(G0 ) = h(L(G0 )) ⊆ L(G).

Most lássuk be, hogy L(G) ⊆ L(G0 ). Legyen
D : S = α0 → α1 → · · · → αn = u
G G G
egy olyan levezetése az u szónak G-ben, melyre ws(D) ≤ K · `(u). Készı́tünk egy
1. Példák 5
∗ ∗ ∗ ∗
D0 : S = α00 →0 α10 →0 · · · →0 αn0 →0 u
G G G G
levezetést G0 -ben, melyre minden 0 ≤ i ≤ n esetén, ha αi0 = ψe1 · · · ψer %ψer+1 · · · ψes akkor
αi = ψ1 · · · ψr %ψr+1 · · · ψs .
Legyen α0 = S. Tegyük fel, hogy α0 = ψe1 · · · ψer %ψer+1 · · · ψes D0 -beli mondatforma és
0 i
αi = ψ1 · · · ψr %ψr+1 · · · ψs . Belátjuk, hogy G0 -ben levezethető egy olyan αi+1
0
mondatforma,
mely deblokkosı́tva éppen αi+1 -t adja.
Legyen αi = γ1 pγ2 , αi+1 = γ1 qγ2 és p → q ∈ P és készı́tsük el αi következő megengedett
blokkosı́tását:
αbi = βe1 · · · βe` τe1 · · · τes %e

τs+1 · · · τes0 βe`+1 · · · βe`0 ,
ahol p ⊆ τ1 · · · τs %τs+1 · · · τs0 és minden j ∈ {1, . . . , s0 }-re τj tartalmaz p-beli betűt. (αi
két végéről levágunk K hosszúságú szavakat addig, amı́g a következő vágással már belemet-
szenénk p-be. A levágott K hosszú szavak lesznek a βi -k, mı́g a közepét felbontjuk
τ1 · · · τs %τs+1 · · · τs0 alakban, ahol minden j ∈ {1, . . . , s0 }-re `(τj ) = K és `(%) ≤ K.) αbi
az előzőek szerint P1 szabályaival levezethető αi0 -ből.
Világos, hogy τe1 · · · τes %e
τs+1 · · · τes0 -re teljesülnek a P2 -beli szabályok baloldalára előı́rt
feltételek. Ezért a megfelelő P2 -beli szabály alkalmazásával αi+1 -hez tartozó blokkosı́tott
mondatformát kapunk, legyen ez az αi+1 0
.
∗ ∗
Tehát ha S → u, akkor S →0 v, valamely v ∈ (N 0 )∗ -ra, mely az u-nak egy blokkosı́tott
G G
változata. Innen P3 szabályaival levezethető G0 -ben u, tehát L(G) ⊆ L(G0 ).
Végül az 1-korlátoltság bizonyı́tásához elegendő belátni, hogy a fenti D0 levezetésre
ws(D0 ) ≤ `(u), azaz D0 minden α0 mondatformájára `(α0 ) ≤ `(u). Ezt a mondatforma
levezetésbeli indexére vonatkozó teljes indukcióval bizonyı́tjuk.
Ha α0 = α00 = S, akkor `(α0 ) = 1 ≤ `(u). A levezetés két részből áll. Az első részben
csak (P1 ∪ P2 )-beli szabályokat alkalmazunk, utána csak P3 -belieket.
Tegyük fel, hogy D0 : · · · →0 β 0 →0 α0 →0 · · · és β 0 -re igaz az állı́tás. Ha α0 -t β 0 -ből P1 -beli
G G G
szabály alkalmazásával kaptuk, akkor az indukciós feltevés szerint `(α0 ) = `(β 0 ) ≤ `(u). Ha
P2 -beli szabály alkalmazásával kaptuk α0 -t, akkor van olyan α mondatforma D-ben, melyre
ha α0 = χ e1 · · · χ
ej δ χ
ej+1 · · · χ
er akkor α = χ1 · · · χj δχj+1 · · · χr .
Mivel α0 -ben minden blokk hossza K legfeljebb egy kı́vétellel, ezért G K-korlátoltsága
miatt
`(α0 ) = d`(α)/Ke ≤ d(K · `(u))/Ke = `(u).

P3 -beli szabályokat csak a levezetés második részében, azaz akkor alkalmazunk, ha már u
egy blokkosı́tott formáját levezettük. Viszont ekkor a levezetésnek ez a már csak deblokkosı́tó
szabályokat alkalmazó része legfeljebb `(u) munkaterületet használ. 2
1.8. tétel. L1 = L1lb .

Bizonyı́tás. L1 ⊆ L1lb nyilvánvaló, hiszen ekkor egy L1 -beli nyelvet generáló nyelvtan-
ban egy nemüres szó levezetése során nem csökkenhet az aktuális mondatforma hossza, ı́gy
ilyenkor elegendő akkora munkaterület, mint az utolsó mondatforma, azaz a levezetett ter-
minális szó, hossza. Az ε szó egyetlen S → ε levezetésének a munkaterülete pedig 1, ami
éppen egyenlő `(ε)-val.
e Elegendő tehát belátni, hogy tetszőleges G = hT, N, P, Si ∈ G1lb
nyelvtanhoz létezik G ∈ G1 , hogy L(G0 ) = L(G).
0
A 1.7 tétel bizonyı́tásában látottakhoz hasonló érvelés alapján feltehető, hogy P-ben
nincsenek ε-szabályok, továbbá B 6∈ N .
Legyen G0 = hT, N ∪ {B}, P 0 , Si, ahol P 0 = P1 ∪ P2 ∪ P3 .
P1 szabályai a hosszat csökkentő P-beli szabályok jobboldalát annyi B-vel egészı́tik ki,
hogy a két oldal egyező hosszúságú legyen.
p → qB `(p)−`(q) ∈ P1 ⇔ p → q és `(q) < `(p).

P2 szabályai hosszat nem csökkentő P-beli szabályok esetén csökkenthetik a B-k számát.
pB j → q ∈ P2 ⇔ p → q és `(p) + j ≤ `(q).

A P3 -beli szabályokkal a B-k a megfelelő pozı́cióba cserélhetők.
ZB → BZ ∈ P3 (Z ∈ T ∪ N ),
BZ → ZB ∈ P3 (Z ∈ T ∪ N ).
Könnyen ellenőrizhető, hogy G0 ∈ G1 , azt kell csak belátni, hogy L(G0 ) = L(G).
Tekintsük azt a h : (T ∪ N ∪ {B})∗ → (T ∪ N )∗ homomorfizmust, melyre h(B) = ε és
h(Z) = Z (Z ∈ T ∪ N ). Minden G0 -beli szabály h-képe nyilván G-beli vagy a baloldalának
és a jobboldalának ugyanaz a képe valamint a Homomorfizmus lemma (1.1 tétel) további
feltételei is teljesülnek, tehát L(G0 ) = h(L(G0 )) ⊆ L(G).
Be kell még látni, hogy ha u ∈ L(G), akkor u ∈ L(G0 ). Ha u ∈ L(G), akkor létezik
olyan D : S = α0 → α1 → · · · → αn = u levezetés, melyre ws(D) ≤ `(u), azaz minden
G G G
j = 0, . . . n-re `(αj ) ≤ `(u).
Elkészı́tjük u-nak egy olyan D0 levezetését G0 -ben, melyre
∗ ∗ ∗
D0 : S = α0 B j0 →0 α1 B j1 →0 · · · →0 αn B jn (j0 = 0, jn = 0).
G G G
∗ ∗
S →0 α0 B j0 . Tegyük fel, hogy valamely 0 ≤ r ≤ n − 1 -re S →0 αr B jr .
G G
∗
Készı́tsük tehát el G0 -ben az αr B jr →0 αr+1 B jr+1 levezetést
G
Ha αr → αr+1 hosszúságot csökkentő szabállyal történt, akkor alkalmazzuk a szabálynak
G
megfelelő P1 -beli szabályt, majd a B-ket a P3 -beli szabályokkal vigyük a mondatforma
végére. Azaz, ha αr = γ1 pγ2 és αr+1 = γ1 qγ2 , továbbá `(p) > `(q), akkor
∗
αr B jr = γ1 pγ2 B jr →0 γ1 qB `(p)−`(q) γ2 B jr →0 γ1 qγ2 B jr +`(p)−`(q) = αr+1 B `(p)−`(q) .
G G
Ha αr → αr+1 hosszúságot nem csökkentő p → q szabállyal történt, akkor vigyünk mr
G
darab B-t közvetlenül p utánra, majd alkalmazzunk a megfelelő mr darab B-t elnyelő P2 -beli
1.3. Alkalmazások 7
szabályt, ahol mr = max{jr , `(q) − `(p)}. Azaz, ha αr = γ1 pγ2 és αr+1 = γ1 qγ2 , továbbá
`(p) ≤ `(q), akkor
∗
αr B jr = γ1 pγ2 B jr →0 γ1 pB mr γ2 B jr −mr →0 γ1 qγ2 B jr −mr = αr+1 B jr −mr .
G G
Állı́tás: minden 0 ≤ r ≤ n -re `(αr ) + jr ≤ `(u) teljesül.
Az állı́tás teljes indukcióval látható be. Mivel feltettük, hogy u 6= ε, ezért r = 0 -ra igaz
az állı́tás. (1 + 0 ≤ `(u)).
Tegyük fel, hogy `(αr ) + jr ≤ `(u). Belátjuk, hogy `(αr+1 ) + jr+1 ≤ `(u).
∗
Ha a αr →0 αr+1 levezetés során a p → q hosszat csökkentő szabálynak megfelelő P1 -beli
G
szabályt alkalmaztunk, akkor
`(αr+1 ) + jr+1 = (`(αr ) − `(p) + `(q)) + (jr + `(p) − `(q)) = `(αr ) + jr ≤ `(u).
∗
Ha az αr →0 αr+1 levezetés során a p → q hosszat nem csökkentő szabálynak megfelelő
G
P2 -beli szabályt alkalmaztunk, akkor mr = `(q) − `(p) esetén
`(αr+1 ) + jr+1 = (`(αr ) − `(p) + `(q)) + (jr − mr ) = `(αr ) + jr ≤ `(u),

ha viszont mr = jr , azaz jr+1 = jr − mr = 0, akkor a D G-beli levezetés 1-korlátoltsága
miatt ekkor is
`(αr+1 ) + jr+1 = `(αr+1 ) ≤ `(u),

amivel az állı́tást beláttuk.
Alkalmazzuk az állı́tást αn -re: `(αn ) + jn ≤ `(u). Mivel αn = u, ezért kapjuk, hogy
jn = 0, tehát a D0 levezetés G0 -ben éppen u-t vezeti le. 2
1.3. Alkalmazások
1.3.1. Chomsky nyelvosztályok metszetre való zártsága

Korábban láttuk, hogy L3 zárt a metszetre (***Formális nyelvek I. jegyzet 3.36 tétel***),
viszont L2 nem (***Formális nyelvek I. jegyzet 5.12 tétel***).
1.9. tétel. L0 és L1 zárt a ∩ műveletre.
Bizonyı́tás. Elég belátni, hogy tetszőleges G1 , G2 ∈ Gi (i = 0, 1) nyelvtanokhoz létezik

G∩ ∈ Gi , melyre L(G∩ ) = L(G1 ) ∩ L(G2 ).
Legyen G1 = hT1 , N1 , P1 , S1 i és G2 = hT2 , N2 , P2 , S2 i A nyelvtani jelek esetleges átne-
vezésével feltehető, hogy N1 ∩ N2 = ∅, továbbá, hogy T1 = T2 =: T (ugyanis tekinthetjük
őket T1 ∪ T2 feletti nyelvtanoknak). Tekintsük a G∩ = hT, N∩ , P∩ , Si nyelvtant, ahol N∩ =
N1 ∪ N2 ∪ {S, L} ∪ {Xt | t ∈ T } ∪ {Yt | t ∈ T }, P∩ = P 1 ∪ P 2 ∪ P 0 és P 0 = {S → LS1 S2 , L →
ε} ∪ {Xt1 Yt2 → Yt2 Xt1 | t1 , t2 ∈ T } ∪ {LXt Yt → tL | t ∈ T }. Továbbá P i -t úgy kapjuk Pi -

ből, hogy minden szabályban a terminálisokat a nekik megfelelő egyedi álterminális nyelvtani
jelre cseréljük, mégpedig P1 -ben t-t Xt -re, P2 -ben t-t Yt -re.
∗
L(G1 ) ∩ L(G2 ) ⊆ L(G∩ ). Ugyanis legyen u = t1 · · · tn ∈ L(G1 ) ∩ L(G2 ), tehát S1 → u és
G1
∗
S1 → u. Ekkor
G2
∗ ∗ ∗
S → LS1 S2 → LXt1 · · · Xtn S2 → LXt1 · · · Xtn Yt1 · · · Ytn →
G∩ G∩ G∩ G∩
∗ ∗
→ LXt1 Yt1 · · · Xtn Ytn → t1 · · · tn L → t1 · · · tn = u
G∩ G∩ G∩
L(G∩ ) ⊆ L(G1 ) ∩ L(G2 ) bizonyı́tásához készı́tsük el a hi : (T ∪ N∩ )∗ → (T ∪ Ni )∗
homomorfizmusokat (i = 1, 2), melyeket T ∪ N∩ elemein elegendő megadni.
Legyen hi (t) = t (t ∈ T ), hi (S) = Si , hi (A) = A (A ∈ Ni ), hi (Z) = ε (Z 6∈ T ∪ Ni ∪ {S}).
Mivel a hi homomorfizmus esetén a nem P i -beli szabályok baloldalának és a jobbol-
dalának ugyanaz a képe és P i -beli szabályok képe Gi -beli szabály, ezért a hi (i = 1, 2)
homomorfizmusokra teljesülnek a Homomorfizmus lemma (1.1 tétel) feltételei a G∩ és Gi
nyelvtanokra. Tehát
L(G∩ ) = hi (L(G∩ )) ⊆ L(Gi ) (i = 1, 2) =⇒ L(G∩ ) ⊆ L(G1 ) ∩ L(G2 ).

G∩ , mint minden nyelvtan, 0. tı́pusú, tehát a fentiek bizonyı́tják L0 metszetre való
zártságát. Továbbá ha G1 és G2 1. tı́pusúak, akkor bennük minden levezetés 1-korlátolt.
G∩ -ben egy D levezetés munkaterületére
ws(D) ≤ 1 + `(u)e + `(u)

e ≤ 3 · `(u)e
adódik (az első becslésnél az első tag az L nyelvtani jel hossza, a másik kettő az S1 illetve
S2 -ből való 1-korlátolt levezetésből adódik). Tehát ekkor G∩ 3-korlátolt nyelvtan, ı́gy az 1.7
és 1.8 tételek szerint L(G∩ ) generálható G1 -beli nyelvtannal. 2
2. Programozott nyelvtanok
A közönséges nyelvtanok működése a következő programsémával modellezhető:
α := S
köv(α) 6= ∅
α :∈ köv(α)
\ α∈T ∗
\ különben
Kiı́r(α) Hiba
Itt köv(α) = {β | α → β}. A ciklusmagban történő nemdeterminisztikus értékadás a kulcsa
G
a levezetések sokszı́nűségének.
Ezt a sémát úgy szeretnénk általánosı́tani, hogy a nyelvtan működését nem csak egy
α mondatformával, hanem egy [α, vi] konfigurációval ı́rjuk le, ahol vi valamilyen vezérlési
információ. Legyen adott a bemeneti vezérlési információk VI0 halmaza valamint a kimeneti
vezérlési információk FI halmaza, továbbá köv([α, vi]) = {[β, vi0 ] | [α, vi] → [β, vi0 ]}, akkor
G
az általánosı́tott séma:
α := S, vi ∈ VI0
köv([α, vi]) 6= ∅
[α, vi] :∈ köv([α, vi])
\ α ∈ T ∧ vi ∈ FI
∗
\ különben
Kiı́r(α) Hiba
Ennek az általánosı́tott sémának megfelelően működnek a programozott nyelvtanok.
2.1. Előfordulásellenőrzés nélküli programozott nyelv-

tanok
2.1. definı́ció. Egy G = hT, N, P, S, F, lab, σi hetest programozott nyelvtannak nevezünk,
ha a kövezkezők teljesülnek. hT, N, P, Si egy nyelvtan, ekkor T -t, N -t, P-t és S-t rendre
9
10 2. Programozott nyelvtanok
a programozott nyelvtan ábécéjének, a nyelvtani jelek ábécéjének, szabályhalmazának illetve

kezdőszimbólumának nevezzük. F (exit 6∈ F ) egy véges halmaz, a cı́mkék halmaza. lab :
F → P mindenütt értelmezett cı́mkéző függvény. Továbbá σ : F → 2F ∪{exit} mindenütt
értelmezett rákövetkezési függvény.
2.2. definı́ció. Legyen α ∈ (T ∪ N )∗ és f ∈ F ∪ {exit}, ekkor [α, f ]-et a programozott

nyelvtan egy konfigurációjának nevezzük.
Legyen P = p → q egy szabály, ekkor vezessük be a következő jelöléseket a szabály bal-

illetve jobboldalára: bo(P ) := p, jo(P ) := q.
2.3. definı́ció. Azt mondjuk, hogy az [α, f ] konfigurációból közvetlen (1-lépéses) konfigu-
rációátmenettel levezethető a [β, f 0 ] konfiguráció (α, β ∈ (T ∪ N )∗ , f ∈ F, f 0 ∈ F ∪ {exit}),
ha létezik olyan γ1 , γ2 ∈ (T ∪ N )∗ , melyre α = γ1 bo(lab(f ))γ2 , β = γ1 jo(lab(f ))γ2 és
f 0 ∈ σ(f ). A közvetlen konfigurációátmenet jelölése: [α, f ] → [β, f 0 ].
G
2.4. definı́ció. A közvetett konfigurációátmenet a közvetlen konfigurációátmenet reflexı́v,

∗
tranzitı́v lezártja, jelölése →. A levezetés (azaz közvetett konfigurációátmenet) hosszán a
G
levezetés során alkalmazott közvetlen konfigurációátmenetek n ∈ N számát értjük. n lépéses
n
levezetés jelölése →.
G
2.5. definı́ció. A G programozott nyelvtan által generált nyelv:

∗
L(G) = {u ∈ T ∗ | ∃ f ∈ F, f 0 ∈ F ∪ {exit}, [S, f ] → [u, f 0 ]}.
G
A programozott nyelvtanokban tehát a vezérlési információ a következő végrehajtandó

szabály cı́mkéje, mı́g VI0 = {f ∈ F | bo(lab(f )) = S}, FI = F ∪ {exit}.
2.6. definı́ció. Egy G = hT, N, P, S, F, lab, σi programozott nyelvtan i. tı́pusú, ha

hT, N, P, Si a lehető legáltalánosabb értelemben vett i. tı́pusú nyelvtan.
Jelölje GiP az i. tı́pusú programozott nyelvtanok összességét. Legyen továbbá Pi :=

{L | ∃ G ∈ GiP és L(G) = L}.
1. példa:
f0 : S → ABC f1 , f4
f1 : A → aA f2
f2 : B → bB f3
f3 : C → cC f1 , f4
f4 : A→a f5
f5 : B→b f6
f6 : C→c exit
2.1. Előfordulásellenőrzés nélküli programozott nyelvtanok 11
Példa levezetésre:
[S, f0 ] → [ABC, f1 ] → [aABC, f2 ] → [aAbBC, f3 ] → [aAbBcC, f4 ] → [aabBcC, f5 ] →
G G G G G G
[aabbcC, f6 ] → [aabbcc, exit].
G
A programozott nyelvtan által generált nyelv: L(G) = {an bn cn | n ≥ 1}.
2. példa:
f0 : S → X1 X2 {ft | t ∈ T } ∪ {fε }
ft : X1 → tX1 ft0 (t ∈ T )
ft0 : X2 → tX2 {ft | t ∈ T } ∪ {fε } (t ∈ T )
fε X1 → ε fε0
fε0 X2 → ε exit
L(G) = {uu | u ∈ T ∗ }
Minden nyelvtan tekinthető egyben programozott nyelvtannak is. Legyen ugyanis T , N ,
P, S mint a nyelvtanban, F = P, legyen lab az identitás P-n, továbbá σ(p → q) = P ∪{exit}.
Ugyanakkor az előző két példa mutatja, hogy programozott 2. tı́pusú nyelvtanokkal nem
csak 2. tı́pusú nyelveket lehet generálni.
2.7. állı́tás. Pi ⊇ Li (i = 0, 1, 2, 3), P2 ⊃ L2 .
Másrészt a 0., 1., 3. tı́pusú nyelvtanok programozási lehetősége nem bővı́ti a generált
nyelvek körét.
2.8. tétel. P3 = L3 .
Bizonyı́tás. Azt kell tehát belátni, hogy ha G = hT, N, P, S, F, lab, σi ∈ G3P , akkor létezik
G0 ∈ G3 , hogy L(G0 ) = L(G).
Legyen G0 = hT, N 0 , P 0 , S 0 i, ahol N 0 = {Af }A∈N,f ∈F ∪{exit} ∪ {S 0 }, P 0 -t pedig a követ-
kezőképpen definiáljuk.
Af → uBf 0 ∈ P 0 ⇐⇒ lab(f ) = A → uB, f 0 ∈ σ(f ),

Af → u ∈ P 0 ⇐⇒ lab(f ) = A → u, σ(f ) 6= ∅,
S 0 → Sf ∈ P 0 ⇐⇒ bo(lab(f )) = S.
1. Állı́tás: Legyen A, B ∈ N, u ∈ T ∗ , f ∈ F, f¯ ∈ F ∪ {exit}, ekkor
[A, f ] → [uB, f¯] ⇐⇒ Af →0 uBf¯.

∗ ∗
G G
Ezt a G-beli levezetés hosszára vonatkozó teljes indukcióval láthatjuk. Ha a levezetés
hossza 1, azaz [A, f ] → [uB, f¯], akkor
G
[A, f ] → [uB, f¯] ⇐⇒ lab(f ) = A → uB ∧ f¯ ∈ σ(f ) ⇐⇒ Af → uB ¯ ∈ P 0 ⇐⇒ f
G
Af →0 uBf¯.
G
Tegyük fel, hogy legfeljebb n hosszú levezetésekre igaz az állı́tás.

[A, f ] −→ [uB, f¯] ⇐⇒ ∃ C ∈ N, u0 ∈ T ∗ , g ∈ F, ([A, f ] → [u0 C, g] → [uB, f¯])
n+1 n
⇐⇒
G G G
Af →0 u0 Cg ∧ lab(g) = C → u00 B, u = u0 u00 , f¯ ∈ σ(g)
n n
⇐⇒ Af →0 u0 Cg ∧ Cg →0
G G G
n+1
u Bf¯ ⇐⇒ Af −→
00
0
uBf¯.
G
2. Állı́tás: Legyen B ∈ N, v ∈ T ∗ , f¯ ∈ F, f 0 ∈ F ∪ {exit}, ekkor
[B, f¯] → [v, f 0 ] ⇐⇒ Bf¯ →0 v.

G G
Ezt az előzőekhez hasonlóan láthatjuk be.
[B, f¯] → [v, f 0 ] ⇐⇒ lab(f ) = B → v ∧ f 0 ∈ σ(f¯) ⇐⇒ Bf¯ → v ∈ P 0 , σ(f ) 6=
G
∅ ⇐⇒ Bf¯ →0 v.
G
Az 1. és 2. állı́tásokból kapjuk, hogy A ∈ N, w ∈ T ∗ , f ∈ F, f 0 ∈ F ∪ {exit} esetén
∗ ∗
[A, f ] → [w, f 0 ] ⇐⇒ Af →0 w.
G G
Tehát
∗
u ∈ L(G) ⇐⇒ ∃ f ∈ F, f 0 ∈ F ∪ {exit} ([S, f ] → [u, f 0 ]) ⇐⇒ ∃ f ∈ F (S 0 → Sf ∈
G
∗ ∗
P 0 ∧ Sf →0 u) ⇐⇒ S 0 →0 u ⇐⇒ u ∈ L(G). 2
G G
2.9. tétel. Pi = Li (i = 0, 1).
Bizonyı́tás. Azt kell tehát belátni, hogy ha G = hT, N, P, S, F, lab, σi ∈ GiP (i = 0, 1),
akkor létezik G0 ∈ Gi , hogy L(G0 ) = L(G).
Legyen G0 = hT, N 0 , P 0 , S 0 i, ahol N 0 = N ∪ {Xf }f ∈F ∪{exit} ∪ {S 0 }, P 0 -t pedig a követ-
Xf p → Xg q ∈ P)0 ⇐⇒ lab(f ) = p → q, g ∈ σ(f ), (*)

Xf Z → ZXf ∈ P 0
⇐⇒ f ∈ F ∪ {exit}, Z ∈ T ∪ N ,
ZXf → Xf Z ∈ P 0
Xf → ε ∈ P 0 ⇐⇒ f ∈ F ∪ {exit},
S → SXf ∈ P 0 ⇐⇒ bo(lab(f )) = S.
0
Legyen α, β ∈ (T ∪ N )∗ , f ∈ F, f¯ ∈ F ∪ {exit}, ekkor
[α, f ] → [β, f¯] ⇐⇒ αXf →0 βXf¯.

∗ ∗
G G
A G-beli levezetés hosszára vonatkozó teljes indukcióval elegendő belátni, hogy
[α, f ] → [β, f¯] ⇐⇒ αXf →0 βXf¯ ∧ (*) alakú szabályt n-szer alkalmaztunk.
n ∗
G G
Ha a levezetés hossza 1, azaz [α, f ] → [β, f¯], akkor
G
[α, f ] → [β, f¯] ⇐⇒ ∃ γ1 , γ2 ∈ (T ∪ N )∗ , α = γ1 pγ2 , β = γ1 qγ2 , lab(f ) = p →
G
q ∧ f¯ ∈ σ(f )
∗
⇐⇒ α = γ1 pγ2 , β = γ1 qγ2 , Xf p → Xf¯q ∈ P 0 ⇐⇒ αXf →0 βXf¯ ∧
G
(*) alakú szabályt egyszer alkalmaztunk.
2.2. Előfordulásellenőrzéses programozott nyelvtanok 13

[α, f ] −→ [β, f¯] ⇐⇒ ∃ β 0 ∈ (T ∪ N )∗ , g ∈ F, ([α, f ] → [β 0 , g] → [β, f¯]) ⇐⇒ αXf →0
n+1 n ∗
G G G G
∗ ∗
β 0 Xg ∧ β 0 Xg →0 βXf¯ ∧ (*) alakú szabályt (n + 1)-szer alkalmaztunk ⇐⇒ αXf →0
G G
βXf¯ ∧ (*) alakú szabályt (n + 1)-szer alkalmaztunk.
Mivel Xf → ε ∈ P 0 és terminális szót csak ezen szabály alkalmazásával kaphatunk, ezért
ha α ∈ (T ∪ N )∗ , w ∈ T ∗ , f¯ ∈ F, f 0 ∈ F ∪ {exit}, akkor
∗ ∗
[α, f ] → [w, f 0 ] ⇐⇒ αXf →0 w.
G G
Tehát
∗
u ∈ L(G) ⇐⇒ ∃ f ∈ F, f 0 ∈ F ∪ {exit} ([S, f ] → [u, f 0 ]) ⇐⇒ ∃ f ∈ F (S 0 → SXf ∈
G
∗ ∗
P 0 ∧ SXf →0 u) ⇐⇒ S 0 →0 u ⇐⇒ u ∈ L(G).
G G
G0 , mint minden nyelvtan, 0. tı́pusú, tehát a fentiek bizonyı́tják a 0. tı́pusra vonatkozó
állı́tást. Ha G 1. tı́pusú, akkor benne u minden D levezetésére ws(D) ≤ `(u), e ahol ws(D)-
t a konfigurációk mondatforma komponense alapján számoljuk. Ha G -ben az u D-nek
0
megfelelő levezetését D0 -vel jelöljük, akkor ennek munkaterületére
ws(D0 ) ≤ 1 + ws(D) ≤ 1 + `(u)

e ≤ 2 · `(u)
e
(a +1 az Xf többletjelből adódik). Ekkor G0 2-korlátolt nyelvtan, ı́gy az 1.7 és 1.8 tételek
szerint L(G0 ) generálható G1 -beli nyelvtannal.
2
2.2. Előfordulásellenőrzéses programozott nyelvtanok

2.10. definı́ció. Egy G = hT, N, P, S, F, lab, σ, ϕi nyolcast előfordulásellenőrzéses progra-
mozott nyelvtannak nevezünk, ha a kövezkezők teljesülnek. hT, N, P, S, F, lab, σi egy progra-
mozott nyelvtan, ekkor T -t, N -t, P-t, S-t F -t,lab-t valamint σ-t rendre az előfordulásellen-
őrzéses programozott nyelvtan ábécéjének, a nyelvtani jelek ábécéjének, szabályhalmazának,
kezdőszimbólumának, cı́mkehalmazának, cı́mkéző függvényének illetve pozitı́v rákövetkezési
függvényének nevezzük. Továbbá ϕ : F → 2F ∪{exit} mindenütt értelmezett függvény, melyet
negatı́v rákövetkezési függvénynek hı́vunk.
2.11. definı́ció. Legyen α ∈ (T ∪ N )∗ és f ∈ F ∪ {exit}, ekkor [α, f ]-et az előfordulásel-

lenőrzéses programozott nyelvtan egy konfigurációjának nevezzük.
2.12. definı́ció. Azt mondjuk, hogy a [α, f ] konfigurációból közvetlen (1-lépéses) konfigurá-
cióátmenettel előfordulásellenőrzés nélkül levezethető a [β, f 0 ] konfiguráció, jelölése:
[α, f ] → [β, f 0 ] (α, β ∈ (T ∪ N )∗ , f ∈ F, f 0 ∈ F ∪ {exit}), ha [α, f ] →0 [β, f 0 ], ahol
G G
G0 = hT, N, P, S, F, lab, σi az előfordulásellenőrzés nélküli programozott nyelvtan. [α, f ]-
ből közvetlen (1-lépéses) konfigurációátmenettel előfordulásellenőrzéssel levezethető [β, f 0 ],

jelölése: [α, f ] −→ [β, f 0 ], ha [α, f ] → [β, f 0 ] vagy bo(lab(f )) * α, α = β és g ∈ ϕ(f ).
G,ac G
2.13. definı́ció. A(z előfordulásellenőrzéses) közvetett konfigurációátmenet a közvetlen

∗
konfigurációátmenet reflexı́v, tranzitı́v lezártja, jelölése −→ . A levezetés (azaz közvetett
G(,ac)
konfigurációátmenet) hosszán a levezetés során alkalmazott közvetlen konfigurációátmenetek
n
n ∈ N számát értjük. n lépéses (előfordulásellenőrzéses) levezetés jelölése −→ .
G(,ac)
2.14. definı́ció. A G előfordulásellenőrzéses programozott nyelvtan által (előfordulásellen-

őrzéssel) generált nyelv:
∗
L(ac) (G) = {u ∈ T ∗ | ∃f ∈ F, f 0 ∈ F ∪ {exit}, [S, f ] −→ [u, f 0 ]}.
G(,ac)
2.15. definı́ció. Egy G = hT, N, P, S, F, lab, σ, ϕi előfordulásellenőrzéses programozott

nyelvtan i. tı́pusú, ha hT, N, P, Si a lehető legáltalánosabb értelemben vett i. tı́pusú nyelvtan.
Jelölje GiP, ac az i. tı́pusú előfordulásellenőrzéses programozott nyelvtanok összességét. Le-

gyen továbbá Piac := {L | ∃ G ∈ GiP, ac és Lac (G) = L}.
1. példa:
σ ϕ
f1 : S → ZZ f1 f2
f2 : Z→S f2 f1 , f3
f3 : S→a f3 exit
n
L(G) = {a2 | n ∈ N}.
2. példa:
σ ϕ
f1 : S → SS f1 , f2
f2 : S → AAB f2 f3
f3 : A→ε f4 exit
f4 : B→ε f5
f5 : A→a f5 f6
f6 : B→S f6 f2
Példa levezetésre:
∗ ∗ ∗ ∗ ∗
[S, f1 ] −→ [SSS, f2 ] −→ [AABAABAAB, f3 ] −→ [AAABAAB, f5 ] −→ [aaaBaaB, f6 ] −→
G,ac G,ac G,ac G,ac G,ac
∗ ∗ ∗
[aaaSaaS, f2 ] −→ [aaaAABaaAAB, f3 ] −→ [aaaAaaAAB, f5 ] −→ [aaaaaaaaB, f6 ] −→
G,ac G,ac G,ac G,ac
∗
[aaaaaaaaS, f2 ] −→ [aaaaaaaaAAB, f3 ] −→ [aaaaaaaaA, f5 ] −→ [aaaaaaaaa, f2 ]
G,ac G,ac G,ac
−→ [aaaaaaaaa, f3 ] −→ [aaaaaaaaa, exit].
G,ac G,ac
(n − 1) helyett n darab S generálása a levezetés elején (2n − 1)-gyel több a-t eredményez.
Pn 2
Mivel n2 = i=1 (2i − 1), ezért L(G) = {an | n ≥ 1}.
Világos, hogy minden előfordulásellenőrzés nélküli programozott nyelvtan tekinthető

előfordulásellenőrzéses programozott nyelvtannak, ha kiegészı́tjük a ϕ ≡ ∅ negatı́v rákö-
vetkezési függvénnyel. Ezért minden i = 0, 1, 2, 3 mellett Pi ⊆ Piac .
2.16. tétel. P3ac = L3 .
Bizonyı́tás. Azt elegendő belátni, hogy ha G = hT, N, P, S, F, lab, σ, ϕi ∈ G3P, ac , akkor

létezik G0 ∈ G3 , hogy L(G0 ) = Lac (G).
Legyen G0 = hT, N 0 , P 0 , S 0 i, ahol N 0 = {Af }A∈N,f ∈F ∪{exit} ∪ {S 0 }, P 0 -t pedig a követ-
Af → uBf 0 ∈ P 0 ⇐⇒ lab(f ) = A → uB, f 0 ∈ σ(f ),

Af → u ∈ P 0 ⇐⇒ lab(f ) = A → u, σ(f ) 6= ∅,
Cf → Cg ∈ P 0 ⇐⇒ bo(lab(f )) 6= C, g ∈ ϕ(f ),
S 0 → Sf ∈ P 0 ⇐⇒ bo(lab(f )) = S.
1. Állı́tás: Legyen A, B ∈ N, u ∈ T ∗ , f ∈ F, f¯ ∈ F ∪ {exit}, ekkor
[A, f ] −→ [uB, f¯] ⇐⇒ Af →0 uBf¯.

∗ ∗
G,ac G
Ezt a G-beli levezetés hosszára vonatkozó teljes indukcióval láthatjuk. Ha a levezetés
hossza 1, azaz [A, f ] −→ [uB, f¯], akkor
G,ac
[A, f ] −→ [uB, f¯] ⇐⇒ lab(f ) = A → uB ∧ f¯ ∈ σ(f ) ∨ A = uB ∧ bo(lab(f )) 6=
G,ac
A, ∧ f¯ ∈ ϕ(f ) ⇐⇒ Af → uBf¯ ∈ P 0 ∨ A = uB ∧ Af →0 Af¯ ⇐⇒ Af →0 uBf¯.
G G
[A, f ] −→ [uB, f¯] ⇐⇒ ∃ C ∈ N, u0 ∈ T ∗ , g ∈ F, ([A, f ] −→ [u0 C, g] −→ [uB, f¯]) ⇐⇒
n+1 n
G,ac G,ac G,ac
Af →0 u0 Cg ∧ (lab(g) = C → u00 B, u = u0 u00 , f¯ ∈ σ(g) ∨ u0 = u, C = B, bo(lab(g)) 6=
n
G
B, f¯ ∈ ϕ(g)) ⇐⇒ Af →0 u0 Cg ∧ (Cg →0 u00 Bf¯ ∨ u0 = u, C = B, Bg →0 Bf¯) ⇐⇒ Af −→
n n+1
G G G G0
uBf¯.
2. Állı́tás: Legyen B ∈ N, v ∈ T ∗ , f¯ ∈ F, f 0 ∈ F ∪ {exit}, ekkor
[B, f¯] −→ [v, f 0 ] ⇐⇒ Bf¯ →0 v.

G,ac G
Itt előfordulásellenőrzéses konfigurációátmenet valójában nem történhet negatı́v rákövet-
kezési függvénnyel, mivel B = v nem állhat fenn.
[B, f¯] −→ [v, f 0 ] ⇐⇒ [B, f¯] → [v, f 0 ] ⇐⇒ lab(f ) = B → v ∧ f 0 ∈ σ(f¯) ⇐⇒ Bf¯ →
G,ac G
v ∈ P 0 , σ(f ) 6= ∅ ⇐⇒ Bf¯ →0 v.
G
Az 1. és 2. állı́tásokból kapjuk, hogy A ∈ N, w ∈ T ∗ , f ∈ F, f 0 ∈ F ∪ {exit} esetén

∗ ∗
[A, f ] −→ [w, f 0 ] ⇐⇒ Af →0 w.
G,ac G
Tehát
∗
u ∈ Lac (G) ⇐⇒ ∃ f ∈ F, f 0 ∈ F ∪ {exit} ([S, f ] −→ [u, f 0 ]) ⇐⇒ ∃ f ∈ F (S 0 →
G,ac
∗ ∗
Sf ∈ P 0 ∧ Sf →0 u) ⇐⇒ S 0 →0 u ⇐⇒ u ∈ L(G). 2
G G
A P0ac és P1ac nyelvosztályok vizsgálatához szükségünk van valamilyen mintafelismerő
eszközre.
2.17. definı́ció. (Knuth-Morris-Pratt (KMP) automata) Legyen m ∈ T ∗ egy szó.

Az m = m1 m2 · · · m`(m) mintához tartozó Am Knuth-Morris-Pratt automata (vagy röviden
KMP automata) a következő. Am = h{qi }0≤i≤`(m) , T, δ m , q0 , {q`(m) }i, ahol

`(m) i = `(m)
δ m (qi , x) = qj ⇐⇒ j = .
max{`(w) | w ∈ Pre(m) ∩ Suf(m1 · · · mi x)} i < `(m)
2.18. állı́tás. L(Am ) = {u ∈ T ∗ | m ⊆ u}.
Bizonyı́tás. A KMP automata csak az m mintát tartalmazó szavakat tudja felismerni,

hiszen mivel q`(m) az egyetlen elfogadó állapot és oda csak q`(m)−1 -ből juthatunk, ezért
minden elfogadott szónak van egy olyan x ∈ T betűje melyre Am a működése során a
q`(m)−1 állapotból a q`(m) állapotba lép, azaz δ m (q`(m)−1 , x) = q`(m) . Ez azt jelenti, hogy
az x előtti `(m) − 1 betű és x együtt kiadják az m mintát.
Másrészt, ha u = v1 mv2 , v1 , v2 ∈ T ∗ , akkor u-t felismeri az Am automata, hiszen v1 m
elolvasása után az automata aktuális állapota q`(m) és ez nem változik v2 betűinek olvasására.
2
2.19. tétel. Piac = Li (i = 0, 1).
Bizonyı́tás. Elegendő belátni, hogy ha G = hT, N, P, S, F, lab, σ, ϕi ∈ Piac , akkor létezik

G0 ∈ Gi , melyre L(G0 ) = Lac (G) (i = 0, 1).
Legyen G0 = hT, N 0 , P 0 , S 0 i, ahol
N 0 = N ∪ {Xf }f ∈F ∪{exit} ∪ {qif }f ∈F,0≤i≤`(bo(lab(f ))) ∪ {S 0 , L, R},

P 0 -t pedig a következőképpen definiáljuk (δ mf a a T ∪ N ábécé feletti mf = bo(lab(f ))
mintához tartozó KMP automata átmenetfüggvénye):
Xf p → Xg q ∈ P)0 ⇐⇒ lab(f ) = p → q, g ∈ σ(f ), (*)

Xf Z → ZXf ∈ P 0
⇐⇒ f ∈ F ∪ {exit}, Z ∈ T ∪ N ,
ZXf → Xf Z ∈ P 0
Xf → ε ∈ P 0 ⇐⇒ f ∈ F ∪ {exit},
S 0 → LSXf R ∈ P0 ⇐⇒ bo(lab(f )) = S,
LXf → Lq0f ∈ P0 ⇐⇒ f ∈ F, (**)
qjf Z → Zδ mf (qjf , Z) ∈ P0 ⇐⇒ f ∈ F, Z ∈ T ∪ N, 0 ≤ j ≤ `(mf ),
qjf R → Xg R ∈ P0 ⇐⇒ f ∈ F, g ∈ F ∪ {exit}, 0 ≤ j ≤ `(mf ) − 1, g ∈ ϕ(f ),
L → ε, R → ε ∈ P 0.
Legyen α, β ∈ (T ∪ N )∗ , f ∈ F, f¯ ∈ F ∪ {exit}, ekkor
[α, f ] −→ [β, f¯] ⇐⇒ LαXf R →0 LβXf¯R.

∗ ∗
G,ac G
A G-beli levezetés hosszára vonatkozó teljes indukcióval elegendő belátni, hogy
[α, f ] −→ [β, f¯]

n ∗
⇐⇒ LαXf R →0 LβXf¯R ∧ (*) vagy (**) alakú szabályt n-szer
G,ac G
alkalmaztunk.
Ha a levezetés hossza 1, azaz [α, f ] −→ [β, f¯], akkor
G,ac
[α, f ] −→ [β, f¯] ⇐⇒ ∃ γ1 , γ2 ∈ (T ∪ N )∗ , α = γ1 pγ2 , β = γ1 qγ2 , lab(f ) = p → q ∧ f¯ ∈
G,ac
σ(f ) ∨ bo(lab(f )) * α ∧ α = β ∧ f¯ ∈ ϕ(f ) ⇐⇒ α = γ1 pγ2 , β = γ1 qγ2 , Xf p → Xf¯q ∈
∧ f¯ ∈ ϕ(f ) ⇐⇒ LαXf R →0 LβXf¯R∧ (*) vagy (**)
∗
P 0 ∨ α = β ∧ δ mf (q0f , α) 6= q`(m
f
f) G
alakú szabályt egyszer alkalmaztunk.
[α, f ] −→ [β, f¯] ⇐⇒ ∃ β 0 ∈ (T ∪ N )∗ , g ∈ F, ([α, f ] −→ [β 0 , g] −→ [β, f¯])
n+1 n
⇐⇒
G,ac G,ac G,ac
∗ ∗
LαXf R →0 Lβ 0 Xg R ∧ Lβ 0 Xg R →0 LβXf¯R ∧ (*) vagy (**) alakú szabályt (n + 1)-szer alkal-
G G
∗
maztunk ⇐⇒ LαXf →0 RβLXf¯R ∧ (*) vagy (**) alakú szabályt (n+1)-szer alkalmaztunk.
G
Mivel Xf → ε ∈ P 0 és terminális szót csak ezen szabály alkalmazásával kaphatunk, ezért
ha α ∈ (T ∪ N )∗ , w ∈ T ∗ , f¯ ∈ F, f 0 ∈ F ∪ {exit}, akkor
∗ ∗
[α, f ] −→ [w, f 0 ] ⇐⇒ LαXf R →0 LwR.
G,ac G
Tehát
∗
u ∈ Lac (G) ⇐⇒ ∃ f ∈ F, f 0 ∈ F ∪ {exit} ([S, f ] −→ [u, f 0 ]) ⇐⇒ ∃ f ∈ F (S 0 →
G,ac
∗ ∗
LSXf R ∈ P 0 ∧ LSXf R →0 LuR) ⇐⇒ S 0 →0 u ⇐⇒ u ∈ L(G).
G G
G0 , mint minden nyelvtan, 0. tı́pusú, tehát a fentiek bizonyı́tják a 0. tı́pusra vonatkozó
állı́tást. Ha G 1. tı́pusú, akkor a 2.9 tételben látottt érvelést követve van u ∈ L(G0 )-nek
olyan D0 G0 -beli levezetése, melyre
ws(D0 ) ≤ 3 + ws(D) ≤ 3 + `(u)

e ≤ 4 · `(u),
e
ahol a +3 az L, R, és az egyszerre nem előforduló Xf illetve qjf többletjelekből adódik.
Tehát ekkor G0 4-korlátolt nyelvtan, ı́gy az 1.7 és 1.8 tételek szerint L(G0 ) generálható
G1 -beli nyelvtannal. 2
2.20. tétel. P2ac = L0 .

Bizonyı́tás. P2ac ⊆ P0ac = L0 . Elegendő tehát belátni, hogy tetszőleges G = hT, N, P =

{p1 → q1 , . . . , pk → qk }, Si ∈ G0 nyelvtanhoz létezik G0 2. tı́pusú előfordulásellenőrzéses
programozott nyelvtan, melyre Lac (G0 ) = L(G).
Ehhez azt használjuk ki, hogy előfordulásellenőrzéses programozott nyelvtanokban lehet
számolni. Egy X változónak, mely nemnegatı́v egész értékeket vehet fel, megfelel egy X
nemterminális, melynek a mondatformában való előfordulásának száma a változó értéke.
Az első lépésben definiáljuk a mondatformáknak egy természetes számokkal való kódo-
lását és megadjuk a kódolást és dekódolást elvégző algoritmusokat.
Definiáljuk tehát a G-beli mondatformák egy természetes számmal való kódolását (és
visszakódolását) a következőképpen. Legyen M = |T ∪ N | + 1 valamint kod : T ∪ N →
{1, . . . , M − 1} egy tetszőleges bijekció. Legyen

0 α=ε
kod(α)
d = .
M · kod(α
d 0 ) + kod(z) α = α0 z
kod
d a kod függvény kiterjesztése, ezért a továbbiakban elhagyjuk a b-t. Továbbá az is
teljesül, hogy kod(α) M -áris alakjában nincs 0 számjegy, ha α 6= ε. kod tényleg kódolás, a
következőképpen kapható vissza a mondatforma a kódból:

ε n=0
kod−1 (n) = .
−1 −1
kod (n ) kod (m) n = M · n0 + m, 1 ≤ m ≤ M − 1
0
Tehát egy α ∈ (T ∪ N )∗ mondatforma X ∈ N kódját megadó, illetve az X ∈ N kódot

egy α ∈ (T ∪ N )∗ változóba dekódoló algoritmus:
Kód(α, X) Dekód(X, α)
X := 0 α := ε
α 6= ε X 6= 0
z := pre(α, 1) X, B := bX/M c, {X/M }
X := M · X + kod(z) α := kod−1 (B)α
α := suf(α, `(α) − 1)
Ezek után elkészı́tünk egy, a közvett levezetéseket számokon szimuláló algoritmust, mely
inputként beolvassa egy mondatforma kódját és nemdeterminisztikusan outputként vissza-
adja egy belőle közvetetten levezethető mondatforma kódját.
A kódfüggvény rekurzı́v definı́ciója alapján nemdeterminisztikusan le tudjuk választani
egy α mondatforma utolsó néhány (r) betűjét és fordı́tott sorrendben egy γ mondatformában
eltárolni, illetve egy γ mondatforma megfordı́tását α-hoz jobbról hozzákonkatenálni.
Nemdeterminisztikus leválasztás(α, γ) := pre(α, `(α)−r), suf(α, r)−1
Hozzáı́rás(α, γ) := αγ −1
A nemdeterminisztikus leválasztást és a hozzáı́rást a kódokon megvalósı́tó algoritmusok

(X = kod(α) és Y = kod(γ)):
NLevál(X, Y ) Hozzá(X, Y )
Y 6= 0
X, B := bX/M c, {X/M } Y, B := bY /M c, {Y /M }
Y := M Y + B X := M X + B
Továbbá szükségünk van q meghatározására, ha p egy szabály baloldala, és p → q ∈ P.

Legyen P = kod(p), ekkor P -t lenullázzuk és Q = kod(q) lesz. Az ezt megvalósı́tó szintén
nemdeterminisztikus algoritmus (több szabálynak is lehet ugyanaz a baloldala):
Meghat(P, Q)
P = kod(p−1
1 ) P = kod(p−1
i ) P = kod(p−1
k )
\ \ \ \ \
Q := kod(q1−1 ) ··· Q := kod(qi−1 ) ··· Q := kod(qk−1 )
P := 0 P := 0 P := 0
Így a következő Gener(X) nemdeterminisztikus algoritmus generálja egy egy α ∈ (T ∪

∗
N ) mondatforma kódját (X-be), melyre kod−1 (X) → α. Az algoritmus kod−1 (X)-ből
∗
G
valahány G-beli levezetési lépést szimulál a kódokon. Egy α = α1 pα2 → α1 qα2 = β lev-
G
ezetési lépés szimulálása esetén a változók jelentései a következők. X amellett, hogy az
egyes levezetési lépések szimulálása végén az aktuális mondatforma kódjával egyezik meg, a
szimuláció közben a leválasztás után megmaradó mondatforma kódját tároló változó is egy-
ben. Tehát X kezdetben kod(α)-val, a levezetési lépés szimulálása végén kod(β)-val egyezik
meg. Y = kod(α2−1 ), P = kod(p−1 ) és Q = kod(q −1 ).
Gener(X)
NLevál(X, Y )
NLevál(X, P )
Meghat(P, Q)
Hozzá(X, Q)
Hozzá(X, Y )
A második lépésben számfüggvény makrókat hozunk létre, melyek egy 2. tı́pusú előfor-
dulásellenőrzéses nyelvtanban megvalósı́tják a számunkra szükséges számı́tásokat. A makrók
mindig valamilyen α mondatformán működnek, a benne lévő nyelvtani jeleken operálnak.
−
A Makró(X1 , . . . , Xn , fBE , fKI
+
, fKI ) makró a következő alakú specifikációnak felel meg.
Leı́rás Szabályok Előfeltétel

lab σ ϕ
Null(X, fBE , fKI ) fBE : X→ε fBE fKI
X:=0
Add0(X, Y, fBE , fKI ) fBE : Y →X fBE fKI
X:=X+Y, Y :=0
Add(X, Y, fBE , fKI ) fBE : Y → XY 0 fBE f1 Y0 =0
X:=X+Y, Y :=Y f1 : Y0 →Y f1 fKI
SzorM (X, fBE , fKI ) fBE : X → QM fBE f1 Q=0
X:=X · M f1 : Q→X f1 fKI
OsztM (X, Y, fBE , fKI ) fBE : X → XE g0 fKI Y =0
X:=bX/M c, Y :={X/M } g0 : X→ε g1 h0 E=0
g1 : X→ε g2 h1 Q=0
..
.
gM −2 : X→ε gM −1 hM −2
gM −1 : X→Q g0 hM −1
h0 : E→ε k
h1 : E→Y k
..
.
hi : E →Yi k
..
.
hM −1 : E → Y M −1 k
k: Q→X k fKI
Beállı́tM (X, fBE , fKI ) fBE : X→Q f0 X≥1
X:=M f0 : X→ε f0 f1
f1 : Q → XM fKI
−
EgyenlőM (X, fBE , fKI
+
, fKI ) fBE : X →X f0 f0
X = M ; fKI+
f0 : X →Z f1 g−
−
X 6= M ; fKI f1 : X →Z f2 g−
..
X:=0 .
fM −1 : X →Z fM g−
fM : X →Z g− fKI
+
−
g− : X →Z g− fKI
−
NEgyenlőM (X, fBE , fKI
+
, fKI ) fBE : X →X f0 f0
X 6= M ; fKI
+
f0 : X →Z f1 g−
−
X = M ; fKI f1 : X →Z f2 g−
..
X:=0 .
fM −1 : X →Z fM g−
−
fM : X →Z g− fKI
g− : X →Z g− fKI
+
2.1. táblázat. Számfüggvény makrók előfordulásellenőrzéses programozott nyelvtanokban

Előfeltétel: X1 = X10 , . . . , Xn = Xn0 ∧ cı́mke = fBE ,

utófeltétel: X1 , . . . , Xn := f (X10 , . . . , Xn0 ) ∧ (cı́mke = fKI
+
∧ B(X10 , . . . , Xn0 ) = >
−
∨ cı́mke = fKI ∧ B(X10 , . . . , Xn0 ) = ⊥),
ahol f : N → N függvény és B : Nn → {>, ⊥} Boole-függvény. Ha B mindig igaz akkor
n n
−
fKI el is hagyható.
Az aktuális α mondatformában szereplő W nyelvtani jelek számát tekintsük változónak
és `W (α) helyett használjuk rá a W jelölést. A makrókban szereplő lokális cı́mkékhez és
változókhoz a kifejtés során új, egyedi cı́mkéket és változókat veszünk majd fel. A számunkra
szükséges makrókat a 2.1. táblázatban adtuk meg. A változó=0 előfeltételt a Null makróval
is biztosı́thatjuk.
Végül a harmadik lépésben a Gener(X) algoritmust a makrók segı́tségével megvalósı́tjuk
egy G0 2. tı́pusú előfordulásellenőrzéses nyelvtanban, majd X = kod(S)-el futtatjuk. Végül
szükségünk van a kapott mondatforma dekódolására. Az egyes részfeladatok megvalósı́tása:
NLevál(X, Y ) NLevál(X, P )
OsztM (X, B) OsztM (X, B)

SzorM (Y ) SzorM (P )
AddM (Y, B) AddM (P, B)
Meghat(P, Q)
Egyenlőkod(p−1 ) (P ) Egyenlőkod(p−1 ) (P ) Egyenlőkod(p−1 ) (P )
\ 1
\ \ i
\ \ i
Beállı́tkod(q−1 ) (Q) ··· Beállı́tkod(q−1 ) (Q) ··· Beállı́tkod(q−1 ) (Q)

1 i k
Hozzá(X, Q) Hozzá(X, Y )
NEgyenlő0 (Q) NEgyenlő0 (Y )
OsztM (Q, B) OsztM (Y, B)
SzorM (X) SzorM (X)
AddM (X, B) AddM (X, B)
Dekód(X, α)
NEgyenlő0 (X)
OsztM (X, B)
Egyenlő1 (B) Egyenlői (B) EgyenlőM −1 (B)
\ \ \ \ \
E → E kod−1 (1) ··· E → E kod−1 (i) ··· E → E kod−1 (M − 1)
Tekintsük tehát a következő G0 = hT, N 0 , P 0 , S 0 , F, lab, σ, ϕi előfordulásellenőrzéses prog-

ramozott nyelvtant, ahol N 0 = N ∪ {S 0 , E, X, Y, B, P, Q} ∪ N b, N b a makrókban előforduló
segédjelek halamaza és F = {fi }0≤i≤21 ∪ {gi , gi+ }1≤i≤|T ∪N | ∪ {hi , h+

i }1≤i≤|P| ∪ F , F
b b
a makrókban előforduló segédcı́mkék halamaza. P cı́mkézett szabályai σ-val és ϕ-vel a
0
következők:
σ ϕ
f0 : S → X
0
E
kod(S)
f1
f1 : E → E f2 f3
f2 : E→E f4 f5
OsztM (X, B, f4 , f6 )
SzorM (Y, f6 , f7 )
Add(Y, B, f7 , f2 )
f5 : E→E f8 f9
OsztM (X, B, f8 , f6 )
SzorM (P, f6 , f7 )
Add(P, B, f7 , f5 )
f9 : E→E h1 , . . . , hk
Egyenlőkod(p−1 ) (P, hi , h+
i , ) (1 ≤ i ≤ k)
i
Beállı́t kod(qi−1 ) (Q, h+

i , f10 ) (1 ≤ i ≤ k)
NEgyenlő0 (Q, f10 , f11 , f12 )
OsztM (Q, B, f11 , f13 )
SzorM (X, f13 , f14 )
Add(X, B, f14 , f10 )
NEgyenlő0 (Y, f12 , f15 , f16 )
OsztM (Y, B, f15 , f17 )
SzorM (X, f17 , f18 )
Add(X, B, f18 , f12 )
NEgyenlő0 (X, f3 , f19 , f20 )
OsztM (X, B, f19 , f21 )
f21 : E→E g1 , . . . , gM −1
Egyenlői (B, gi , gi+ , ) (1 ≤ i ≤ M −1)
gi+ : E → E kod−1 (i) f3 (1 ≤ i ≤ M −1)
f20 : E → ε exit
Tehát a dekódoló alprogram valamely S-ből levezethető G-beli α mondatformára a
megfelelő X kod(α) E mondatformából Eα-t készı́t, (a többi változó már korábban kinullázó-
dott), lab(f20 ) pedig eltünteti E-t. Tehát Lac (G0 ) = L(G). 2
3. Mátrixnyelvtanok
Mı́g programozott nyelvtanoknál a vezérlési struktúrára nincsen semilyen megkötés, addig
a mátrixnyelvtanoknál teljes szekvenciákat kell végrehajtani. Egy szekvenciát az elejéről
kell kezdeni és végig kell csinálni, ha egy szabályt nem lehet végrehajtani, akkor a program
abortál.
A mátrixnyelvtanok programsémája, ha mi = [pi1 → q1i , . . . , pi`(i) → q`(i)
i
] (i ∈ {1, . . . , k}),
és `(i) az i. mátrix hossza.
\ \ \ \ \
p11 → q11 pi1 → q1i pk1 → q1k

.. ··· .. ··· ..
. . .
p1`(1) → q`(1)
1
pi`(i) → q`(i)
i
pk`(k) → q`(k)
k
A mátrixnyelvtanokban megengedett még az egy szabályra vonatkozó elágazás, melyet a

szabály pontozásával jelölünk. A pontozott szabály végrehajtási szemantikája:
•
p→q p→q
α −→ β ⇐⇒ α −→ β ∨ (p * α ∧ α = β).
3.1. definı́ció. Egy G = hT, N, M, Si négyest mátrixnyelvtannak nevezünk, ha M mát-

rixok egy véges halmaza. Egy m ∈ M mátrix közönséges vagy pontozott szabályok véges
sorozata. Legyen mi = [pi1 → q1i , . . . pi`(i) → q`(i)
(•) (•) i
] (i ∈ {1, . . . , |M|}). Az α mondat-
formából közvetlenül levezethető a β mondatforma (előfordulásellenőrzés nélkül) ha létezik
α0 , α1 , . . . , α`(i) ∈ (T ∪ N )∗ , hogy α0 = α, α`(i) = β és minden j ∈ {1, . . . , `(i)}-re
pij →qji m
αj−1 −→ αj (a szabályok pontozását figyelmen kı́vül hagyjuk). Jelölése α →i β.
G
Az α mondatformából közvetlenül, előfordulásellenőrzéssel levezethető a β mondatforma
ha létezik α0 , α1 , . . . , α`(i) ∈ (T ∪ N )∗ , hogy α0 = α, α`(i) = β és minden j ∈ {1, . . . , `(i)}-
•
pij →qji pij →qji
re αj−1 −→ αj ha a szabály pontozatlen, illetve αj−1 −→ αj , ha pontozott. Jelölése
m
α −→
i
β.
G,ac
23
24 3. Mátrixnyelvtanok
m ∗
α −→ β, ha létezik m ∈ M, hogy α −→
i
β. −→ a −→ reflexı́v, tranzitı́v lezártja.
G(,ac) G(,ac) G(,ac) G(,ac)
∗
L(ac)
(G) = {u ∈ T | S −→ u}.
∗
G(,ac)
G i. tı́pusú mátrixnyelvtan, ha minden szabály a legáltalánosabb értelemben vett i.

tı́pusú. A korlátozott ε-szabály értelmezése: [S → ε] ∈ M és S nem fordulhat elő szabály
jobboldalán.
(ac)
Mi = {L | ∃ G i. tı́pusú mátrixnyelvtan, melyre L(ac) (G) = L}.
Példák: (csak a mátrixrendszert megadva)
1. [S → ABC], [A → aA, B → bB, C → cC], [A → a, B → b, C → c].

L(G) = {an bn cn | n ≥ 1}.
2. [S → V W ], [V → tV, W → tW ]t∈T , [V → ε, W → ε].

L(G) = {uu | u ∈ T ∗ }.
3. [A → U, Y → U, S → ZZ], [A → U, S → U, Z → Y ], [A → U, Z → U, Y → S], [Z →
• • • • • • •
U, Y → U, S → A], [Z → U, Y → U, S → U, A → a].
• • • •
n
Lac (G) = {a2 | n ∈ N}.
4. [S → ABC], [A → AA], [B → BB], [C → CC], [A → a, B → b, C → c].

L(G) = {an bn cn | n ≥ 1}.
Egy mátrixnyelvtan természetes módon tekinthető programozott nyelvtannak is, ha
σ(P ) a mátrixban következő szabály cı́mkéjét tartalmazza csak, ha P nem a mátrix
utolsó szabálya, mı́g a mátrixok első szabályainak cı́mkéit, ha P egy mátrix utolsó
szabálya.
A mátrixnyelvtannak megfelelő programozott nyelvtan által generált nyelv:
L = {an bn cn ∨ an+1 bn cn ∨ an+1 bn+1 cn | n ≥ 1}.
A generált nyelvek különbözősége onnan adódik, hogy a programozott nyelvtanban a
generálás bármelyik cı́mkén befejeződhet.
(ac) (ac)
3.2. tétel. Mi = Pi .
Bizonyı́tás. Legyen G = hT, N, P, S, F, lab, σ, ϕi i. tı́pusú (előfordulásellenőrzéses) pro-

gramozott nyelvtan. Készı́tünk egy G0 = hT, N 0 , M, S 0 i i. tı́pusú (előfordulásellenőrzéses)
mátrixnyelvtant, melyre L(ac) (G0 ) = L(ac) (G).
Legyen N 0 = N ∪ {Af }A∈N,f ∈F ∪ {S 0 , U }, M mátrixai:
25
[S 0 → Sf ] (f ∈ F ),
[Af → A, p → q, B → Bg ] (A, B ∈ N, f ∈ F, lab(f ) = p → q, g ∈ σ(f )),
[Af → A, p → U `(p) , B → Bg ] (A, B ∈ N, f ∈ F, bo(lab(f )) = p, g ∈ ϕ(f )),
•
[Af → A, p → q] (A ∈ N, f ∈ F, lab(f ) = p → q, q ∈ T ∗ ).
Tehát a következő programsor cı́mkéjét az aktuális mondatforma egy tetszőlegesen vá-

lasztott nyelvtani jelének indexében tároljuk, azaz egy G-beli
[S, f ] → [α1 , f1 ] → · · · → [αk , fk ] → [u, g]

G G G G
levezetésnek megfelel egy G0 -beli
m m m m0
S →0 Sf −→
1
0
α
b1 −→
2
0
· · · −→
k
0
α
bk −→
0
u
G G G G G
levezetés, ahol minden 1 ≤ j ≤ k-ra α bj αj -nek egy olyan variánsa, ahol pontosan egy
nyelvtani jel indexelt, és ez az index fj , az m0 4. fajtájú mátrixszal történő levezetésnél
eltűnik az index.
Mivel terminális szavaknak az összes G0 -beli levezetése fenti alakú, ezért L(ac) (G0 ) =
L (G).
(ac)
Ha S → ε ∈ P, és a korlátozott ε-szabály teljesül, akkor hagyjuk el ezt a szabályt P-ből

G elkészı́tése előtt, majd adjuk hozzá M-hez az [S 0 → ε] mátrixot. Így a G0 mátrixnyelvtan
0
is teljesı́ti a korlátozott ε-szabályt és továbbra is L(ac) (G0 ) = L(ac) (G). Ezen módosı́tással
ha G i. tı́pusú (előfordulásellenőrzéses) programozott nyelvtan volt, akkor G0 i. tı́pusú
(előfordulásellenőrzéses) mátrixnyelvtan.
Legyen most G0 = hT, N, M, Si i. tı́pusú (előfordulásellenőrzéses) mátrixnyelvtan.
Készı́tünk egy G0 = hT, N 0 , P, S 0 , F, lab, σ, ϕi i. tı́pusú (előfordulásellenőrzéses) programo-
zott nyelvtant, melyre L(ac) (G0 ) = L(ac) (G).
Legyen M = {m1 . . . , m|M| } és mj,k az mj mátrix k. szabálya. Legyen továbbá
P = {mj,k | 1 ≤ j ≤ |M|, 1 ≤ k ≤ |mj |, mj,k pontozatlan}, illetve P • = {mj,k | 1 ≤ j ≤
◦
|M|, 1 ≤ k ≤ |mj |, mj,k pontozott}. Legyen N 0 = N ∪ {Xt }t∈T ∪ {S 0 , Xε }. Ha valamely 1 ≤

j ≤ |M|,1 ≤ k < |mj | esetén jo(mj,k ) =  t1 · · · t` ∈ T vezessük be a következő jelöléseket.
∗
t ` > 0 X `>0
` t`
xj,k = , továbbá Xj,k = valamint mb j,k az a szabály, melyre
ε ` = 0 Xε ` = 0

t · · · t X `>0
1 `−1 t`
bo(mb j,k ) = bo(mj,k ) és jo(m
b j,k ) = .
Xε `=0
A G0 (előfordulásellenőrzéses) programozott nyelvtan P szabályrendszere a cı́mkézéssel
(F az előforduló cı́mkék halmaza) valamint a pozitı́v (σ) és negatı́v (ϕ) rákövetkezési
függvénnyel a következő:
26 3. Mátrixnyelvtanok
σ ϕ
|M|
fkezd : S0 → S {f`,1 }`=1
|M| |M|
fj,|mj | : mj,|mj | {f`,1 }`=1 {f`,1 }`=1 1 ≤ j ≤ |M|, mj,|mj | ∈ P •
|M|
fj,|mj | : mj,|mj | {f`,1 }`=1 1 ≤ j ≤ |M|, mj,|mj | ∈ P ◦
fj,k : mj,k fj,k+1 fj,k+1 1 ≤ j ≤ |M| ∧ 1 ≤ k < |mj | ∧ mj,k ∈ P • ∧

(jo(mj,k ) 6∈ T ∗ ∨ ∀k < ` ≤ |mj | mj,` ∈ P • )
fj,k : mj,k fj,k+1 1 ≤ j ≤ |M| ∧ 1 ≤ k < |mj | ∧ mj,k ∈ P ◦ ∧

(jo(mj,k ) 6∈ T ∗ ∨ ∀k < ` ≤ |mj | mj,` ∈ P • )
fj,k : m
b j,k {fj,k
A
}A∈N fj,k+1 1 ≤ j ≤ |M| ∧ 1 ≤ k < |mj | ∧ mj,k ∈ P • ∧
jo(mj,k ) ∈ T ∗ ∧ ∃k < ` ≤ |mj | mj,` ∈ P ◦
fj,k : m
b j,k {fj,k
A
}A∈N 1 ≤ j ≤ |M| ∧ 1 ≤ k < |mj | ∧ mj,k ∈ P ◦ ∧
jo(mj,k ) ∈ T ∗ ∧ ∃k < ` ≤ |mj | mj,` ∈ P ◦
fj,k
A
: A→A fj,k
vissza
1 ≤ j ≤ |M| ∧ 1 ≤ k < |mj | ∧ A ∈ N ∧
jo(mj,k ) ∈ T ∗ ∧ ∃k < ` ≤ |mj | mj,` ∈ P ◦
fj,k
vissza
: Xj,k → xj,k fj,k+1 1 ≤ j ≤ |M| ∧ 1 ≤ k < |mj | ∧
jo(mj,k ) ∈ T ∗ ∧ ∃k < ` ≤ |mj | mj,` ∈ P ◦ .
Tehát G0 szabályai alapvetően az M mátrix szabályai, egy szabály esetén a rákövetkezési

függvény a mátrix következő szabályára mutat, kivéve ha ez a mátrix utolsó szabálya, ekkor
bármely mátrix első szabálya lehet a következő alkalmazott szabály. Amennyiben egy mátrix
nem utolsó szabályának jobboldala terminális szó és van még a mátrix hátralevő szabályai
között pontozatlan, akkor ezen szabály alkalmazása után nem érhet véget a levezetés, tehát
ellenőriznünk kell, hogy van-e még az aktuális mondatformában nyelvtani jel. Az utolsó
4 sorban szereplő programozott szabályok ezt az ellenőrzést hajtják végre. Tehát a G0
programozott nyelvtan valóban szimulálja a G mátrixnyelvtant, azaz L(ac) (G0 ) = L(ac) (G).
Ha [S → ε] ∈ M és S nem fordul elő szabály jobboldalán, akkor G0 elkészı́tése előtt
töröljük ezt a mátrixot M-ből, viszont adjuk hozzá P-hez az S 0 → ε szabályt, melynek
cı́mkéje legyen fkezd0 , továbbá σ(fkezd0 ) = {exit} és ϕ(fkezd0 ) = ∅. Ezzel a megjegyzéssel,
ha G i. tı́pusú, akkor G0 is az. 2
4. Kontrollnyelvtanok
4.1. definı́ció. Egy G = hT, N, F, P, lab, Ci hatost kontrollnyelvtannak nevezünk, ha a
kövezkezők teljesülnek. Valamely S ∈ N -re hT, N, P, Si egy nyelvtan, ekkor T -t, N -t, P-t
és S-t rendre a kontrollnyelvtan ábécéjének, a nyelvtani jelek ábécéjének, szabályhalmazának
illetve kezdőszimbólumának nevezzük. P tartalmazhat pontozott szabályokat is. F egy véges
halmaz, a cı́mkék halmaza. lab : F → P mindenütt értelmezett cı́mkéző függvény. Továbbá
C ⊆ F ∗ reguláris nyelv, melyet kontrollnyelvnek nevezünk.
4.2. definı́ció. Az α mondatformából a kontrollnyelvtanban előfordulásellenőrzés nélkül

közvetlenül levezethető a β mondatforma (α, β ∈ (T ∪ N )∗ ), ha létezik olyan f ∈ F ,
lab(f )
melyre α −→
0
β, a szabályok pontozásának figyelmen kı́vül hagyásával, ahol G0 = hT, N, Pi.
G
f
Jelölése α → β.
G
Az α mondatformából a kontrollnyelvtanban előfordulásellenőrzéssel közvetlenül leveze-
lab(f )
thető a β mondatforma (α, β ∈ (T ∪ N )∗ ), ha létezik olyan f ∈ F , melyre α −→ 0
β, a
G
f
szabályok pontozásának figyelembevételével. Jelölése α −→ β.
G,ac
4.3. definı́ció. Az α mondatformából a kontrollnyelvtanban előfordulásellenőrzés nélkül il-

letve előfordulásellenőrzéssel közvetetten levezethető a β mondatforma (α, β ∈ (T ∪ N )∗ ) a
σ = f1 · · · fk (k ≥ 0) kontrollszó segı́tségével, ha léteznek α0 , . . . , αk mondatformák, melyekre
fi σ
α0 = α, αk = β és αi−1 −→ αi (i ∈ {1 . . . , k}). Jelölése α −→ β.
G(,ac) G(,ac)
4.4. definı́ció. A kontrollnyelvtan által előfordulásellenőrzés nélkül illetve előfordulásellen-

őrzéssel generált nyelv:
σ
L(ac) (G) = {u ∈ T ∗ | ∃ σ ∈ C, S −→ u}.
G(,ac)
Példák:
1. A G1 kontrollnyelvtan cı́mkézett szabályai:
27
28 4. Kontrollnyelvtanok
f1 : S −→ ABC f5 : A −→ a
f2 : A −→ aA f6 : B −→ b
f3 : B −→ bB f7 : C −→ c
f4 : C −→ cC.
C = f1 (f2 f3 f4 )∗ f5 f6 f7 . Ekkor L(G) = {an bn cn | n ≥ 1}.
2. A G2 kontrollnyelvtan cı́mkézett szabályai:
f1 : S −→ ZZ f20 Z −→ U
•
f10 : S −→ U f3 S −→ a
•
f20 : Z −→ S
n
C = (f1∗ f10 f2∗ f20 )∗ f3∗ . Ekkor Lac (G) = {a2 | n ∈ N}.
G = hT, N, F, P, lab, Ci i. tı́pusú kontrollnyelvtan ha hT, N, Pi i. tı́pusú nyelvtan.

(ac)
Ci = {L | ∃ G i. tı́pusú kontrollnyelvtan, melyre L(ac) (G) = L}.
Megjegyzés: A kontrollnyelv tı́pusára tett megszorı́tást az indokolja, hogy minden nyelv

nagyon egyszerűen generálható kontrollnyelvtannal, ha a kontrollnyelv bármilyen nyelv lehet.
Legyenek ugyanis a cı́mkézett szabályok
ft : S → tS (t ∈ T )
#: S → ε.
Jelölés: ft1 ···tk = ft1 · · · ftk , továbbá legyen fL = {fu | u ∈ L}. Ekkor C = fL # jó kontroll-
nyelv L-hez a fenti cı́mkézett nyelvtanban.
(ac) (ac)
4.5. tétel. Ci = Mi (i = 0, 1, 2, 3).
Bizonyı́tás. (⊇) Legyen G = hT, N, M, Si i. tı́pusú (előfordulásellenőrzéses) mátrixnyelv-

tan és legyen M j. mátrixának k. szabálya mj,k . A következő G0 = hT, N, F, P, lab, Ci kont-
rollnyelvtan L(G)-t generálja, ahol F = {fj,k | 1 ≤ j ≤ |M|, 1 ≤ k ≤ |mj |}, lab(fj,k ) = mj,k
|M|
és C = ({fj,1 · · · fj,|mj | }j=1 )∗ .
(⊆) Legyen G = hT, N, F, P, lab, Ci i. tı́pusú (előfordulásellenőrzéses) kontrollnyelv-
tan. Készı́tünk egy G0 = hT, N 0 , M, S 0 i i. tı́pusú (előfordulásellenőrzéses) mátrixnyelvtant,
melyre L(ac) (G0 ) = L(ac) (G).
Mivel C 3. tı́pusú, ezért létezik olyan A = hQ, F, δ, q0 , V i véges determinisztikus au-
tomata, melyre L(A) = C.
29
Legyen N 0 = N ∪ {Aq }A∈N,q∈Q . M = {m0 } ∪ {mA,B,f,q }A,B∈N,f ∈F,q∈Q ∪
{mA,f,q }A∈N,f ∈F,q∈Q , ahol
m0 : [S 0 → Sq0 ]
mA,B,f,q : [Aq → A, lab(f ), B → Bδ(q,f ) ] (jo(lab(f )) 6∈ T ∗ )
mA,f,q : [Aq → A, lab(f )] (jo(lab(f )) ∈ T ∗ , δ(q, f ) ∈ Vb ),
ahol az előfordulásellenőrzés nélküli esetben Vb = V , mı́g az előfordulásellenőrzéses esetben

Vb = {q ∈ Q | δ(q, σ) ∈ V, valamely σ csupa pontozott szabályok cı́mkéiből álló sorozatra}
(itt δ valójában a δ függvény szokásos kiterjesztése szavakra).
σ σ
u ∈ L(ac) (G) ⇐⇒ ∃ σ ∈ C, S −→ u ⇐⇒ ∃ σ ∈ F ∗ , δ(q0 , σ) ∈ V, S −→ u.
G(,ac) G(,ac)
A δ(q0 , σ) ∈ V feltétel ellenőrzése a mátrixnyelvtanban úgy történik, hogy az automata
aktuális állapotát az aktuális mondatforma egy tetszőlegesen választott nyelvtani jelének
indexében tároljuk, azaz egy G-beli
f1 f2 fk
S → α1 → · · · → αk = u
G G G
levezetésnek megfelel egy G0 -beli
m m m
S →0 Sq0 −→ 1
α
b1 −→ 2
· · · −→`
α
b` = u
G G0 G0 G0
levezetés, ahol az előfordulásellenőrzés nélküli esetben ` = k, mı́g az előfordulásellenőrzéses
esetben ` ≤ k és α` = · · · = αk , f`+1 , . . . , fk pontozott szabályok cı́mkéi továbbá mindkét
esetben minden 1 ≤ i ≤ ` − 1-re α bi αi -nek egy olyan variánsa, ahol pontosan egy nyelvtani
jel indexelt, és ez az index δ(q0 , f1 · · · fi ).
Mivel α` nem tartalmaz nyelvtani jelet, ezért m` egy 3. fajtájú mátrix, ı́gy
δ(δ(q0 , f1 · · · f`−1 ), f` ) ∈ V , mely az előfordulásellenőrzéses esetben is azzal ekvivalens, hogy
b
δ(q0 , f1 · · · fk ) ∈ V .
Mivel terminális szavaknak az összes G0 -beli levezetése fenti alakú, ezért L(ac) (G0 ) =
L(ac) (G).
A bizonyı́tás mindkét részében G0 ugyanolyan tı́pusú, mint G. 2
5. Indexelt nyelvtanok
Motiváció: Tekintsük a kifejezések fogalmának BNF-fel való leı́rását.
hKifejezési → hTagihAddopihKifejezési | hTagi

hTagi → hElemihMpopihElemi | hElemi
hElemi → hAzonosı́tói | hKonstansi | (hKifejezési).
Azonban pédául az hUtası́tási → IFhKifejezésiTHENhUtası́tási szabályban nem ı́rhatunk
akármilyen kifejezést hKifejezési helyére, csak logikai kifejezést. Hasonlóan egy számlálós
ciklus paraméterei csak egész kifejezések lehetnek. Egy lehetőség ennek megoldására, hogy
adott tı́pusú kifejezéseket definiálunk.
hLogikaiKifejezési → hLogikaiKifejezésihLogikaiAddopihLogikaiKifejezési |
hLogikaiTagi
hLogikaiTagi → hLogikaiElemihLogikaiMpopihLogikaiElemi | hLogikaiElemi
hLogikaiElemi → hLogikaiAzonosı́tói | hLogikaiKonstansi | (hLogikaiKifejezési)
hEgészKifejezési → hEgészKifejezésihEgészAddopihEgészKifejezési | hEgészTagi
hEgészTagi → hEgészElemihEgészMpopihEgészElemi | hEgészElemi
hEgészElemi → hEgészAzonosı́tói | hEgészKonstansi | (hEgészKifejezési)
Egy másik lehetőség a kifejezés fogalmának indexében jelölni a tı́pust.
hLogikai if utası́tási → IFhKifejezésiL THENhUtası́tási.
A tulajdonságok öröklődnek a fogalmakra, de a terminálisokra nem.
hKifejezésiL → hTagiL hAddopiL hKifejezésiL → hElemiL hAddopiL hKifejezésiL →

xhAddopiL hKifejezésiL → . . .
Persze hAddopi → + | − | ∨ helyett most hAddopiE → + | −, hAddopiL → ∨ szerepel.

Általában fogalmak tulajdonságait jelölhetjük az indexben. Amennyiben a terminálisok,
fogalmak és indexek halmaza páronként diszjunkt, akkor nem is kell az indexet indexbe
tenni, egyszerűen a fogalmat jobbról konkatenáljuk az indexszel.
30
31
5.1. definı́ció. Egy G = hT, N, F, P, Si ötöst indexelt nyelvtannak nevezünk, ha a követ-
kezők teljesülnek. T , N , F páronként diszjunkt véges halmazok. F elemeit indexeknek
nevezzük. Továbbá hT, N 0 , P, Si környezetfüggetlen nyelvtan, ahol N 0 = N F ∗ .
5.2. definı́ció. Legyen α ∈ (T ∪ N F ∗ )∗ , azaz α = u0 A1 σ1 u1 A2 σ2 · · · un−1 An σn un , vala-

mely n ∈ N-re ahol ui ∈ T ∗ (0 ≤ i ≤ n), Ai ∈ N (1 ≤ i ≤ n), σi ∈ F ∗ (1 ≤ i ≤ n).
Az α mondatformából σ ∈ F ∗ teljes öröklődésével kapott mondatforma n = 0 esetén α,
különben
α ←σ := u0 A1 σ1 σu1 A2 σ2 σ · · · un−1 An σn σun .

Az α mondatformából σ ∈ F ∗ legbal öröklődésével kapott mondatforma n = 0 esetén α,
különben
←σ
α lb := u0 A1 σ1 σu1 A2 σ2 · · · un−1 An σn un .
A teljes illetve legbal öröklődés, mint művelet legyen alacsonyabb prioritású a konkate-
nációnál.
←gf
Példa: Af 2 aBf C ←gf = Af 2 gf aBf gf Cgf , mı́g Af 2 aBf C lb = Af 2 gf aBf C.
5.3. definı́ció. α-ból teljes öröklődéssel közvetlenül levezethető β mondatforma ( α, β ∈

(T ∪ N F ∗ )∗ ), ha következőek teljesülnek.
α → β ⇐⇒ α = α1 Aσα2 , β = α1 q ←σ α2 , α1 , α2 ∈ (T ∪ N F ∗ )∗ , A → q ∈ P, A ∈
G
N F ∗ , q ∈ (T ∪ N F ∗ )∗ .
5.4. definı́ció. α-ból legbal öröklődéssel közvetlenül levezethető β mondatforma ( α, β ∈

(T ∪ N F ∗ )∗ ), ha következőek teljesülnek.
←σ
α −→ β ⇐⇒ α = α1 Aσα2 , β = α1 (qα2 ) lb , α1 ∈ T ∗ , α2 ∈ (T ∪ N F ∗ )∗ , A → q ∈
G,lb
P, A ∈ N F ∗ , q ∈ (T ∪ N F ∗ )∗ .
∗ ∗
Tehát a legbal öröklődéss levezetés egyben legbal levezetést is jelent. A →, −→ közvetett
G G,lb
levezetéseket a →, −→ közvetlen levezetések reflexı́v, tranzitı́v lezártjaként értelmezzük.
G G,lb
5.5. definı́ció. A G = hT, N, F, P, Si indexelt nyelvtan által teljes öröklődéssel illetve legbal
∗
öröklődéssel generált nyelv L(lb) (G) = {u ∈ T ∗ | S −→ u}.
G,(lb)
Példák:
1. Legyen G1 = h{a, b, c}, {S, S 0 , A, B, C}, {f, g}, P1 , Si a következő indexelt nyelvtan.
P1 szabályai:
32 5. Indexelt nyelvtanok
S −→ S 0 g S 0 −→ ABC Bf −→ bB Ag −→ ε
S 0 −→ S 0 f Af −→ aA Cf −→ cC Bg −→ ε
Cg −→ ε
Egy teljes öröklődéses levezetés:
S → (S 0 g) ←ε = S 0 g → (S 0 f ) ←g = S 0 f g → (S 0 f ) ←f g = S 0 f f g → (ABC) ←f f g =
Af f gBf f gCf f g → Af f g(bB) ←f g Cf f g = Af f gbBf gCf f g → a2 b2 c2 .
∗
L(G1 ) = {an bn cn | n ≥ 1}.
2. G2 = hT, {S, S 0 , A}, {ft }t∈T , P2 , Si. P2 szabályai:
S −→ S 0 g S 0 −→ AA Ag −→ ε
S 0 −→ S 0 ft (t ∈ T ) Aft −→ tA
L(G2 ) = {uu | u ∈ T ∗ }.
3. G3 = h{a}, {S, I, A}, {f, g}, P3 , Si. P3 szabályai:
S −→ Ig I −→ ε Ag −→ ε
I −→ aAAIf Af −→ aA
k
S → Ig → αIf k g. Teljes indukcióval belátható, hogy à (α) + `f (α) = k 2 . à (ε) +
`f (ε) = 02 αIf k g → α(aAAIf ) ←f g = αaAf k gAf k gIf k+1 g, melyre à (α) + `f (α) =
k
2
k 2 + k + k + 1 = (k + 1)2 . Tehát L(G3 ) = {an | n ∈ N}.
4. G4 = h{a}, {S, I, B, D, E, V }, {f, g}, P4 , Si. P4 szabályai:
S −→ If g Df −→ DBf f V g −→ ε
I −→ DI Dg −→ Eg E −→ ε
I −→ V V f −→ aV B −→ ε
Egy legbal öröklődéses levezetés:

←ε ←f g ←g
S → (If g) lb = If g → (DI) lb = Df gI → (DBf f I) lb = DgBf f I →
←ε ←g ←f f g
(EgBf f I) lb = EgBf f I → (Bf f I) lb = Bf f gI → (I) lb = If 2 g.
∗ ∗ ∗ k k k k
If 2 g → If 4 g → · · · → If 2 g → V f 2 g → a2 . Llb (G4 ) = {a2 | k ∈ N}.
33
(lb)
LInd = {L | ∃ G indexelt nyelvtan, melyre L(lb) (G) = L}.
5.6. tétel. L2 ⊂ LInd ⊆ Llb

Ind = L0 .
∗ ∗
Bizonyı́tás. Mivel 2. tı́pusú nyelvtanokban S → u ⇔ S −→ u és minden nyelvtan
G G,lb
tekinthető indexelt nyelvtannak az F = ∅ választással, ezért L2 ⊂ LInd és L2 ⊂ Llb
Ind , a
valódi tartalmazást a fenti példák mutatják.
Legyen tehát G = hT, N, P, Si ∈ G0 nyelvtan, készı́tünk G0 = hT, N 0 , F, P 0 , S 0 i indexelt
nyelvtant, melyre Llb (G0 ) = L(G). Legyen N 0 = {S 0 , B, E, I, L, V } és F = {fZ }Z∈T ∪N ∪
{g}. Ha Z1 Z2 · · · Zk ∈ (T ∪ N )∗ , akkor vezessük be a következő jelölést: fZ1 Z2 ···Zk :=
fZ1 fZ2 · · · fZk . A P 0 szabályrendszer:
S 0 → IfS g E→ε
I → LI | V B→ε
LfZ → LBfZ (Z ∈ T ∪ N ) V ft → tV (t ∈ T )
Lfp → Efq (p → q ∈ P) V g → ε.
∗ ∗
Elegendő belátni, hogy S 0 −→
0
Ifα g ⇐⇒ S → α, hiszen az I → V szabály al-
G ,lb G
kalmazása után visszakaphatjuk az I indexében tárolt mondatformát, ha az terminális
sorozat. Egy α = α1 pα2 → α1 qα2 = β G-beli lépés szimulálása G0 -ben öt lépésben
történik. Az első lépésben az Ifα g mondatformából Lfα gI lesz az I → LI szabály al-
kalmazásával. Mivel ı́gy most L lett a legbal nyelvtani jel, ezért most csak arra (vagy
indexelt változatára) tudunk szabályt alkalmazni. Második lépésben az LfZ → LBfZ
szabályok k-szori alkalmazásával (akár k = 0 is lehet) leválasztunk α-ból balról egy α1 részt,
és ez bekerül az egymás utáni B-k indexébe fordı́tott sorrendben, a kapott mondatforma
Lfα0 gBfZk · · · BfZ1 I, ahol α = α1 α0 = Z1 · · · Zk α0 . A harmadik lépésben akkor tudunk
továbblépni, ha α0 -nek prefixe valamely G-beli szabály baloldala, legyen ez a szabály p → q,
azaz α0 = pα2 . Ekkor az Lfp → Efq szabály alkalmazásával legbal öröklődéssel kapott
←fα g
mondatforma (Efq ) lb 2 BfZk · · · BfZ1 I = Efqα2 gBfZk · · · BfZ1 I. A negyedik és ötödik
lépésben az E → ε illetve B → ε szabályok alkalmazásával előbb BfZk qα2 g · · · BfZ1 I-t majd
a B-ket sorra balról jobbra (a levezetésnek legbal levezetésnek kell lennie) eltüntetve végül
megkapjuk IfZ1 ···Zk qα2 g = Ifβ g-t (eltűnő nyelvtani jel indexe a megmaradó legbaloldalibb
nyelvtani jelre öröklődik).
Legyen G = hT, N, F, P, Si indexelt nyelvtan, készı́tünk egy G0 = hT, N 0 , P 0 , S 0 i ∈ G0
nyelvtant, melyre L(G0 ) = L(G). Jelölje M a P-beli szabályok jobboldalán előforduló N -
beli jelek maximumát. Legyen N 0 = N ∪ F ∪ {Zi }0≤i≤M ∪ {Xf,i }f ∈F,0≤i≤M ∪ {S 0 , R}. P 0
szabályai a következők:
34 5. Indexelt nyelvtanok
S 0 → SR
A → qZj (A → q ∈ P, j a q-ban levő N -beli jelek száma)
Zj f → Xf,j−1 · · · Xf,1 Xf,0 Zj (f ∈ F, 0 ≤ j ≤ M )
tXf,i → Xf,i t (t ∈ T, f ∈ F, 0 ≤ i ≤ M )
gXf,i → Xf,i g (f, g ∈ F, 1 ≤ i ≤ M )
Y Xf,i → Xf,i−1 Y (Y ∈ N, f ∈ F, 1 ≤ i ≤ M )
gXf,0 → gf (f, g ∈ F )
Y Xf,0 → Y f (Y ∈ N, f ∈ F )
Zj t → t (t ∈ T, 0 ≤ j ≤ M )
Zj Y → Y (Y ∈ N ∪ {R}, 0 ≤ j ≤ M )
R → ε.
Egy α1 Aσα2 → α1 q ←σ α2 levezetési lépést (α1 , α2 , q ∈ (T ∪ N F ∗ )∗ , A ∈ N, F ∈ F ∗ ) egy

G
α1 Aσα2 R → α1 q ←σ α2 R levezetéssel szimulálunk a G0 0. tı́pusú nyelvtanban.
∗
G
Legyen q = u1 A1 σ1 · · · uj Aj σj uj+1 , ahol ui ∈ T ∗ (i ≤ j + 1), Ai ∈ N, σi ∈ F ∗ (i ≤ j)

továbbá σ = f σ 0 , (f ∈ F, σ, σ 0 ∈ F ∗ ).
Ekkor G0 -ben σ = ε esetén α1 Aσα2 R → α1 qZj α2 R → α1 qα2 R. σ 6= ε esetén:

α1 Aσα2 R → α1 qZj σα2 R
→ α1 u1 A1 σ1 · · · uj Aj σj uj+1 Xf,j−1 · · · Xf,1 Xf,0 Zj σ 0 α2 R
∗
→ α1 u1 A1 σ1 Xf,0 · · · uj Aj σj Xf,0 uj+1 Zj σ 0 α2 R
∗
→ α1 u1 A1 σ1 f · · · uj Aj σj f uj+1 Zj σ 0 α2 R
∗
→ α1 u1 A1 σ1 σ · · · uj Aj σj σuj+1 Zj α2 R
→ α1 u1 A1 σ1 σ · · · uj Aj σj σuj+1 α2 R = α1 q ←σ α2 R,
továbbá a Zj , Xf,i nyelvtani jeleket máshogy nem lehet eltüntetni, azaz G0 -ben minden
S 0 -ből való terminális szót eredményező levezetés G-beli levezetési lépések szimulációjának
sorozata, tehát L(G0 ) = L(G).
Most készı́tünk a G = hT, N, F, P, Si indexelt nyelvtanhoz G0 módosı́tásával egy

G00 = hT, N 00 , P 00 , S 0 i ∈ G0 nyelvtant, melyre L(G00 ) = Llb (G). Legyen
N 00 = N 0 ∪ N
b ∪ {X 0 , X 00 }f ∈F , ahol N
f f
b = {A} b A∈N . Egy q ∈ (T ∪ N F ∗ )∗ indexelt mondat-
forma esetén vezessük be az alábbi jelölést:

u A
1 1 σ1 q ha q = u1 A1 σ1 q 0 (u1 ∈ T ∗ , A1 ∈ N, σ1 ∈ F ∗ , q 0 ∈ (T ∪ N F ∗ )∗ )
b 0
qb = .
q ha q ∈ T ∗
P 00 szabályai:
35
S 0 → SRb
Ab → qbZj (A → q ∈ P, j a q-ban levő N -beli jelek száma)
Zj f → Xf,j−1 Zj (f ∈ F, 1 ≤ j ≤ M )
tXf,i → Xf,i t (t ∈ T, f ∈ F, 0 ≤ i ≤ M )
gXf,i → Xf,i g (f, g ∈ F, 1 ≤ i ≤ M )
Y Xf,i → Xf,i−1 Y (Y ∈ N, f ∈ F, 1 ≤ i ≤ M )
gXf,0 → gf (f, g ∈ F )
Yb Xf,0 → Yb f (Yb ∈ Nb, f ∈ F )
Zj t → t (t ∈ T, 1 ≤ j ≤ M )
Zj Y → Y (Y ∈ N ∪ {R}, 1 ≤ j ≤ M )
Z0 Y → Yb (Y ∈ N )
Z0 R → R
Z0 f → Z0 Xf0 (f ∈ F )
Xf0 t → tXf0 (t ∈ T, f ∈ F )
Xf0 g → gXf0 (f, g ∈ F )
Xf0 Y → Y Xf00 (Y ∈ N, f ∈ F )
Xf0 R → R (f ∈ F )
Xf00 g → gXf00 (f, g ∈ F )
Xf00 t → f t (t ∈ T, f ∈ F )
Xf00 Y → f Y (Y ∈ N ∪ {R}, f ∈ F )
R → ε.
∗ ∗
Az előzőhöz hasonlóan látható, hogy S 0 −→
0
u ⇐⇒ S −→ u.
G G,lb
2
?
Megjegyzés: LInd ⊂ Llb
Ind , nem ismeretes.
6. Attribútumnyelvtanok
6.1. definı́ció. Egy G = hT, N, P, Si négyest attribútumnyelvtannak nevezünk, ha a követ-
kezők teljesülnek. N minden eleme egy rekord tı́pus. A rekord mezőneveit attribútumoknak
nevezzük és az A ∈ N nyelvtani jelhez tartozó attribútumokat Attr(A)-val jelöljük. Ha
hangsúlyozni akarjuk, hogy egy attr ∈ Attr(A) attribútum az A nyelvtani jelhez tartozik,
akkor A. attr-t ı́runk. A rekordmezőkhöz hozzá van rendelve egy értékhalmaz (domain), egy
rekormező értékei a hozzárendelt értékhalmazból kerülhetnek ki. P nyelvtani szabályok véges
halmaza. Minden szabály 2 részből áll, egy P 2. tı́pusú nyelvtani szabályból és egy ϕ(P )
elsőrendű logikai állı́tásból, melynek szabad változói az adott szabályban szereplő nyelvtani
jelek attribútumai. Ha egy nyelvtani jel egy szabályban többször is szerepel, akkor ezeket az
előfordulásokat a logikai állı́tásban megkülönböztetetten kell kezelni.
6.2. definı́ció. t a G = hT, N, P, Si attribútumnyelvtanhoz tartozó szemantikus fa, ha t a

G-hez, mint közönséges nyelvtanhoz tartozó szintaxisfa és minden belső pontjához hozzáren-
deljük a benne levő nyelvtani jel, mint rekord tı́pus egy lehetséges értékét.
6.3. definı́ció. t helyes szemantikus fa, ha minden c belső csúcs esetén a c-be és gyer-
mekeibe ı́rt értékek kielégı́tik ϕ(P )-t, ahol P a c-hez és gyermekeihez tartozó szintaktikus
szabály.
6.4. definı́ció. A G = hT, N, P, Si attribútumnyelvtan által generált nyelv
L(G) = {u ∈ T ∗ | ∃ t helyes szemantikus fa, melyre gy(t) = S, front(t) = u}.
LAttr = {L | ∃ G attribútumnyelvtan, melyre L(G) = L}.
Példák: Egy szabályban egy adott nyelvtani jel különböző előfordulásaira a nyelvtani jel
indexelésével hivatkozunk. Tehát az 1 index a szabályban balról jobbra első, 2 a második
előfordulásra hivatkozik, és ı́gy tovább.
1. Programozási nyelvek szintaxisa nem ı́rható le csupán 2. tı́pusú nyelvtannal a dek-

laráció és a neki megfelelő azonosı́tóhasználat miatt, ugyanis {uu | u ∈ T ∗ } 6∈ L2 .
Vizsgáljuk meg, hogyan lehetne a deklarációkat leı́rni attribútumnyelvtanokkal. Egy
36
37
leegyszerűsı́tett modellt vizsgálunk, ahol a deklarációs rész vesszővel elválasztott sza-
vak sorozata, a végrehajtható rész is, azzal a különbséggel, hogy a végrehajtható rész
minden eleme elő kell forduljon a deklarációs részben is. Az egyes részeket # jellel
határoljuk. A modellt leı́ró G attribútumnyelvtan szabályai:
P → #D#V # D. sztábla = V. sztábla

D→A D. sztábla = {A. szó}
D → A, D D1 . sztábla = D2 . sztábla ∪{A. szó}
A→a A. szó = a (a ∈ T )
A → aA A1 . szó = aA2 . szó (a ∈ T )
V →A A. szó ∈ V. sztábla
V → A, V V1 . sztábla = V2 . sztábla ∧ A. szó ∈ V1 . sztábla,
∗
ahol az sztábla attribútum értékhalmaza 2T , a szóé T ∗ .
Például u = #a, ba#ba, a, ba# ∈ L(G). Egy u-hoz tartozó helyes szemantikus fa a
6.1. ábrán látható.
# {a, ba} D # V {a, ba} #
a , ba , {a, ba}
A D {ba} A V
{a, ba}
ba a a ,
a A b A A V
b Aa a a A ba
a b Aa
6.1. ábra. Egy #a, ba#ba, a, ba#-hoz tartozó helyes szemantikus fa a deklarációk attribútum-
nyelvtanában.
38 6. Attribútumnyelvtanok
2. G = h{a, b, c}, {S, A, B, C}, P, Si, ahol P:
S → ABC A. szám = B. szám = C. szám

A → aA A1 . szám = A2 . szám +1
A→a A1 . szám = 1
B → bB B1 . szám = B2 . szám +1
B→b B1 . szám = 1
C → cC C1 . szám = C2 . szám +1
C→c C1 . szám = 1
S-nek 0, A-nak, B-nek, C-nek 1 attribútuma van, mindhárom attribútumnév “szám”.
dom(A. szám) = dom(B. szám) = dom(C. szám) = N.
L(G) = {an bn cn | n ≥ 1}.
3. G = h{a}, {S, A, B}, P, Si, ahol P:
S → AB A. szám = (B. szám)2

A → aA A1 . szám = A2 . szám +1
A→ε A. szám = 0
B→B B1 . szám = B2 . szám +1
B→ε B. szám = 0
dom(A. szám) = dom(B. szám) = N.

2
L(G) = {an | n ∈ N}.
6.5. tétel. LAttr ⊇ L0 .
Bizonyı́tás. Azt kell belátni, hogy tetszőleges G = hT, N, P, Si ∈ G0 nyelvtanhoz létezik

G0 attribútumnyelvtan, melyre L(G0 ) = L(G). Legyen P = {p1 → q1 , . . . , pn → qn }. Legyen
a G0 = hT, {S 0 , A, B, C} ∪ {XZ }Z∈T ∪N , P 0 , S 0 i nyelvtan minden nyelvtani jelének egyetlen
szó attribútuma, melynek tı́pusa (T ∪ N )∗ . A szabályok:
39
S 0 → CB S 0 . szó = C. szó = B. szó

C → tC C1 . szó = tC2 . szó (t ∈ T )
C→ε C. szó = ε
B → AAAAAAB B1 . szó = A1 . szó A2 . szó A3 . szó ∧ B2 . szó = A4 . szó A5 . szó A6 . szó ∧
A1 . szó = A4 . szó ∧ A3 . szó A6 . szó ∧ (A5 . szó = p1 ∧ A2 . szó = q1 ∨
A5 . szó = p2 ∧ A2 . szó = q2 ∨ . . . ∨ A5 . szó = pn ∧ A2 . szó = qn )
A → XZ A A1 . szó = ZA2 . szó (Z ∈ T ∪ N )
XZ → ε XZ . szó = Z (Z ∈ T ∪ N )
A→ε A. szó = ε.
A B → AAAAAAB alakú szabályok a G-beli levezetések szimulációját végzik, a mon-

datformának, mint B attribútumának alulról felfelé való szintézisével. Az S 0 → CB szabály
azt garantálja, hogy a levezetett terminális szó valóban S-ből kiinduló G-beli levezetés
eredménye. 2
Megjegyzés: Ha minden domain véges, akkor konstruálható olyan 2. tı́pusú nyelvtan,
mely az attribútumnyelvtan által leı́rt nyelvet generálja, ilyenkor a nyelv 2. tı́pusú. (Az új
nyelvtani jelek az eredeti nyelvtani jelek minden lehetséges értékükkel cı́mkézve, a szabályok
pedig olyanok, hogy a bennük lévő nyelvtani jelek cı́mkéi kielégı́tik az eredeti szabályhoz
tartozó állı́tást.)
7. Kétszintű nyelvtanok
Az ALGOL 68 leı́rásához van Wijngaarden holland matematikus használt először kétszintű
nyelvtanokat, melyeket róla elnevezve van Wijngaarden nyelvtanoknak vagy W-nyelvtanok-
nak is neveznek.
Motiváció: Tekintsük a lista fogalmának BNF-fel való leı́rását.
1. hegész listai → hegészi | hegészi, hegész listai
hvalós listai → hvalósi | hvalósi, hvalós listai
Tekintsük változónak azt, hogy milyen lista. Ekkor a lista fogalma következőképpen
ı́rható le a W-nyelvtanban.
hX listai → hXi | hXi, hX listai hiperszabály
X → egész | valós | duplapontos metaszabály
A hiperszabályok adják meg a szabályok sémáját, mı́g a metaszabályok magukról a
szabályokról szóló szabályok.
2. Adott hosszúságú listák esetén a hosszat unárisan számoljuk, pálcikák ( ) segı́tségével.

hY hosszú X listai → hXi, hY hosszú X listai hiperszabály
h hosszú X listai → hXi hiperszabály
X → egész | valós | duplapontos metaszabály
Y → | Y metaszabály
A tényleges szabályokat példányosı́tással kapjuk. Például legyen X=egész és Y = . A
példányosı́tással kapott szabályok:
h hosszú egész listai → hegészi, h hosszú egész listai

h hosszú egész listai → hegészi, h hosszú egész listai
h hosszú egész listai → hegészi
7.1. definı́ció. G = hG1 , G2 i kétszintű nyelvtan (W-nyelvtan), ha
40
41
• G2 = hM T, M N, M Pi metanyelvtan, 3. tı́pusú kezdőjel nélküli nyelvtan.
M T elemeit metaterminálisoknak, M N elemeit metanyelvtani jeleknek, M P elemeit
metaprodukciós szabályoknak nevezzük.
• G1 = hT, HN, HP, Si hipernyelvtan.

HN ⊆ (M T ∪ M N )∗ véges nyelv, S ∈ (M T )+ kezdőjel. HN elemeit hipernyelvtani
jeleknek, HP elemeit hiperprodukciós szabályoknak nevezzük. HP 2. tı́pusú szabályok
véges halmaza.
Konvencionálisan a terminálisokat és a metaterminálisokat kisbetűkkel, a metanyelvtani

jeleket nagybetűvel jelöljük, a hipernyelvtani jeleket h és i közé tesszük.
7.2. definı́ció. Legyen hG1 , G2 i kétszintű nyelvtan, továbbá L(G2 , Y ) = { α ∈ (M T )∗ |

∗
Y → α}. Egy h : (M T ∪ M N )∗ → (M T )∗ homomorfizmust példányosı́tásnak nevezünk, ha
G2
minden t ∈ M T esetén h(t) = t valamint minden Y ∈ M N esetén h(Y ) ∈ L(G2 , Y ). A
h homomorfizmus természetes módon kiterjeszthető (M T ∪ M N )∗ részhalmazaira, ı́gy HN
elemeire és ı́gy a HP-beli hiperszabályokra is. Jelölje Peld = Peld(G) a G nyelvtan összes
példányosı́tásainak halmazát. Definiálunk egy G
b ∞ sok szabállyal rendelkező nyelvtant, G
b=
∗
hT, {h(HN )}h∈Peld , {h(HP)}h∈Peld , Si. L(G) = {u ∈ T | S → u}. A G kétszintű nyelvtan
b ∗
G
b
által generált nyelv L(G) = L(G).
b
LW = {L | ∃ G kétszintű nyelvtan, melyre L(G) = L}.
Példák:
1. Legyenek a G(1) W-nyelvtan hiperszabályai:

hSi → hX hosszú a blokkihX hosszú b blokkihX hosszú c blokki
hX hosszú Y blokki → hY ihX hosszú Y blokki
h hosszú Y blokki → ε
hai → a, hbi → b, hci → c
Metaszabályai:
X → ε| X
Y → a|b|c
A G(1) W-nyelvtan által generált nyelv: L(G(1) ) = {an bn cn | n ≥ 0}.
42 7. Kétszintű nyelvtanok
2. Legyenek a G(2) W-nyelvtan hiperszabályai:

hSi → hX példányihX példányi
hXt példányi → hX példányit (t ∈ T )
h példányi → ε
Metaszabályai:
X → tX | ε (t ∈ T )
AG (2)
W-nyelvtan által generált nyelv: L(G(2) ) = {uu | u ∈ T ∗ }.
7.3. tétel. LW ⊇ L0 .
Bizonyı́tás. Legyen G = hT, N, P, Si ∈ G0 ahol P = {p1 → q1 , . . . , pn → qn }. Készı́tünk

egy G0 = hG1 , G2 i W-nyelvtant, melyre L(G0 ) = L(G).
Feltehető, hogy {V, E, X} ∩ N = ∅. Legyen M T = T ∪ N , M N = {V, E, X} és HN =
{hEpi V i}i∈{1,...,n} ∪ {hEqi V i}i∈{1,...,n} ∪ {Xt}t∈T ∪ {X, ε}. Legyen G2 = hM T, M N, M Pi,
és G1 = hT, HN, HP, hSii, ahol M P metaszabályai:
E → ZE | ε (Z ∈ T ∪ N )
V →E
X → tX | ε (t ∈ T ),
mı́g HP hiperszabályai:
hEpi V i → hEqi V i i ∈ {1, . . . , n}

hXti → hXit (t ∈ T )
hi → ε
A példányosı́tás során E-ből, V -ből tetszőleges T ∪ N feletti mondatforma, X-ből tet-

szőleges, T ábécé feletti szó lehet, ı́gy
{h(HP)}h∈Peld ={hγ1 pi γ2 i → hγ1 qi γ2 i | γ1 , γ2 ∈ (T ∪ N )∗ , pi → qi ∈ P} ∪
.
{ht1 · · · tk i → ht1 · · · tk−1 itk | t1 · · · tk ∈ T + } ∪ {h i → ε}
Könnyen látható, hogy L(G0 ) = L(G) b = L(G). 2
8. Párhuzamos nyelvtanok
Az eddig látott modellekben a szabályok alkalmazása valamilyen megadott módon szekvenci-
álisan történt. Most tekintsünk olyan rendszereket, ahol a szabályalkalmazás párhuzamosan
történik.
Általában egy G párhuzamosan dolgozó rendszernél megköveteljük, hogy minden Z ∈
(T ∪ N )-re legyen átı́ró szabály, és ez a szabály legyen környezetfüggő. A terminálisokra
a t → t átı́rási szabályt vehetjük. Egy levezetési lépésben minden jelet kötelezően átı́runk
valamely rá vonatkozó szabállyal. A levezetés egy ax axiómával indul.
∗
Ekkor L(G) = {u ∈ T ∗ | ax → u}.
G,k
Példa: Aristid Lindenmayer 1968-ban a vörös algák növekedését modellezte párhuzamos

átı́ró rendszerrel. A modelljében egy sejtnek kilenc állapota volt. Az átı́ró szabályok:
1→23 4→25 7→8 [ →[

2→2 5→65 8→9[3] ]→ ]
3→24 6→7 9→9
Az 1 axiómából induló levezetés elemei:

1, 23, 224, 2225, 22265, 222765, 2228765, 2229[3]8765, 2229[24]9[3]8765,
2229[2265]9[225]9[24]9[3]8765, 2229[225]9[24]9[3]8765,
2229[22765]9[2265]9[225]9[24]9[3]8765,
2229[228765]9[22765]9[2265]9[225]9[24]9[3]8765,
2229[229[3]8765]9[228765]9[22765]9[2265]9[225]9[24]9[3]8765,
2229[229[24]9[3]8765]9[229[3]8765]9[228765]9[22765]9[2265]9[225]9[24]9[3]8
765, . . .
Az alga növekedése a 8.1. ábrán látható azzal a konvencióval, hogy egy [,] zárójelpár
közé ı́rt rész oldalágat jelent.
43
44 8. Párhuzamos nyelvtanok
5
5 6
5 6 7
5 6 7 8
5 3
6 7 8 4 9
5 3 2 5
6 7 8 9 4 9 2
1 3 4 5 3 2 2
6 7 8 9 9 9
2 2 2 2 2 2 2 2 2
2 2 2 2 2 2 2 2
2 2 2 2 2 2 2
8.1. ábra. Aristid Lindenmayer (1925-1989), magyar származású holland biológus, matematikus
eredetileg a vörös algák fejlődésének tanulmányozása során fedezte fel a 60-as évek végén a róla
elnevezett Lindenmayer-rendszereket.
8.1. Lindenmayer-rendszerek
∗ ∗
8.1. definı́ció. Legyenek X és Y ábécék. Egy σ : 2X → 2Y függvényt helyettesı́tésnek
nevezünk, ha a következők teljesülnek:
1. σ( Lλ ) = σ(Lλ ), (Λ tetszőleges indexhalmaz),

S S
λ∈Λ λ∈Λ
2. σ(L) = ∅ ⇐⇒ L = ∅, (L ⊆ X ∗ ),
3. σ(L1 L2 ) = σ(L1 )σ(L2 ) (L1 , L2 ⊆ X ∗ ),
4. σ({ε}) = {ε}.
σ véges helyettesı́tés, ha minden L ⊆ X ∗ véges nyelvre σ(L) véges. σ ε-mentes helyettesı́tés,

ha minden L ⊆ X ∗ esetén ε ∈ σ(L) ⇐⇒ ε ∈ L.
A helyettesı́tés tulajdonságai alapján elegendő a helyettesı́téseket az egyetlen egy 1-betűs

szót tartalmazó elemi nyelveken megadni, melyek képei az Y ábécé feletti nemüres nyelvek.
A továbbiakban ezen elemi nyelvekre az {t} =: t azonosı́tással élünk (ezzel az azonosı́tással
az egyetlen szót tartalmazó nyelvek esetében is élni fogunk). A helyettesı́tés nyilvánvalóan
a homomorfizmus általánosı́tása. Ha X = Y , akkor jelölje σ i (L) a helyettesı́tés i-edik
hatványát, melyet a σ 0 (L) = L, σ i (L) = σ(σ i−1 (L) (i ≥ 1) rekurzióval definiálunk.
Példa: X = Y = {x, y}, σ(x) = {x, ε}, σ(y) = {y}. σ(xxyy) = {xxyy, xyy, yy}. Ha
L = {u ∈ X ∗ | `x (u) = `y (u)}, akkor σ(L) = {u ∈ X ∗ | `x (u) ≤ `y (u)}.
Egy véges helyettesı́tést átı́rási szabályokkal is megadhatunk: α ∈ σ(x) ⇔ x → α.
8.1. Lindenmayer-rendszerek 45
8.2. definı́ció. Egy G = hT, σ, ω0 i rendszert Lindenmayer-rendszernek (0L-rendszernek,

∗
L-renszernek) nevezünk, ha T egy véges halmaz, a rendszer ábécéje, σ : T → 2T véges
helyettesı́tés, és ω0 ∈ T + egy T ábécé feletti nemüres szó, melyet axiómának nevezünk. Egy
S∞
G Lindenmayer-rendszer által felismert nyelv L(G) = i=0 σ i (ω0 ). A Lindenmayer-rendszer
determinisztikus (D0L-rendszer), ha minden t ∈ T esetén |σ(t)| = 1.
A G által felismert nyelvet a következőképpen is definiálhattuk volna. A σ helyettesı́tést

átı́rási szabályokkal adjuk meg, ekkor egy ilyen átı́rási szabályra azt mondjuk, hogy a
Lindenmayer-rendszer szabálya. Definiáljuk a levezetés fogalmát. α, β ∈ T ∗ esetén
(1)
α → β ⇐⇒ ∃t1 , . . . , tk ∈ T, γ1 , . . . , γk ∈ T ∗ , α = t1 · · · tk ,
G
α = γ1 · · · γk , t1 → γ1 , . . . , tk → γk szabály G-ben.
(n) (1) ∗
α → β, ha ∃γ0 , . . . γn ∈ T ∗ , hogy α = γ0 , γi−1 → γi (1 ≤ i ≤ n) és β = γn . α → β, ha
G G G
(n) (i)
valamely n ∈ N-re α → β. Ekkor nyı́lván α ∈ σ i (ω0 ) ⇐⇒ ω0 → α. Tehát L(G) = {u ∈
G G
∗
T ∗ | ω0 → u}.
G
0L := {L | ∃G 0L-rendszer, L(G) = L},
D0L := {L | ∃G D0L-rendszer, L(G) = L}.
Példák:
1. Lindenmayer algáinak növekedését leı́ró fenti σ szabályrendszer egy

h{1,2,3,4,5,6,7,8,9,[,]}, σ,1i D0L-rendszer.
2. MISS3 = h{x}, {x → ε, x → x2 , x → x5 }i 0L-rendszer, de nem D0L-rendszer.

L(MISS3 ) = {xi | i 6= 3}. Generáljuk az x → x2 szabály segı́tségével n lépésben az
n
x2 szót, ahol 2n ≥ i. Ezek után, ha i páros, akkor i/2 darab x-re alkalmazzuk az
x → x2 , a többire az x → ε szabályt. Ha i páratlan, akkor bi/2c − 2 (≥ 0) darab x-re
alkalmazzuk az x → x2 , 1 darab x-re az x → x5 , a többire az x → ε szabályt. Az
ı́gy kapott x-ek száma 2 · (bi/2c − 2) + 5 = 2 · bi/2c + 1 = i. Tehát i 6= 1, 3 esetén
ı́gy generálhatunk pontosan i darab x-et. 1 darabot is kaphatunk, hiszen ez maga az
axióma. x3 azonban nem kapható meg, hiszen az utolsó lépésben nem használhatjuk
az x → x5 átı́rást, a másik kettővel viszont x-nek csak páros hatványát lehet generálni.
i
3. EXP2 = h{x}, {x → xx}, xi. L(EXP2 ) = {x2 | i ≥ 0}.
4. LIN= h{a, b}, {a → ab, b → b}, ai. L(LIN) = {abi | i ≥ 0}.
5. FIB= h{a, b}, {a → b, b → ab}, ai.

FIB D0L-rendszer, azaz σ determinisztikus helyettesı́tés, tehát homomorfizmus. Jelölje
ωn az n. átı́rás után kapott szót. ω0 = a, ω1 = b, ω2 = ab = ω0 ω1 . Teljes indukcióval
belátjuk, hogy n ≥ 2 -re ωn = ωn−2 ωn−1 . Az n = 2 esetet már láttuk, az indukciós

lépés:
ωn+1 = σ(ωn ) = σ(ωn−2 ωn−1 ) = σ(ωn−2 )σ(ωn−1 ) = ωn−1 ωn .
Tehát `(ωn ) = `(ωn−2 ) + `(ωn−1 ), `(ω0 ) = 1, `(ω1 ) = 1. `(ωn )-re ugyanaz a rekurzió
teljesül, mint az (n + 1). Fibonacci számra, tehát `(ωn ) = Fn+1 , ahol Fn jelöli az n.
Fibonacci számot.
Teljes indukcióval hasonlóan látható, hogy `b (ωn ) = Fn (n ≥ 0) és à (ωn ) = Fn−1
(n ≥ 1).
6. SQU= h{a, b, c}, {a → abc2 , b → bc2 , c → c}, ai D0L-rendszer. Állı́tás: `(ωn ) = (n +

1)2 . Ez következik abból, ha belátjuk, hogy à (ωn ) = 1, `b (ωn ) = n, `c (ωn ) = n(n + 1),
hiszen 1 + n + n(n + 1) = (n + 1)2 . Teljes indukcióval bizonyı́tjuk.
à (ωn+1 ) = 1 · à (ωn ) + 0 · `b (ωn ) + 0 · `c (ωn ) = 1 · 1 + 0 · n + 0 · n(n + 1) = 1.
à (ωn+1 ) = 1 · à (ωn ) + 1 · `b (ωn ) + 0 · `c (ωn ) = 1 · 1 + 1 · n + 0 · n(n + 1) = n + 1.
`c (ωn+1 ) = 2 · à (ωn ) + 2 · `b (ωn ) + 1 · `c (ωn ) = 2 · 1 + 2 · n + 1 · n(n + 1) = (n + 1)(n + 2).
7. Nem létezik olyan G Lindenmayer-rendszer, melyre L(G) = {a, a2 }. Ugyanis, ha

∗ ∗ ∗
ω0 = a, akkor a → a2 , és ı́gy a2 → a4 , tehát a4 ∈ L(G). Mı́g ha ω0 = a2 , akkor a2 → a,
G G G
∗
de ekkor a → ε, mert az átı́rási szabályok környezetfüggetlenek, tehát ε ∈ L(G).
G
8.3. definı́ció. Egy G = hT, N, σ, ω0 i rendszert kiterjesztett (extended) Lindenmayer-rend-

szernek (E0L-rendszernek) nevezünk, ha G (T ∪ N ) feletti 0L-rendszer. Egy G kiterjesztett
S∞
Lindenmayer-rendszer által felismert nyelv L(G) = ( i=0 σ i (ω0 )) ∩ T ∗ (illetve, ami ezzel
∗
ekvivalens L(G) = {u ∈ T ∗ | ω0 → u}). G kiterjesztett determinisztikus Lindenmayer-
G
rendszer (ED0L-rendszer), ha (T ∪ N ) feletti D0L-rendszer.
Példa: SYNC= h{a, b, c}, {A, B, C, A0 , B 0 , C 0 , F }, σ, ABCi Az átı́ró szabályok:
A → AA0 A→a A 0 → A0 A0 → a a→F

B → BB 0 B→b B0 → B0 B0 → b b→F
C → CC 0 C→c C0 → C0 C0 → c c→F F →F
Az F zsákutcának az a szerepe, hogy terminális szó generálásához egyszerre kelljen az

összes nemterminálist átı́rni. Hiszen ha egy átı́rásnál marad nemterminális, akkor terminális
sorozat generálásához kell, hogy legyen legalább még egy átı́ró lépés, de ekkor a terminálisok
megváltoztathatatlanul átı́ródnak F -re, ı́gy viszont mégse kaphatunk terminális sorozatot.
Ha viszont nem ı́runk át nemterminálisokat terminálisokra, akkor n átı́rás után determin-
isztikusan A(A0 )n B(B 0 )n C(C 0 )n -t kaphatunk csak. Tehát L(G) = {an bn cn | n ≥ 1}.
8.1. Lindenmayer-rendszerek 47
E0L := {L | ∃G E0L-rendszer, L(G) = L},

ED0L := {L | ∃G ED0L-rendszer, L(G) = L}.
8.4. definı́ció. Egy G = hT, σ1 , . . . , σm , ω0 i rendszert táblázatos Lindenmayer-rendszernek

(táblázatos L-renszernek, T 0L-renszernek) nevezünk, ha minden 1 ≤ i ≤ m esetén Gi =
(1)
hT, σi , ω0 i 0L-rendszer. α, β ∈ T ∗ esetén α → β ⇐⇒ α → β. α → β ⇐⇒ ∃ 1 ≤ i ≤
G,i Gi G
∗
m, α → β. α → β ⇐⇒ ∃ n, γ0 , . . . , γn ∈ T ∗ , hogy α = γ0 , γi−1 → γi (1 ≤ i ≤ n) és β = γn .
G,i G G
∗
L(G) = {u ∈ T | ω0 → u} a táblázatos Lindenmayer-rendszer által generált nyelv. G
∗
G
determinisztikus táblázatos Lindenmayer-rendszer (T D0L-rendszer), ha minden 1 ≤ i ≤ m
esetén Gi D0L-rendszer.
T 0L := {L | ∃G T0L-rendszer, L(G) = L},

T D0L := {L | ∃G TD0L-rendszer, L(G) = L}.
8.5. definı́ció. Egy G = hT, N, σ1 , . . . , σm , ω0 i rendszert kiterjesztett (extended) táblázatos

Lindenmayer-rendszernek (kiterjesztett T 0L-renszernek, ET 0L-renszernek) nevezünk, ha G
(T ∪ N ) feletti T 0L-rendszer. Egy G ET 0L-rendszer által felismert nyelv L(G) = {u ∈
∗
T ∗ | ω0 → u}. G kiterjesztett determinisztikus táblázatos Lindenmayer-rendszer (EDT 0L-
G
rendszer), ha (T ∪ N ) feletti T D0L-rendszer.
ET 0L := {L | ∃G ET0L-rendszer, L(G) = L},

ET D0L := {L | ∃G ETD0L-rendszer, L(G) = L}.
8.6. tétel. L2 ⊆ E0L ⊆ ET 0L ⊆ LInd .
Bizonyı́tás. L2 ⊆ E0L, hiszen adjuk hozzá minden Z ∈ T ∪ N -re a Z → Z szabályt az

L ∈ L2 nyelvet generáló 2. tı́pusú nyelvtanhoz. A példáknál láttuk a SYNC E0L-rendszert
és azt, hogy az általa generált nyelv nem ı́rható le 2. tı́pusú nyelvtannal. Ezért L2 ⊂ E0L
is igaz. E0L ⊆ ET 0L nyilvánvaló.
Legyen G = hT, N, σ1 , . . . , σm , axi ET 0L rendszer, készı́tünk egy G0 = hT, N 0 , F, P 0 , Si
teljes öröklődésű indexelt nyelvtant, melyre L(G0 ) = L(G). Legyen N 0 = N ∪ Tb ∪ {S, S 0 },
F = {fi }ni=1 ∪{S, S 0 } és F = {fi }ni=1 ∪{g}. Vezessük be a következő jelölést, egy α ∈ (T ∪N )∗
mondatforma esetén legyen α b az a mondatforma, melyet úgy kapunk, hogy α-ban minden
t ∈ T terminálist a neki megfelelő b t álterminális nyelvtani jelre cserélünk. P 0 szabályai:
S → S0g
S 0 → S 0 fi i ∈ {1, . . . , n}
S 0 → ac
x
Afi → qb i ∈ {1, . . . , n}, A → q ∈ σi
tg → t
b t∈T
Egy G-beli levezetés a következőképpen néz ki. Adva van tábláknak egy σi1 · · · σik
sorozata. Ha a j. táblát alkalmazzuk, akkor a mondatforma minden jelére alkalmazunk
egy σij -beli átı́rási szabályt. Ennek a sorozatnak G0 -ben megfelel egy fi1 · · · fik index-
sorozat, mely kezdetben öröklődik az axióma minden jelére. Egy nyelvtani jel (eredeti vagy
álterminális) utáni index úgy tűntethető el, ha alkalmazunk a jelre egy a megfelelő táblából
vett átı́rási szabályt. A teljes öröklődés miatt az átı́rás után az újonnan bejövő jelekre
öröklődik, hogy mely táblák szerint kell még majd őket tovább átı́rni. Az álterminálisokra
azért van szükség, hogy a terminálisokra is öröklődjön, hogy mely táblákat kell még al-
kalmazni. Az álterminálisok csak akkor ı́rhatók vissza terminálisokká, ha már nincs rá
vonatkozó alkalmazandó tábla, tehát pontosan k darab megfelelő tábla szerinti átı́rás után
keletkezett. Tehát G0 tényleg helyesen szimulálja G működését, azaz L(G0 ) = L(G). 2
8.2. CD nyelvtani rendszerek
A problémamegoldás fekete tábla módszere: Adott n darab ügynök és egy probléma egy
táblára felı́rva (vagy az 1. ügynök felı́r egy problémát a táblára), az ügynökök célja a
probléma megoldása. A probléma megoldása körökben történik. Minden körben kiáll egy
ügynök a táblához, dolgozik a problémán, majd átadja egy másik ügynöknek a munkát, de
későbbi körökben újra következhet.
A fekete tábla módszer egy modellje a kooperáló osztott (cooperative distributive, CD)
nyelvtani rendszer. A probléma megoldásának aktuális állását (a tábla tartalmát) egy mon-
datforma reprezentálja. Az i. ügynök ezen a mondatformán a hozzá rendelt nyelvtani
szabályok szerint dolgozhat. A CD nyelvtani rendszerek több változata ismeretes aszerint,
hogy mikor adják át az egyes nyelvtanok a vezérlést egy másiknak.
8.7. definı́ció. Egy G = hT, N, P1 , . . . , Pn , Si rendszert CD rendszernek nevezünk, ha min-

den i ∈ {1, . . . , n} esetén Gi = hT, N, Pi , Si egy nyelvtan. Ekkor n a CD rendszer kompo-
nenseinek a száma. Legyen z ∈ {t, ≤∞} ∪ {=k, ≤k, ≥k | k ≥ 1}. A G CD-rendszerben egy
α ∈ (T ∪ N )∗ -ból egy körben, z-módban levezethető a β ∈ (T ∪ N )∗ mondatforma,
8.2. CD nyelvtani rendszerek 49
α → β ⇐⇒ ∃ i ∈ {1, . . . , n}, α0 , . . . , α` ∈ (T ∪ N )∗
G,z
(α0 = α, α` = β, ∀ j ∈ {1, . . . , `} : αj−1 → αj ) ∧ ϕ(z, i, `),
Gi


 @γ ∈ (T ∪ N )∗ (α` → γ) z = “t” (nincs több alkalmazható szabály),


 Gi
> z = “≤∞”,




ahol ϕ(z, i, `) = ` = k z = “=k”,


` ≤ k

 z = “≤k”,



` ≥ k

z = “≥k”.
∗
α → β ⇔ ∃n ∈ N, α0 , . . . , αn ∈ (T ∪ N )∗ (α0 = α, αn = β, ∀ j ∈ {1, . . . , n} : αj−1 → αj ).
G,z G,z
∗
Lz (G) = {u ∈ T ∗ | S → u}.
G,z
Példák:
1. G1 = h{a, b, c}, {S, A, B, C, A0 , B 0 , C 0 }, P1 , P2 , P3 , Si.
P1 szabályai P2 szabályai P3 szabályai

S → ABC A → aA0 A→ε
A0 → A B → bB 0 B→ε
B0 → B C → cC 0 C→ε
C0 → C
S →S
Lt (G1 ) = L=3 (G1 ) = L≥3 (G1 ) = {an bn cn | n ≥ 0}.

L≤3 (G1 ) = L≤∞ (G1 ) = {an1 bn2 cn3 | n1 , n2 , n3 ≥ 0}.
2. G2 = hT, {S, X1 , X10 , X2 , X20 }, Pkezd , Pt (t ∈ T ), Pvége , Si.
Pkezd szabályai Pt (t ∈ T ) szabályai Pvége szabályai

S → X1 X2 X1 → tX10 X1 → ε
X10 → X1 X2 → tX20 X2 → ε
X20 → X2
S →S
Lt (G2 ) = L=2 (G2 ) = L≥2 (G2 ) = {uu | u ∈ T ∗ }.

n
3. G3 = h{a}, {S, Z}, {S → ZZ}, {Z → S}, {S → a}, Si. Ekkor Lt (G3 ) = {a2 | n ≥ 0}.
A G = hT, N, P1 , . . . , Pn , Si CD rendszer i. tı́pusú, ha Gj = hT, N, Pj , Si minden

j ∈ {1, . . . , n} esetén i. tı́pusú nyelvtan.
CDiz = {L | ∃ G i. tı́pusú, z-módban dolgozó CD rendszer, melyre Lz (G) = L}. (z ∈

{t, ≤∞} ∪ {=k, ≤k, ≥k | k ≥ 1}.)
8.8. tétel. CDiz = Li , (i = 0, 1, 3), z ∈ {t, ≤∞} ∪ {=k, ≤k, ≥k | k ≥ 1}.
Bizonyı́tás. Li ⊆ CDiz , ugyanis ha G = hT, N, P, Si ∈ Gi generálja L ∈ Li -t, akkor az 1

komponensű G0 = hT, N, P ∪{S 0 → S, S → S}, S 0 i CD rendszer i. tı́pusú és L(G)-t generálja
minden módban.
Legyen G = hT, N, P1 , . . . , Pn , Si i. tı́pusú CD-rendszer. Készı́tünk egy
G = hT, N , P , S i i. tı́pusú nyelvtant, melyre L(G ) = L(G).
0 0 0 0 0
Sn
≤∞ mód esetén legyen N 0 = N , S 0 = S és P 0 = P≤∞ 0
= j=1 Pj , ekkor G0 i. tı́pusú
nyelvtan, melyre L(G0 ) = L(G).
=k mód és i = 0, 1 esetén legyen N 0 = N=k
0
= N ∪ {Xjr }1≤r≤n, 0≤j≤k , a P 0 = P=k
0
szabályrendszer:
S 0 → X0r 1 ≤ r ≤ n,
pXjr → qXj+1
r
1 ≤ r ≤ n, 0 ≤ j < k, p → q ∈ Pr ,
0
Xkr → X0r 1 ≤ r, r0 ≤ n,
ZXjr → Xjr Z 1 ≤ r ≤ n, 0 ≤ j ≤ k, Z ∈ T ∪ N ,
Xjr Z → ZXjr 1 ≤ r ≤ n, 0 ≤ j ≤ k, Z ∈ T ∪ N ,
Xkr →ε 1 ≤ r ≤ n.
=k mód és i = 3 esetén legyen N 0 = N=k

0
= {Arj }1≤r≤n, 0≤j≤k, A∈N ∪ {S 0 }, a P 0 = P=k
0
szabályrendszer:
S 0 → S0r 1 ≤ r ≤ n,
Arj → uBj+1
r
1 ≤ r ≤ n, 0 ≤ j < k, A → uB ∈ Pr ,
0
Ark → Ar0 1 ≤ r, r0 ≤ n, A ∈ N ,
Ark−1 → u 1 ≤ r ≤ n, A → u ∈ Pr .
≤k mód és i = 0, 1 esetén legyen N 0 = N≤k

0
= N=k
0
és P 0 = P≤k
0
= P=k
0
∪ P 00 , ahol a P 00
szabályrendszer:
0
Xjr → X0r 1 ≤ r, r0 ≤ n, 0 ≤ j < k,
Xjr → ε 1 ≤ r ≤ n, 0 ≤ j < k,
mı́g i = 3 esetén a P 00 szabályrendszer:

8.2. CD nyelvtani rendszerek 51
0
Arj → Ar0 1 ≤ r, r0 ≤ n, 0 ≤ j < k, A ∈ N ,
Arj → u 1 ≤ r ≤ n, 0 ≤ j < k − 1, A → u ∈ Pr .
≥k mód és i = 0, 1 esetén legyen N 0 = N≥k

0
= N=k
0
és P 0 = P≥k
0
= P=k
0
∪ {pXkr →
qXkr | 1 ≤ r ≤ n, p → q ∈ Pr }, mı́g i = 3 esetén P 0 = P≥k 0
= P=k
0
∪ P 00 , ahol a P 00
szabályrendszer:
Ark → uBkr 1 ≤ r ≤ n, A → uB ∈ Pr ,
Ark →u 1 ≤ r ≤ n, A → u ∈ Pr .
t-módban akkor lehet Pr -beli szabály után Pr0 -beli szabályt alkalmazni (r0 6= r), ha már
Pr -beli szabályt nem lehet alkalmazni. Ennek ellenőrzésére i = 0, 1 esetén párhuzamosan
futtatunk az aktuális mondatformával mint inputtal T ∪ N feletti KMP-automatákat, ahol a
minták a Pr -beli szabályok baloldalai. Akkor és csak akkor válthatunk valamely másik Pr0
szabályrendszerre ha az input végigolvasása után egyik automata se találja meg a mintáját.
Minden 1 ≤ r ≤ n esetén jelölje s(r) = |Pr | és legyen Pr = {pr1 → q1r , . . . , prs(r) →
qs(r)
r
}. Legyen továbbá az m mintát felismerő KMP-automata Am = h{ai }0≤i≤`(m) , T ∪
N, δ m , a0 , {a`(m) }i.
Legyen tehát N 0 = Nt = N ∪ {Xr }1≤r≤n ∪ {Wir1 ,...,is(r) }∀1≤j≤s(r): ij ∈{0,...,`(prj )} ∪

{S 0 , L, R}, továbbá a P 0 = Pt0 szabályrendszer legyen a következő:
S 0 → LSXr R 1 ≤ r ≤ n,
pXr → qXr 1 ≤ r ≤ n, p → q ∈ Pr ,
ZXr → Xr Z 1 ≤ r ≤ n, Z ∈ T ∪ N ,
Xr Z → ZXr 1 ≤ r ≤ n, Z ∈ T ∪ N ,
LXr → LW0,...,0
r
1 ≤ r ≤ n,
r
Wir1 ,...,is(r) Z → ZWir0 ,...,i0 1 ≤ r ≤ n, Z ∈ T ∪ N, ∀ 1 ≤ j ≤ s(r) : δ pj (aij , Z) = ai0j ,
1 s(r)
Wir1 ,...,is(r) R → Xr R 1 ≤ r ≤ n, ∃ 1 ≤ j ≤ s(r) : ij = `(prj ),

Wir1 ,...,is(r) R → Xr0 R 1 ≤ r, r0 ≤ n, r0 6= r, ∀ 1 ≤ j ≤ s(r) : ij < `(prj ),
Xr → ε 1 ≤ r ≤ n,
L → ε, R → ε.
i = 3 esetén legyen N 0 = Nt0 = {Ar }1≤r≤n, A∈N ∪ {S 0 }, a P 0 = Pt0 szabályrendszer:

S 0 → Sr 1 ≤ r ≤ n,
Ar → uBr 1 ≤ r ≤ n, A → uB ∈ Pr ,
Ar → u 1 ≤ r ≤ n, A → u ∈ Pr ,
Ar → Ar 0 1 ≤ r, r0 ≤ n, r0 6= r, A 6∈ {bo(P ) | P ∈ Pr }.
A konstrukciókból nyilvánvaló, hogy minden esetben L(G0 ) = L(G). i = 0, 3 esetén G0

i. tı́pusú nyelvtan. i = 1 esetén =k, ≤k, ≥k módok esetén G0 2-korlátolt, t-mód esetén
4-korlátolt nyelvtan. Így az 1.7 és 1.8 tételek szerint L(G0 ) generálható G1 -beli nyelvtannal.
2
8.9. tétel. CD2t = ET 0L.
8.3. PC rendszerek
A párhuzamosan kommunikáló (parallel communicating, PC) rendszerekben a kooperáló
nyelvtanoknak kétfajta lépése van: a szokásos munkalépés, és az információcserélő lépés.
A munkalépések szinkronizáltak, azaz a nyelvtanok egy ütemben egyszerre 1-1 levezetési
lépést tesznek. Az utóbbi esetben ha valamelyik nyelvtan kereső (query) szimbólumot vezet
le, akkor elkéri a kérdezett nyelvtantól az addig levezetett mondatformáját.
8.10. definı́ció. Egy G = hT, N, K, (P1 , S1 ), . . . , (P` , S` )i rendszert PC rendszernek ne-

vezünk, ha K = {Q1 , . . . , Q` }, azaz |K| = `, K ∩ N = ∅ és minden i ∈ {1, . . . , `} esetén
Gi = hT, N ∪K \{Qi }, Pi , Si i egy olyan nyelvtan, ahol Pi -ben szabály baloldalán nem szerepel
K-beli jel. Ekkor Qi -t az i. nyelvtanhoz tartozó keresőszimbólumnak nevezzük, ` pedig a PC-
rendszer komponenseinek a száma.
[α1 , . . . , α` ] a PC-rendszer egy konfigurációja, ha minden i ∈ {1, . . . , `} esetén αi ∈
(T ∪ N ∪ K \ {Qi })∗ .
[α1 , . . . , α` ] → [β1 , . . . , β` ] ⇐⇒ ∀ i ∈ {1, . . . , `} (αi ∈ (T ∪ N )∗ ∧ αi → βi ).

G,d Gi
Definiáljuk a h[α1 ,...,α` ] : (T ∪ N ∪ K)∗ → (T ∪ N ∪ K)∗ homomorfizmust a kövezkezőképpen
T ∪ N ∪ K elemein

α valamely i ∈ {1, . . . , `}-re Z = Q ∧ α ∈ (T ∪ N )∗
i i i
h[α1 ,...,α` ] (Z) = .
Z egyébként
[α1 , . . . , α` ] → [β1 , . . . , β` ] ⇐⇒∃ i ∈ {1, . . . , `}(αi ∈ (T ∪ N ∪ K)∗ K(T ∪ N ∪ K)∗ )

G,q
∧ ∀ i ∈ {1, . . . , `}(βi = h[α1 ,...,α` ] (αi )).
[α1 , . . . , α` ] → [β1 , . . . , β` ], ha [α1 , . . . , α` ] → [β1 , . . . , β` ] vagy [α1 , . . . , α` ] → [β1 , . . . , β` ].
G G,d G,q
8.3. PC rendszerek 53
∗
C → C 0 , ha létezik n ∈ N, C0 , . . . Cn konfigurációk, hogy C0 = C, Cn = C 0 , és minden
G
i ∈ {1, . . . , n} esetén Ci−1 → Ci .
G
∗
L(G) = {u ∈ T ∗ | ∃β2 , . . . , β` ∈ (T ∪ N ∪ K)∗ [S1 , . . . , S` ] → [u, β2 , . . . , β` ]}.
G
Példák:
1. G1 = h{a, b, c}, {S1 , S2 , S20 , S3 , S30 , S300 }, {Q1 , Q2 , Q3 }, (P1 , S1 ), (P2 , S2 ), (P3 , S3 )i, ahol
P1 szabályai P2 szabályai P3 szabályai

S1 → aS1 S2 → bS2 S3 → cS3
S1 → Q2 S2 → S20 S3 → S30
S20 → Q3 S20 → S20 S30 → S300
S300 → ε S300 → S300
L(G) = {an bn cn | n ∈ N}
2. G2 = hT, {S1 , S2 }, {Q1 , Q2 }, (P1 , S1 ), (P2 , S2 )i, ahol
P1 szabályai P2 szabályai
S1 → S1 S2 → tS2 (t ∈ T )
S1 → Q2 Q2 S2 → ε
L(G) = {uu | u ∈ T ∗ }.
3. G3 = h{a}, {S1 , S2 , A}, {Q1 , Q2 }, (P1 , S1 ), (P2 , S2 )i, ahol
P1 szabályai P2 szabályai
S1 → Q2 S2 → aA
A → Q2 A → aaA
A→ε
2
L(G) = {an | n ≥ 1}.
A G = hT, N, K, (P1 , S1 ), . . . , (P` , S` )i PC rendszer i. tı́pusú, ha Gj = hT, N ∪ K \

{Qj }, Pj , Sj i minden j ∈ {1, . . . , `} esetén i. tı́pusú nyelvtan.
PCi = {L | ∃ G i. tı́pusú PC rendszer, melyre L(G) = L}.
Mivel minden nyelvtan tekinthető egy 1 komponensű PC rendszernek, ezért Li ⊆ PCi
(i = 0, 1, 2, 3). A fenti példák mutatják, hogy a párhuzamos számı́tás már a 3. tı́pusú
nyelvtanok erejét is jelentősen megnöveli, L3 ⊂ PC3 , sőt PC3 ∩ L1 6= ∅. PC2 és L1 viszonya
máig nyitott kérdés.

Automaták És Formális Nyelvek II. - Dr. Hunyadvári László (2009)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Automaták És Formális Nyelvek II. - Dr. Hunyadvári László (2009)

Uploaded by

Copyright:

Available Formats

1

Dr. Hunyadvari Laszl

Automaták és formális

Jegyzet programtervező matematikus és informatika tanári

Első kiadás, utolsó javı́tás dátuma: 2009. január 9.

Készült Donald E. Knuth TEX szövegszedő rendszerével.

1 K-korlátolt nyelvtanok, homomorfizmus lemma 2

Ekkor h(L(G1 )) ⊆ L(G2 ).

1.2. K-korlátolt nyelvtanok

ws(D) := max `(αi ).

1.3. definı́ció. Legyen K ≥ 1 egész. A G nyelvtan K-korlátolt, ha minden u ∈ L(G)-hez

Jelölje a K-korlátolt nyelvtanok osztályát GKlb (K ≥ 1).

Jelölje a K-korlátolt nyelvek osztályát LKlb (K ≥ 1).

Bizonyı́tás. A G = h{a}, {S, L, R, D, E}, {S → LEaR, Ea → aaE, aD → Daa, ER →

1.5. tétel. Ha L ∈ LKlb , akkor L ∪ {ε}, L \ {ε} ∈ LKlb .

Bizonyı́tás. Legyen G = hT, N, P, Si az L nyelvet generáló K-korlátolt nyelvtan (S 0 6∈ N ).

1.6. következmény. Ha ε 6∈ L, L ∈ LKlb , akkor létezik G ε-szabálymentes nyelvtan,

Mivel GKlb ⊆ G(K+1)lb , ezért LKlb ⊆ L(K+1)lb (K ≥ 1).

1.7. tétel. Minden K ≥ 1 egész számra L1lb = LKlb .

L(G0 ) = h(L(G0 )) ⊆ L(G).

αbi = βe1 · · · βe` τe1 · · · τes %e

`(α0 ) = d`(α)/Ke ≤ d(K · `(u))/Ke = `(u).

1.8. tétel. L1 = L1lb .

p → qB `(p)−`(q) ∈ P1 ⇔ p → q és `(q) < `(p).

pB j → q ∈ P2 ⇔ p → q és `(p) + j ≤ `(q).

`(αr+1 ) + jr+1 = (`(αr ) − `(p) + `(q)) + (jr − mr ) = `(αr ) + jr ≤ `(u),

`(αr+1 ) + jr+1 = `(αr+1 ) ≤ `(u),

1.3.1. Chomsky nyelvosztályok metszetre való zártsága

1.9. tétel. L0 és L1 zárt a ∩ műveletre.

Bizonyı́tás. Elég belátni, hogy tetszőleges G1 , G2 ∈ Gi (i = 0, 1) nyelvtanokhoz létezik

ε} ∪ {Xt1 Yt2 → Yt2 Xt1 | t1 , t2 ∈ T } ∪ {LXt Yt → tL | t ∈ T }. Továbbá P i -t úgy kapjuk Pi -

L(G∩ ) = hi (L(G∩ )) ⊆ L(Gi ) (i = 1, 2) =⇒ L(G∩ ) ⊆ L(G1 ) ∩ L(G2 ).

ws(D) ≤ 1 + `(u)e + `(u)

2.1. Előfordulásellenőrzés nélküli programozott nyelv-

a programozott nyelvtan ábécéjének, a nyelvtani jelek ábécéjének, szabályhalmazának illetve

2.2. definı́ció. Legyen α ∈ (T ∪ N )∗ és f ∈ F ∪ {exit}, ekkor [α, f ]-et a programozott

Legyen P = p → q egy szabály, ekkor vezessük be a következő jelöléseket a szabály bal-

2.4. definı́ció. A közvetett konfigurációátmenet a közvetlen konfigurációátmenet reflexı́v,

2.5. definı́ció. A G programozott nyelvtan által generált nyelv:

A programozott nyelvtanokban tehát a vezérlési információ a következő végrehajtandó

2.6. definı́ció. Egy G = hT, N, P, S, F, lab, σi programozott nyelvtan i. tı́pusú, ha

Jelölje GiP az i. tı́pusú programozott nyelvtanok összességét. Legyen továbbá Pi :=

2.7. állı́tás. Pi ⊇ Li (i = 0, 1, 2, 3), P2 ⊃ L2 .

Af → uBf 0 ∈ P 0 ⇐⇒ lab(f ) = A → uB, f 0 ∈ σ(f ),

1. Állı́tás: Legyen A, B ∈ N, u ∈ T ∗ , f ∈ F, f¯ ∈ F ∪ {exit}, ekkor

[A, f ] → [uB, f¯] ⇐⇒ Af →0 uBf¯.

Tegyük fel, hogy legfeljebb n hosszú levezetésekre igaz az állı́tás.

[B, f¯] → [v, f 0 ] ⇐⇒ Bf¯ →0 v.

2.9. tétel. Pi = Li (i = 0, 1).

Xf p → Xg q ∈ P)0 ⇐⇒ lab(f ) = p → q, g ∈ σ(f ), (*)

Legyen α, β ∈ (T ∪ N )∗ , f ∈ F, f¯ ∈ F ∪ {exit}, ekkor

[α, f ] → [β, f¯] ⇐⇒ αXf →0 βXf¯.

Tegyük fel, hogy legfeljebb n hosszú levezetésekre igaz az állı́tás.

megfelelő levezetését D0 -vel jelöljük, akkor ennek munkaterületére

ws(D0 ) ≤ 1 + ws(D) ≤ 1 + `(u)

2.2. Előfordulásellenőrzéses programozott nyelvtanok

2.11. definı́ció. Legyen α ∈ (T ∪ N )∗ és f ∈ F ∪ {exit}, ekkor [α, f ]-et az előfordulásel-

ből közvetlen (1-lépéses) konfigurációátmenettel előfordulásellenőrzéssel levezethető [β, f 0 ],

2.13. definı́ció. A(z előfordulásellenőrzéses) közvetett konfigurációátmenet a közvetlen

2.14. definı́ció. A G előfordulásellenőrzéses programozott nyelvtan által (előfordulásellen-

2.15. definı́ció. Egy G = hT, N, P, S, F, lab, σ, ϕi előfordulásellenőrzéses programozott

Jelölje GiP, ac az i. tı́pusú előfordulásellenőrzéses programozott nyelvtanok összességét. Le-

Világos, hogy minden előfordulásellenőrzés nélküli programozott nyelvtan tekinthető

Dr. Hunyadvari Laszl