Disusun oleh: Rina Dewi Indah Sari, S.Kom
Kata Pengantar Teori bahasa dan automata merupakan salah satu mata kuliah yang wajib di jurusan-jurusan informatika maupun ilmu komputer. Salah satunya pada STMIK Asia Malang. Mata kuliah ini mempelajari tentang notasi-notasi bahasa yang digunakan dalam komputer. Bahasan dalam mata kuliah ini akan banyak diimplementasikan pada teknik kompilasi. Oleh sebab itu akan terasa manfaatnya pada saat anda mempelajari tentang kompilasi. Penulis mencoba menyajikan sesuatu dengan cara sesederhana mungkin dengan bahasa yang mudah diterima sehingga mengurangi kesulitan mahasiswa pada perkuliahan ini. Penulis mengharapkan pembaca bisa menangkap materi dan persoalan-persoalan yang
diberikan.
Diharapkan
pembaca
dapat
menikmati
permasalahan
tanpa
memandangnya sebagai sesuatu yang sulit. Sesuai dengan namanya, mata kuliah ini hanya memuat teori saja, tanpa memuat hal-hal praktis yang dapat diterapkan langsung dalam praktek. Penulis menyadari bahwa maíz banyak kekurangan di sini, baik kesalahan pengetikan maupun kekurangtepatan dalam penjelasan. Penulis dengan senang hati akan menerima saran dan kritik membangun dari pembaca, dapat disampaikan melalui e-mail
[email protected]. Tidak lupa penulis mengucapkan terima kasih yang tak terhingga lepada ALLAH SWT atas segala berkahnya, Ibunda tercinta yang akhir-akhir ini sering missed, Suamiku tercinta yang kadang-kadang juga nyebelin, dan calon ’dede’ dalam perutku yang akan menjadi semangat sepanjang hidupku. Serta semua saudaraku, sahabatku serta rekan – rekan kerja di ASIA Malang.
Malang, Agustus 2008
Rina Dewi Indah Sari
i
Daftar Isi Kata Pengantar .............................................................................................
i
Daftar Isi ........................................................................................................
ii
Bab I : Pengantar ..........................................................................................
1
1.1
1.2
Teori Pengantar ................................................................................ 1.1.1
Teori Himpunan ......................................................................
1
1.1.2
Fungsi dan Relasi.....................................................................
4
1.1.3
Teori Pembuktian.....................................................................
4
1.1.4
Graph dan Tree .......................................................................
5
Kompilasi .........................................................................................
7
1.2.1
Bahasa Pemrograman ..............................................................
7
1.2.2
Translator ................................................................................
7
1.2.3
Interpreter ................................................................................
8
1.2.4
Assembler ...............................................................................
8
1.2.5
Compiler .................................................................................
9
Bab II : Konsep Bahasa Automata .............................................................. 2.1
2.2
1
Konsep Bahasa dan Automata .........................................................
13 13
2.1.1
Teori Bahasa ...........................................................................
13
2.1.2
Automata .................................................................................
13
2.1.3
String .......................................................................................
14
2.1.4
Operasi Dasar String ...............................................................
14
2.1.5
Sifat-sifat Operasi String .........................................................
16
Grammar dan Bahasa .......................................................................
17
2.2.1
Definisi ....................................................................................
17
2.2.2
Simbol .....................................................................................
17
2.2.3
Aturan Produksi ......................................................................
18
2.2.4
Grammar .................................................................................
18
2.2.5
Klasifikasi Chomsky ...............................................................
19
2.2.6
Analisa Grammar ....................................................................
21
Bab III : Finite State Automata (FSA) ........................................................
24
ii
3.1
Definisi Formal ................................................................................
24
3.2
Fungsi Transisi .................................................................................
25
3.3
Jenis-jenis FSA ................................................................................
25
3.4
Deterministic finite automata (DFA) ...............................................
26
3.5
Non deterministik finite automata (NFA) ........................................
27
3.6
Ekuivalen .........................................................................................
29
3.7
Indistinguishable ..............................................................................
29
3.8
Distinguishable ................................................................................
29
3.9
Prosedur menentukan pasangan status indistinguishable ................
30
3.10 Prosedur Reduksi DFA ....................................................................
30
Bab IV : Ekuivalensi NFA ke DFA .............................................................
32
4.1
Algoritma Ekivalensi NFA ke DFA ................................................
32
4.2
NFA dengan ε-move ........................................................................
34
4.3
Ekuivalensi NFA dengan ε-move ke NFA tanpa ε-move ................
34
4.4
Penggabungan FSA ..........................................................................
35
Bab V : Ekspresi Reguler .............................................................................
37
5.1
Bahasa regular ..................................................................................
37
5.2
Sifat Bahasa Reguler ........................................................................
38
5.3
Konversi ekspresi reguler ke FSA ...................................................
39
5.4
DFA dan Tatabahasa Reguler ..........................................................
39
5.5
Penerapan ekspresi regular ..............................................................
41
5.6
Pumping Lemma...............................................................................
41
Bab VI : FSA dengan Output ......................................................................
43
6.1
Mesin Moore ....................................................................................
43
6.2
Mesin Mealy ....................................................................................
44
6.3
Ekuivalensi mesin Moore dengan mesin Mealy ..............................
45
Bab VII : Bahasa Bebas Konteks ................................................................
47
7.1
Tata Bahasa Bebas Konteks .............................................................
47
7.2
Leftmost dan Rightmost Derivation .................................................
48
7.3
Pohon Urai .......................................................................................
49
7.4
Parsing dan Keanggotaan .................................................................
49
iii
7.5
Ambiguitas pada Tatabahasa dan Bahasa ........................................
50
7.6
Pumping Lemma untuk bahasa bebas konteks ................................
50
7.7
Sifat - sifat tertutup bahasa bebas konteks .......................................
51
7.8
Substitusi ..........................................................................................
52
7.9
Tatabahasa Bebas Konteks dan Bahasa Pemrograman ....................
52
Bab VIII : Penyederhanaan Tata Bahasa Bebas Konteks ........................
53
8.1
Penghilangan Produksi Useless .......................................................
53
8.2
Penghilangan Produksi Unit ............................................................
55
8.3
Penghilangan Produksi ..................................................................
57
8.4
Pengembangan praktek ....................................................................
58
Bab IX : Bentuk Normal Chomsky .............................................................
60
9.1
Pengertian ........................................................................................
60
9.2
Aturan Produksi ...............................................................................
60
9.3
Pembentukan CNF ...........................................................................
60
9.4
Bagan Tahapan Pembentukan CNF .................................................
61
9.5
Algoritma CYK untuk Tata Bahasa Bebas Konteks ........................
63
Bab X : Penghilangan Rekursif Kiri ...........................................................
69
10.1 Aturan Produksi Rekursif ................................................................
69
10.2 Pohon Penurunan .............................................................................
69
10.3 Tahapan Penghilangan Rekursif Kiri ...............................................
70
Bab XI : Bentuk Normal Greibach .............................................................
73
11.1 Pengertian Bentuk Normal Greibach ...............................................
73
11.2 Pembentukan GNF dengan Substitusi .............................................
73
Bab XII : Pushdown Automata (PDA) ........................................................
77
12.1 Pendahuluan .....................................................................................
77
12.2 Transisi .............................................................................................
77
12.3 Definisi Formal PDA .......................................................................
78
Bab XIII : Mesin Turing ..............................................................................
83
13.1 Sejarah ..............................................................................................
83
13.2 Mekanisme TM ................................................................................
83
13.3 Definisi Formal ................................................................................
83
iv
13.4 Ilustrasi TM sebagai sebuah ‘mesin’ ...............................................
84
13.5 Ilustrasi TM sebagai sebuah Graf berarah .......................................
84
Bab XIV : Aplikasi FSA dan CFG pada Pengembangan Kompilator .....
87
14.1 Scanner .............................................................................................
87
14.2 Parser ................................................................................................
87
14.3 Tool bantuan untuk konstruksi Scanner dan Parser..........................
88
14.4 Implementasi Scanner dan Parser ....................................................
90
Daftar Pustaka ..............................................................................................
99
v
Bab I PENGANTAR 1.1. Teori Pengantar 1.1.1. Teori Himpunan Definisi sebuah himpunan adalah kumpulan obyek atau simbol yang memiliki sifat yang sama. Anggota himpunan disebut elemen Contoh: Terdapat sebuah himpunan X = {1, 2, 4}, maka 1∈X
1 merupakan elemen dari himpunan X
3∈X
3 bukan elemen dari himpunan X
A. Himpunan Sama Himpunan dikatakan sama bila memuat elemen - elemen yang sama. Contoh : Terdapat beberapa himpunan, X = {1, 2, 4} Y = {4, 1, 2} Z = {1, 2, 3} Maka, X=Y X
Z
B. Himpunan Bagian (Subset) Himpunan bagian adalah jika semua elemen dari himpunan A adalah elemen dari himpunan B. Contoh : Terdapat beberapa himpunan, A = {1, 2, 3} B = {1, 2, 3, 4} C = {1, 2, 3} 1
Maka, A ⊆ B dan C ⊆ B, maka A = C C. Himpunan Kosong Himpunan kosong atau null (ø) merupakan bagian dari semua himpunan. Contoh : Terdapat himpunan,
Maka,
A = {1, 2, 3}
Ø⊆A
B = {1, 2, 3, 4}
Ø⊆B
C = {1, 2, 3}
Ø⊆C
D. Operasi – operasi himpunan 1. Gabungan (Union), dinyatakan dengan ∪ Misal, A = {1, 2, 3} B = {2, 4} Jika
P = A ∪ B, maka P = {x | x ∈ A atau x ∈ B} P = {1, 2, 3, 4}
Bisa dianalogikan dengan penjumlahan A∪B=A∨B=A+B 2. Irisan (Intersection), dinyatakan dengan ∩ Misal, A = {1, 2, 3} B = {2, 4} C = {10, 11} Jika
P = A ∩ B, maka P = {x | x ∈ A dan x ∈ B} P = {2} A ∩ C = Ø, disebut saling lepas (disjoint)
Bisa dianalogikan dengan perkalian A∩B=A∧B=A.B
2
3. Komplemen, adalah semua elemen yang tidak menjadi elemen himpunan tersebut. Semua himpunan yang dibahas diasumsikan merupakan bagian dari suatu himpunan semesta (Universal). Jadi komplemen A = ¬A = U – A Misal A = {1, 2, 3} B = {2, 4} C = {10, 11} Maka, A – B = {1, 3} B–C=Ø E. Beberapa ketentuan pada operasi himpunan o Ø∪A=A o Ø∩A=Ø o A⊆B
A∩B=A
o A⊆B
A∪B=B
o A∩A=A o A∪A=A o Komunikatif, A ∪ B = B ∪ A A∩B=B∩A o Assosiatif,
A ∪ ( B ∪ C ) = (A ∪ B) ∪ C A ∩ ( B ∩ C ) = (A ∩ B) ∩ C
o Distributif,
A ∩ ( B ∪ C ) = (A ∩ B) ∪ ( A ∩ C) A ∪ ( B ∩ C ) = (A ∪ B) ∩ ( A ∪ C)
o Hukum DeMorgan,
A – B = A ∩ ¬B ¬(A ∩ B) = ¬A ∪ ¬B
o ¬(A ∪ B) = ¬A ∩ ¬B o ¬(¬A) = A o ¬Ø = U o ¬U = Ø
3
1.1.2. Fungsi dan Relasi Suatu fungsi adalah sebuah relasi yang memenuhi suatu kriteria. Contoh: f:A
B dan g : A
B, maka
f=g
f(x) = g(x) untuk semua x di dalam A
Beberapa ketentuan fungsi 1. f(Ø) = Ø 2. f({x}) = {f(x)} untuk semua x ∈ A 3. X ⊆ Y ⊆ A
f(x) ⊆ f(y)
4. X ⊆ Y ⊆ B
f-1(x) ⊆ f-1(y)
5. X ⊆ B dan Y ⊆ B
f-1(x-y) = f-1(x) - f-1(y)
Kombinasi Fungsi dapat dikombinasikan dengan cara komposisi, dinotasikan dengan o Misal: f(x) = 2x + 1 g(x) = x2 Maka, g o f(x) = g(2x + 1) = (2x + 1)2 = 4x2 + 4x + 1
1.1.3. Teori Pembuktian Pembuktian menggunakan prinsip induksi matematika. Langkah-langkah dalam melakukan pembuktian : o Tunjukkan hal itu berlaku untuk semua P0, disebut basis step. o Tunjukkan hal itu berlaku untuk Pn+1, disebut induction step. o Maka dapat ditarik kesimpulan hal tersebut berlaku untuk semua n Contoh Pembuktian S(n) = 1 + 2 + …. + n = n(n+1)/2, n S(0) = 0(0+1)/2 = 0 (terbukti) S(1) = 1(1+1)/2 = 1 (terbukti)
4
bilangan bulat positif
S(i) = 1 + 2 + …. + i = i(i+1)/2 (anggap benar) Akan dibuktikan S(i+1) juga benar S(i+1) = (i+1)((i+1)+1)/2 = 1+2+….+i+(i+1) = i(i+1)/2 + (i+1) = (i+1)(i/2+1) = (i+1)(i+2)/2 = (i+1)((i+1)+1)/2 (terbukti) Jadi, S(n) benar
1.1.4. Graph dan Tree Suatu graph adalah himpunan vertex (titik) yang tidak kosong dengan setiap sisi (edge) menghubungkan 2 buah titik. G = ( V , E );
V = vertex / titik E = edge / sisi |V(G)| = banyak titik pada graph G = E+1 |E(G)| = banyak sisi pada graph G = V-1 V9
Contoh sebuah Graph V8 V1 V7
V2
V6 V3
V4
V5
Istilah-istilah dalam teori graph
o Lup/ gelung, adalah sisi yang menghubungkan titik dengan titik itu sendiri. o Titik terminal, adalah titik yang berderajat 1 o Derajat, adalah banyaknya sisi dalam 1 titik o Titik terasing, adalah titik yang berderajat nol
5
o Adjantcy/ berdekatan, adalah bila titik-titik terhubung langsung oleh suatu sisi. o Incident/ bersisian, adalah bila titik tidak terhubung langsung. o Lintasan/ Path, adalah urutan titik dan sisi dalam suatu graph terhubung. o Jalan/ Trail, adalah urutan titik dan sisi dalam graph yang tidak mengulang sisi. o Sikel, adalah path yang dimulai dan diakhiri pada titik yang sama. o Graph terhubung, adalah graph yang semua titiknya dihubungkan oleh sisi. o Graph sederhana, adalah graph yang tidak ada simpul/ lup. o Graph berarah/ directed graph, adalah graph yang sisinya mempunyai arah. o Graph tidak berarah/ undirected graph o Graph komplit, adalah graph yang semua titik-titiknya terhubung langsung (lema jabat tangan) -
Jumlah sisi
|E(G)| = degV(G)/2
-
Derajat max = V-1 |E(G)| = 6/2 = 3
v1
v2
Deg = 3-1 = 2
o Euler
v3
-
Lintasan Euler, adalah lintasan yang melalui semua sisi tepat 1 kali dalam graph.
-
Sirkuit Euler, adalah lintasan Euler yang berangkat dan berakhir pada titik yang sama.
o Hamilton -
Lintasan hamilton, adalah lintasan yang melalui semua titik tepat 1 kali dalam graph.
-
Sirkuit hamilton, adalah lintasan hamilton yang berangkat dan berakhir pada titik yang sama.
6
1.2. Kompilasi 1.2.1. Bahasa Pemrograman Bahasa mesin
Bahasa Assembly
Bahasa Pemrograman Bahasa Tingkat tinggi
Bahasa Problem Oriented
1. Bahasa mesin merupakan bentuk terendah dari bahasa komputer. Instruksi direpresentasikan dalam kode numerik. 2. Bahasa Assembly merupakan bentuk simbolik dari bahasa mesin. Kode misalnya ADD, MUL, dsb 3. Bahasa tingkat tinggi (user oriented) lebih banyak memberikan fungsi kontrol program, kalang, block, dan prosedur. 4. Bahasa problem oriented sering juga dimasukkan sebagai bahasa tingkat tinggi, misalnya SQL, Myob, dsb.
1.2.2. Translator Translator melakukan pengubahan source code/ kode program kedalam target code/ object code. Interpreter dan Compiler termasuk dalam kategori translator.
7
Interpreter
Tidak membangkitkan object code.
Translator
Source code dan data diproses bersamaan. Contoh: BASICA, SPSS, DBASE III. Assembler
Compiler Source Code adalah bahasa tingkat tinggi. Object Code adalah bahasa mesin atau assembly.
Source Code adalah bahasa Assembly
Source code dan data diproses tidak bersamaan.
Object Code adalah bahasa mesin.
Contoh: PASCAL, C.
1.2.3. Interpreter Penanganan Kesalahan
Progra m
Analisa Leksikal
Analisa Sintaks
Intermediate Program
Interpretas i
Hasil Operasi
Pengelolaan Tabel
1.2.4. Assembler Source Code
Assembl er
Object Code
.ASM
.OBJ Proses Sebuah Kompilasi pada Bahasa Assembler
8
Lingke r
File Target
.EXE / .COM
Keterangan : •
Source Code adalah bahasa Assembler, Object Code adalah bahasa Mesin.
•
Object Code dapat berupa file object (.OBJ), file .EXE, atau file .COM
•
Contoh : Turbo Assembler (dari IBM) dan Macro Assembler (dari Microsoft).
1.2.5. Compiler Kompilator (compiler) adalah sebuah program yang membaca suatu program yang ditulis dalam suatu bahasa sumber (source language) dan menterjemahkannya ke dalam suatu bahasa sasaran (target language). Proses kompilasi dapat digambarkan melalui sebuah kotak hitam (black box) berikut :
A. Fase Compiler Proses kompilasi dikelompokkan ke dalam dua kelompok besar : 1. Analisis (front-end) : a. program sumber dipecah-pecah dan dibentuk menjadi bentuk antara (inter-mediate representation) b. Language Independent 2. Sintesis (back-end) : a. membangun program sasaran yang diinginkan dari bentuk antara b. Language dependent
9
B. Blok Diagram Compiler Program Sumber
Program Sasaran
ANALISA Penganalisa Leksikal (scanner)
SINTESA Penganalisa Semantik Pembangkit Kode antara
Penganalisa Sintaks (parser)
Pembentuk kode
Pengoptimal kode
TABEL SIMBOL
Bagan pokok proses kompilasi
Keterangan 1. Program Sumber : ditulis dalam bahasa sumber (Pascal, Assembler, dsb) 2. Program Sasaran : dapat berupa bahasa pemrograman lain atau bahasa mesin pada suatu komputer. 3. Penganalisa Leksikal : membaca program sumber, karakter demi karakter. Sederetan (satu atau lebih) karakter dikelompokkan menjadi satu kesatuan mengacu kepada pola kesatuan kelompok karakter (token) yang ditentukan dalam bahasa sumber. Kelompok karakter yang membentuk sebuah token dinamakan lexeme untuk token tersebut. Setiap token yang dihasilkan disimpan di dalam tabel simbol. Sederetan karakter yang tidak mengikuti pola token akan dilaporkan sebagai token tak dikenal (unidentified token). 4. Penganalisa sintaks : memeriksa kesesuaian pola deretan token dengan aturan sintaks yang ditentukan dalam bahasa sumber. Sederetan token yang tidak mengikuti aturan sintaks akan dilaporkan sebagai kesalahan sintaks (sintax error). Secara logika deretan token yang bersesuaian dengan sintaks tertentu akan dinyatakan sebagai pohon parsing (parse tree).
10
5. Penganalisa semantik : memeriksa token dan ekspresi dari batasanbatasan yang ditetapkan. Batasan-batasan tersebut misalnya : a. panjang maksimum token identifier adalah 8 karakter, b. panjang maksimum ekspresi tunggal adalah 80 karakter, c. nilai bilangan bulat adalah -32768 s/d 32767, d. operasi aritmatika harus melibatkan operan-operan yang bertipe sama. Melakukan analisa semantik, biasanya dalam realisasi akan digabungkan Dengan
intermediate
code
generator
(bagian
yang
berfungsi
membangkitkan kode antara). 6. Pembangkit kode antara : membangkitkan kode antara (intermediate code) berdasar-kan pohon parsing. Pohon parse selanjutnya diterjemahkan oleh suatu penerjemah yang dinamakan penerjemah berdasarkan sintak (syntax-directed translator). Hasil penerjemahan ini biasanya merupakan perintah tiga alamat (three-address code) yang merupakan representasi program untuk suatu mesin abstrak. Perintah tiga alamat bisa berbentuk quadruples (op, arg1, arg2, result), tripels (op, arg1, arg2). Ekspresi dengan satu argumen dinyatakan dengan menetapkan arg2 dengan - (strip, dash) 7. Pembentuk Kode : membangkitkan kode objek dalam bahasa target tertentu (misalnya bahasa mesin). 8. Pengoptimal Kode : Melakukan optimasi (penghematan space dan waktu komputasi), jika mungkin, terhadap kode antara sehingga dapat memperkecil hasil dan mempercepat proses. 9. Tabel : Menyimpan semua informasi yang berhubungan dengan proses kompilasi.
C. Pembuatan Compiler Pembuatan kompilator dapat dilakukan dengan: 1. Bahasa Mesin Tingkat kesulitannya tinggi, bahkan hampir mustahil dilakukan.
11
2. Bahasa Assembly Bahasa Assembly bisa dan biasa digunakan sebagai tahap awal pada proses pembuatan sebuah kompilator. 3. Bahasa Tingkat Tinggi lain pada mesin yang sama Proses pembuatan kopilator akan lebih mudah. 4. Bahasa tingkat tinggi yang sama pada mesin yang berbeda Misal, pembuatan kompilator C untuk DOS, berdasar C pada UNIX. 5. Bootstrap Pembuatan kompilator secara bertingkat. Library Object Code Source Code 1
Compiler 1
Source Code 2
Compiler 2
Source Code n
Compiler n
Object Code 1 Object Code 2
Lingker
Executable
Object Code n
Keterangan : o Pembentukan file Executable berdasar dari beberapa Source Code. o Source Code dapat terdiri dari satu atau lebih behasa pemrograman. D. Penggunaan Compiler selain untuk programming o Mentranslasikan javadoc ke html. o Mendapatkan hasil dari SQL query (query optimization). o Printer parsing PostScript file. o Screen Scrapping. o Konversi LaTeX ke PDF.
12
Bab II KONSEP BAHASA AUTOMATA
2.1 Konsep Bahasa dan Automata 2.1.1
Teori Bahasa Teori bahasa membicarakan bahasa formal (formal language), terutama untuk kepentingan perancangan kompilator (compiler) dan pemroses naskah (text processor). Bahasa formal adalah kumpulan kalimat. Semua kalimat dalam sebuah bahasa dibangkitkan oleh sebuah tata bahasa (grammar) yang sama. Sebuah bahasa formal bisa dibangkitkan oleh dua atau lebih tata bahasa berbeda. Dikatakan bahasa formal karena grammar diciptakan mendahului pembangkitan setiap kalimatnya. Bahasa manusia bersifat sebaliknya; grammar diciptakan untuk meresmikan kata-kata yang hidup di masyarakat. Dalam pembicaraan selanjutnya ‘bahasa formal’ akan disebut ‘bahasa’ saja.
2.1.2
Automata Automata adalah mesin abstrak yang dapat mengenali (recognize), menerima (accept), atau membangkitkan (generate) sebuah kalimat dalam bahasa tertentu. Automata berkaitan dengan teori mesin abstrak, yaitu mesin sekuensial yang menerima input, dan mengeluarkan output, dalam bentuk diskrit. Contoh : o Mesin Jaja / vending machine o Kunci kombinasi o Parser/compiler Teori Otomata dan bahasa formal berkaitan dalam hal, yaitu: o Pembangkitan kalimat/ generation : menghasilkan semua kalimat dalam bahasa L berdasarkan aturan yang dimilikinya. o Pengenalan kalimat/ recognition : menentukan suatu string (kalimat) termasuk sebagai salah satu anggota himpunan L.
13
2.1.3
String
2.1.3.1
Definisi Simbol adalah sebuah entitas abstrak. Sebuah huruf atau sebuah angka adalah contoh simbol. String adalah deretan terbatas (finite) simbol-simbol. Sebagai contoh, jika a, b, dan c adalah tiga buah simbol maka abcb adalah sebuah string yang dibangun dari ketiga simbol tersebut. Alfabet adalah hinpunan hingga (finite set) simbol-simbol
2.1.3.2
Panjang String Definisi 1: sebuah string dengan panjang n yang dibentuk dari himpunan A adalah barisan dari n simbol. Misalnya a1a2...an ;
ai ∈ A
Jika w adalah sebuah string maka panjang string dinyatakan sebagai w dan didefinisikan sebagai cacahan (banyaknya) simbol yang menyusun string tersebut. Sebagai contoh, jika w = abcb maka w = 4 2.1.3.3
String Hampa : Definisi 2 : String kosong/ String hampa (null string), dilambangkan dengan ε (atau ^) adalah untaian dengan panjang 0 dan tidak berisi apapun. String hampa adalah sebuah string dengan nol buah simbol. Maka panjang string hampa ε = 0. String hampa dapat dipandang sebagai simbol hampa karena keduanya tersusun dari nol buah simbol.
2.1.4
Operasi Dasar String Diberikan dua string : x = abc, dan y = 123 o Prefik string w adalah string yang dihasilkan dari string w dengan menghilangkan nol atau lebih simbol-simbol paling belakang dari string w tersebut. Contoh : abc, ab, a, dan adalah semua Prefix(x)
14
o ProperPrefix string w adalah string yang dihasilkan dari string w dengan menghilangkan satu atau lebih simbol-simbol paling belakang dari string w tersebut. Contoh : ab, a, dan adalah semua ProperPrefix(x) o Postfix (atau Sufix) string w adalah string yang dihasilkan dari string w dengan menghilangkan nol atau lebih simbol-simbol paling depan dari string w tersebut. Contoh : abc, bc, c, dan adalah semua Postfix(x) o ProperPostfix (atau PoperSufix) string w adalah string yang dihasilkan dari string w dengan menghilangkan satu atau lebih simbol-simbol paling depan dari string w tersebut. Contoh : bc, c, dan adalah semua ProperPostfix(x) o Head string w adalah simbol paling depan dari string w. Contoh : a adalah Head(x) o Tail string w adalah string yang dihasilkan dari string w dengan menghilangkan simbol paling depan dari string w tersebut. Contoh : bc adalah Tail(x) o Substring string w adalah string yang dihasilkan dari string w dengan menghilangkan nol atau lebih simbol-simbol paling depan dan/atau simbolsimbol paling belakang dari string w tersebut. Contoh : abc, ab, bc, a, b, c, dan adalah semua Substring(x) o ProperSubstring string w adalah string yang dihasilkan dari string w dengan menghilangkan satu atau lebih simbol-simbol paling depan dan/atau simbolsimbol paling belakang dari string w tersebut. Contoh : ab, bc, a, b, c, dan adalah semua Substring(x) o Subsequence string w adalah string yang dihasilkan dari string w dengan menghilangkan nol atau lebih simbol-simbol dari string w tersebut. Contoh : abc, ab, bc, ac, a, b, c, dan adalah semua Subsequence(x) o ProperSubsequence string w adalah string yang dihasilkan dari string w dengan menghilangkan satu atau lebih simbol-simbol dari string w tersebut. Contoh : ab, bc, ac, a, b, c, dan adalah semua Subsequence(x)
15
o Concatenation adalah penyambungan dua buah string. Operator concatenation adalah concate atau tanpa lambang apapun. Contoh : concate(xy) = xy = abc123 o Alternation adalah pilihan satu di antara dua buah string. Operator alternation adalah alternate atau |. Contoh : alternate(xy) = x|y = abc atau 123 o Kleene Closure : x* = |x|xx|xxx|… = |x|x2 |x3 |… o Positive Closure : x+ = x|xx|xxx|… = x|x2 |x3 |…
2.1.5
Sifat-sifat Operasi String o Tidak selalu berlaku : x = Prefix(x)Postfix(x) o Selalu berlaku : x = Head(x)Tail(x) o Tidak selalu berlaku : Prefix(x) = Postfix(x) atau Prefix(x) o Selalu berlaku : ProperPrefix(x) o Selalu berlaku : Head(x)
Postfix(x)
ProperPostfix(x)
Tail(x)
o Setiap Prefix(x), ProperPrefix(x), Postfix(x), ProperPostfix(x), Head(x), dan Tail(x) adalah Substring(x), tetapi tidak sebaliknya o Setiap Substring(x) adalah Subsequence(x), tetapi tidak sebaliknya o Dua sifat aljabar concatenation : a. Operasi concatenation bersifat asosiatif : x(yz) = (xy)z b. Elemen identitas operasi concatenation adalah : x = x = x o Tiga sifat aljabar alternation : a. Operasi alternation bersifat komutatif : x|y = y|x b. Operasi alternation bersifat asosiatif : x|(y|z) = (x|y)|z c. Elemen identitas operasi alternation adalah dirinya sendiri : x|x = x o Sifat distributif concatenation terhadap alternation : x (y|z) = xy|xz o Beberapa kesamaan : a. Kesamaan ke-1 : (x*)* = (x*) b. Kesamaan ke-2 : |x+ = x+ | = x* c. Kesamaan ke-3 : (x|y)* =
|x|y|xx|yy|xy|yx|… = semua string yang
merupakan concatenation dari nol atau lebih x, y, atau keduanya.
16
2.2 Grammar dan Bahasa 2.2.1
Definisi
Tata Bahasa (grammar) bisa didefinisikan secara formal sebagai kumpulan dari himpunan-himpunan variabel, simbol-simbol terminal, simbol awal, yang dibatasi oleh aturan-aturan produksi. Bahasa adalah himpunan kalimat-kalimat. Anggota bahasa bisa tak hingga kalimat. Kalimat adalah deretan hingga (string) yang tersusun atas simbol-simbol terminal. Sentensial adalah string yang tersusun atas simbol-simbol terminal atau simbolsimbol non terminal atau campuran keduanya. Kalimat adalah merupakan sentensial, sebaliknya belum tentu. Derivasi adalah proses pembentukan sebuah kalimat atau sentensial. Sebuah derivasi dilambangkan sebagai : α
2.2.2
β.
Simbol
A. Simbol Terminal Pengertian terminal berasal dari kata terminate (berakhir), maksudnya derivasi berakhir jika sentensial yang dihasilkan adalah sebuah kalimat (yang tersusun atas simbol-simbol terminal itu). Simbol terminal adalah simbol yang tidak dapat diturunkan lagi. Simbol-simbol berikut adalah simbol terminal : -
huruf kecil awal alfabet, misalnya : a, b, c
-
simbol operator, misalnya : +, −, dan ×
-
simbol tanda baca, misalnya : (, ), dan ;
-
string yang tercetak tebal, misalnya : if, then, dan else.
B. Simbol Non Terminal Pengertian non terminal berasal dari kata not terminate (belum/tidak berakhir), maksudnya derivasi belum/ tidak berakhir jika sentensial yang dihasilkan mengandung simbol non terminal. Simbol variabel /non terminal adalah simbol yang masih bisa diturunkan. Simbol-simbol berikut adalah simbol non terminal :
17
-
huruf besar awal alfabet, misalnya : A, B, C
-
huruf S sebagai simbol awal
-
string yang tercetak miring, misalnya :
-
expr dan stmt
Huruf besar akhir alfabet melambangkan simbol terminal atau non terminal, misalnya : X, Y, Z. Huruf kecil akhir alfabet melambangkan string yang tersusun atas simbol-simbol terminal, misalnya : x, y, z. Huruf yunani melambangkan string yang tersusun atas simbol-simbol terminal atau simbol-simbol non terminal atau campuran keduanya, misalnya : α, β, dan γ.
2.2.3
Aturan Produksi Aturan produksi men-spesifikasikan bagaimana suatu tatabahasa melakukan transformasi suatu string ke bentuk lainnya. Melalui aturan produksi didefinisikan suatu bahasa yang berhubungan dengan tata bahasa tersebut. Sebuah produksi dilambangkan sebagai α → β (bisa dibaca
menghasilkan ),
artinya : dalam sebuah derivasi dapat dilakukan penggantian simbol α dengan simbol β. Simbol α dalam produksi berbentuk α → β disebut ruas kiri produksi sedangkan simbol β disebut ruas kanan produksi. Contoh aturan produksi : T → a , dibaca: T menghasilkan a E → T | T+E, dibaca: E menghasilkan T atau E menghasilkan T+E merupakan pemendekan dari aturan produksi : E→T E → T+E 2.2.4
Grammar Grammar G didefinisikan sebagai pasangan 4 tuple : VT, VN, S, dan P. Dituliskan sebagai G(VT, VN, S, P), dimana :
18
- VT
: himpunan simbol-simbol terminal (alfabet)
- VN
: himpunan simbol-simbol non terminal.
- S∈ VN
: simbol awal (atau simbol start)
-P
: himpunan produksi.
kamus.
Contoh Grammar : 1. G1 : VT = {I, Love, Miss, You}, VN = {S,A,B,C}, P = {S → ABC, A→ I, B→ Love | Miss, C→ You} S
ABC IloveYou
L(G1)={IloveYou, IMissYou} 2. G2 : VT = {a}, VN = {S}, P = {S → aSa} S
aS aaS aaa
L(G2) ={an n
1}
L(G2)={a, aa, aaa, aaaa,…} 2.2.5
Klasifikasi Chomsky Noam Chomsky melakukan penggolongan tingkatan bahasa berdasarkan aturan produksinya yang disebut dengan Hierarki Chomsky (1959). Berdasarkan komposisi bentuk ruas kiri dan ruas kanan produksinya (α → β), Noam Chomsky mengklasifikasikan 4 tipe grammar. Tipe sebuah grammar (atau bahasa) ditentukan dengan aturan sebagai berikut : A language is said to be type-i (i = 0, 1, 2, 3) language if it can be specified by a type-i grammar but can’t be specified any type-(i+1) grammar.
Klasifikasi Chomsky 1. Grammar tipe ke-0 : Unrestricted Grammar (UG) Ciri : α, β ∈ (VTVN)*, α > 0
19
Mesin automata : Mesin Turing Aturan Produksi : tidak ada batasan Contoh : Bahasa manusia/bahasa alami, misalnya Abc → De
2. Grammar tipe ke-1 : Context Sensitive Grammar (CSG) Ciri : α, β ∈ (VTVN) *, 0 < α ≤ β Mesin automata : Linier Bounded Automata Aturan Produksi : | | | | Contoh : Ab → DeF, CD → eF, S → * |s| = 1, | | = 0, ada perkecualian sehingga S →
dianggap
memenuhi context sensitive grammar. 3. Grammar tipe ke-2 : Context Free Grammar (CFG) Ciri : α ∈ VN, β ∈ (VTVN)* Mesin automata : PDA Aturan Produksi :
berupa sebuah simbol variable
Contoh : B → CDeFg, D → BcDe
4. Grammar tipe ke-3 : Regular Grammar (RG) Ciri : α ∈ VN, β ∈ {VT, VTVN} atau α ∈ VN, β ∈ {VT, VNVT} Mesin automata : FSA meliputi DFA & NFA Aturan Produksi : -
adalah sebuah simbol variable
-
maksimal memiliki sebuah symbol variabel yang bila ada terletak di posisi paling kanan
Contoh : A → e, A → efg, A → efgH, C → D
20
Mesin Pengenal Bahasa Kelas Bahasa
Mesin Pengenal Bahasa
Unrestricted Grammar (UG)
Mesin Turing (Turing Machine), TM
Context Sensitive Grammar (CSG)
Linear Bounded Automaton, LBA
Context Free Gammar (CFG)
Pushdown Automata, PDA
Regular Grammar, RG
Finite State Automata, FSA
Keterkaitan Bahasa
2.2.6
Analisa Grammar A.
Analisa Penentuan Type Grammar 1. Grammar G1 dengan P1 = {S → aB, B → bB, B → b}. Ruas kiri semua produksinya terdiri dari sebuah VN, maka G1 kemungkinan tipe CFG atau RG. Selanjutnya karena semua ruas kanannya terdiri dari sebuah VT atau string VTVN maka G1 adalah RG (3). 2. Grammar G2 dengan P2 = {S → aAb, B → aB}. Ruas kiri semua produksinya terdiri dari sebuah VN maka G2 kemungkinan tipe CFG atau RG. Selanjutnya karena ruas kanannya mengandung string yang panjangnya lebih dari 2 (yaitu aAb) maka G2 bukan RG, dengan kata lain G2 adalah CFG (2). 3. Grammar G3 dengan P3 = {S → aA, S → aB, aAb → aBCb}.
21
Ruas kirinya mengandung string yang panjangnya lebih dari 1 (yaitu aAb) maka G3 kemungkinan tipe CSG atau UG. Selanjutnya karena semua ruas kirinya lebih pendek atau sama dengan ruas kananya maka G3 adalah CSG (1). 4. Grammar G4 dengan P4 = {S → aAb, B → aB}. Ruas kiri semua produksinya terdiri dari sebuah VN maka G4 kemungkinan tipe CFG atau RG. Selanjutnya karena ruas kanannya mengandung string yang panjangnya lebih dari 2 (yaitu aAb) maka G4 bukan RG, dengan kata lain G4 adalah CFG (2). B.
Derivasi Kalimat dan Penentuan Bahasa Tentukan bahasa dari masing-masing gramar berikut : 1. G1 dengan P1 = {1. S → aAa, 2. A → aAa, 3. A → b}. Jawab : Derivasi kalimat terpendek :
Derivasi kalimat umum :
S
S
aAa
(1)
aba
(3)
aAa
(1)
aaAaa
(2)
… anAan
(2)
anban
(3)
Dari pola kedua kalimat disimpulkan : L1 (G1) = {anban n ≥ 1} 2. G2 dg P2 = {1. S → aS, 2. S → aB, 3. B → bC, 4. C → aC, 5. C → a}. Jawab : Derivasi kalimat terpendek :
Derivasi kalimat umum :
S
aB
(2)
S
abC
(3)
…
aba
(5)
aS
(1)
an-1S
(1)
an B
22
(2)
anbC
(3)
anbaC
(4)
… anbam-1C
(4)
anbam
(5)
Dari pola kedua kalimat disimpulkan : L2 (G2)={anbam n ≥1, m≥1} C.
Menentukan Grammar Sebuah Bahasa 1. Tentukan sebuah gramar regular untuk bahasa L1 = { an n ≥ 1} Jawab :
P1 (L1) = {S → aSa}
2. Tentukan sebuah gramar bebas konteks untuk bahasa : L2 : himpunan bilangan bulat non negatif ganjil Jawab : Langkah kunci : digit terakhir bilangan harus ganjil. Vt={0,1,2,..9} Vn ={S,G,J} P = {S HT|JT|J; T GT|JT|J; H 2|4|6|8; G 0|2|4|6|8;J 1|3|5|7|9} P={S GS|JS|J; G 0|2|4|6|8;J 1|3|5|7|9} Buat dua buah himpunan bilangan terpisah : genap (G) dan ganjil (J) P2(L2) = {S → JGSJS, G → 02468, J → 13579}
23
Bab III FINITE STATE AUTOMATA Finite State Automata/ FSA adalah mesin yang dapat mengenali bahasa reguler tanpa menggunakan storage (memory). FSA tidak memiliki tempat penyimpanan (memory), tetapi hanya bisa mengingat state terkini saja. FSA disebut juga dengan Automata Hinga (AH). FSA/ AH sangat berhubungan dengan Regular Grammar. Dan merupakan kelas mesin dengan kemampuan-kemampuan yang paling terbatas. FSA memiliki state yang berhingga banyaknya dan dapat berpindah dari satu state ke state lainnya berdasar input dan fungsi transisi. Sejumlah status dapat didefinisikan pada mesin untuk “mengingat” beberapa hal secara terbatas.
Manfaat nyata: 1. Software untuk mendesain dan mengecek perilaku sirkuit digital. Contoh: mesin ATM. 2. Bagian“Lexical Analyzer” dari berbagai kompiler yang berfungsi membagi teks input menjadi logical unit seperti Keyword, Identifier, dan pungtuasi. 3. Search engine
3.1
menscan web, dan menemukan kata, frase atau pola yang tepat.
Definisi Formal Definisi 1: FSA didefinisikan sebagai pasangan 5 tupel : (Q, , , S, F). Q : himpunan hingga state : himpunan hingga simbol input (alfabet) : fungsi transisi, menggambarkan transisi state FSA akibat pembacaan simbol input. Fungsi transisi ini biasanya diberikan dalam bentuk tabel. S ∈ Q : state AWAL F ⊂ Q : himpunan state AKHIR Mekanisme kerja FSA dapat diaplikasikan pada: elevator, text editor, analisa leksikal, pencek parity.
24
3.2
Fungsi Transisi Untuk q, r ∈ Q dan a ∈ , jika (q,a) = r terdefinisi, maka saat mesin berada dalam status q menerima masukan simbol a, mesin akan bertransisi ke status r. Dengan diagram status digambarkan dengan bulatan dan transisi dengan panah, sbb:
Contoh : FSA untuk mengecek parity ganjil Q ={Gnp, Gjl} = {0,1} =
S = Gnp F = {Gjl} Diagram Transisi untuk mengecek parity ganjil
3.3
Jenis – jenis FSA Ada dua jenis FSA : 1. Deterministic finite automata (DFA). o Transisi state FSA akibat pembacaan sebuah simbol bersifat tertentu. :Q× →Q o Dari suatu state ada tepat satu state berikutnya untuk setiap simbol masukan yang diterima. 2. Non deterministik finite automata (NFA). o Transisi state FSA akibat pembacaan sebuah simbol bersifat tak tentu. :Q×
→ 2Q
25
o Dari suatu state ada 0, 1 atau lebih state berikutnya untuk setiap simbol masukan yang diterima.
3.4
Deterministic finite automata (DFA) DFA disebut juga dengan Automata Hingga Deterministik (AHD). AHD sering digambarkan dengan dua cara : •
Table Transisi State
•
Transisi Digraph
Contoh DFA : 1. Pengujian parity ganjil. 2. Pengujian untuk menerima bit string dengan banyaknya 0 genap, serta banyaknya 1 genap. -
0011 : diterima.
-
10010 : ditolak, karena banyaknya 0 ganjil.
Diagram transisi-nya :
1
start
q0
0
0 q2
DFA nya :
1
q1 0
1
0
q3
1
Q = {q0, q1, q2, q3} = {0,1} S = q0 F = {q0} Fungsi transisi ( ) =
-
δ( q0,011)= δ( q2,11) =δ( q3,1)= q2
(Ditolak)
-
δ( q0,1010)= δ( q1,010) =δ( q3,10)=δ( q2,0)= q0
(Diterima)
3. Variabel dalam bahasa pascal diawali oleh huruf (besar/kecil), dan diikuti dengan huruf atau angka. Diagram Transisinya sebagai berikut:
26
A..Z,a..z,0..9 start
q0
A..Z,a..z
q0
0..9
A..Z,a..z,0..9 q0
4. AHD F(Q, , , S, F), dimana: Q = {q0, q1, q2} = {a, b} diberikan dalam tabel berikut : S = q0 F = {q0, q1} Ilustrasi graf untuk AHD F adalah sebagai berikut: -
Lambang state awal adalah node dengan anak panah.
-
Lambang state awal adalah node ganda.
Contoh kalimat yang diterima AHD: a, b, aa, ab, ba, aba, bab, abab, baba Contoh kalimat yang tidak diterima AHD: bb, abb, abba AHD ini menerima semua kalimat yang tersusun dari simbol a dan b yang tidak mengandung substring bb
3.5
Non deterministik finite automata (NFA) Disebut juga Automata Hingga Non Deterministik (AHN). Fungsi transisi dapat memiliki 0 atau lebih fungsi transisi. Sebuah kalimat di terima NFA jika : -
Salah satu tracing-nya berakhir di state AKHIR, atau
-
Himpunan state setelah membaca string tersebut mengandung state AKHIR
27
Contoh NFA: 1. NFA (Q, , , S, F). dimana : Q = {q0, q1, q2,q3, q4} = {a, b,c} diberikan dalam tabel berikut: S = q0 F = {q4} Diagram Transisinya:
Kalimat yang diterima NFA di atas : aa, bb, cc, aaa, abb, bcc, cbb Kalimat yang tidak diterima NFA di atas : a, b, c, ab, ba, ac, bc
2.
G = ({q0 , q1 , q2 , q3, q4 }, {0,1}, δ , q0 , {q2, q4}}
Diagram transisi: 0,1 q3
0,1
0
q4
0 q0
0,1
1 q1
1
28
q2
Mengecek, apakah string 01001 diterima oleh mesin NFA di atas: q0
0
q0
0
1
q0
1 q3
0
q0
0 q1
0
q0
0 q3
1
q0
1 q3
q1
0 q4
3.6
1
q4
Ekuivalen Definisi 2: Dua buah FSA disebut ekuivalen apabila kedua FSA tersebut menerima bahasa yang sama. Contoh : FSA yang menerima bahasa {an | n≥0 } a q4
3.7
a
a
q4
q4
Indistinguishable Definisi 3: Dua buah state dari FSA disebut indistinguishable (tidak dapat dibedakan) apabila :
3.8
-
δ(q,w)∈F sedangkan δ(p,w)∉F dan
-
δ(q,w) ∉F sedangkan δ(p,w) ∈F untuk semua w ∈ Σ*
Distinguishable Definisi 4: Dua buah state dari FSA disebut distinguishable (dapat dibedakan) bila terdapat w ∈ Σ* sedemikian hingga: -
δ(q,w)∈F sedangkan δ(p,w)∉F dan
-
δ(q,w) ∉F sedangkan δ(p,w) ∈F untuk semua w ∈ Σ*
29
3.9
Prosedur menentukan pasangan status indistinguishable 1. Hapus semua state yang tak dapat dicapai dari state awal. 2. Catat semua pasangan state (p,q) yang distinguishable, yaitu {(p,q) | p ∈ F ∧ q ∉ F} 3. Untuk setiap pasangan (p,q) sisanya, 4. untuk setiap a∈ Σ, tentukan δ(p,a) dan δ(q,a) Contoh: q1 0 q0
0
1
0 q2
1
0
1
0,1 q4
1
q3
-
Hapus state yang tidak tercapai (tidak ada)
-
Pasangan distinguishable (q0,q4), (q1,q4), (q2,q4), (q3,q4).
-
Pasangan sisanya (q0,q1), (q0,q2), (q0,q3), (q1,q2) (q1,q3) (q2,q3)
-
Catatan : jumlah pasangan seluruhnya : C
5 5! = = 10 2 2!3!
3.10 Prosedur Reduksi DFA 1. Tentukan pasangan status indistinguishable. 2. Gabungkan setiap group indistinguishable state ke dalam satu state dengan relasi pembentukan grup secara berantai : Jika p dan q indistingishable dan jika q dan r indistinguishable maka p dan r indistinguishable, dan p,q serta r indistinguishable semua berada dalam satu grup. 3. Sesuaikan transisi dari dan ke state-state gabungan.
30
Contoh : -
pasangan status indistinguishable (q1,q2), (q1,q3) dan (q2,q3).
-
q1,q2,q3 ketiganya dapat digabung dalam satu state q123
-
Menyesuaikan transisi, sehingga DFA menjadi 0,1
0 q0
0,1
q123
31
1
q4
Bab IV Ekuivalensi NFA ke DFA
4.1
Algoritma Ekivalensi NFA ke DFA a. Buat semua state yang merupakan subset dari state semula. Jumlah state menjadi 2Q b. Telusuri transisi state–state yang baru terbentuk, dari diagram transisi. c. Tentukan state awal : {q0} d. Tentukan state akhir adalah state yang elemennya mengandung state akhir. e. Reduksi state yang tak tercapai oleh state awal. Contoh: 1. Ubahlah NFA berikut menjadi DFA Diketahui M(Q, , , S, F), dimana: Q = {q0,q1} = {0,1} diberikan dalam tabel berikut : S = q0 F = {q1} Diagram transisi-nya :
1
0 q0
0,1
q1
1 State yang akan dibentuk : {}, {q0} {q1},{q0,q1} Telusuri state
State awal : {q0} State akhir yang mengandung q1, yaitu {q1},{q0,q1}
32
0
{q1}
1
0,1
1
{q0} 1
{}
{q0,q1}
2. Ubahlah NFA berikut menjadi DFA Diketahui M(Q, , , S, F), dimana: Q = {q0,q1,q2} = {p,r } diberikan dalam tabel berikut : S = q0 F = {q1} p,r
Diagram transisi-nya : q0
p
q1
r
q2
p
State yang akan dibentuk :
{}, {q0} {q1},{q2}, {q0,q1}, {q0,q2}, {q1,q2}, {q0,q1,q2} Telusuri state
State awal : {q0} State akhir yang mengandung q1, yaitu {q1},{q1,q2} Reduksi {q0,q1} {q0,q2} {q0,q1,q2 } sehingga FSA menjadi : r {q0}
p
{q1,q2}
p
r
{q1} r
p {}
{q2} p,r
33
p,r
4.2
NFA dengan ε-move Def 1. ε-move adalah suatu transisi antara 2 status tanpa adanya input. Contoh transisi antara status q1 ke q2 q0
ε
q1
b
b
ε
q3
b
q4
ε
q2
Def 2. ε-closure adalah himpunan state yang dapat dicapai dari suatu state tanpa adanya input. Contoh gambar :
4.3
-
ε-closure(q0) = [q0,q1,q3]
-
ε-closure(q1) = [q1,q3]
-
ε-closure(q3) = [q3]
Ekuivalensi NFA dengan ε-move ke NFA tanpa ε-move Algoritma: a. Buat tabel transisi NFA dengan ε-move b. Tentukan ε-closure setiap state c. Carilah fungsi transisi/ tabel transisi yang baru, rumus : δ’(state,input) = ε-closure(δ(ε-closure(state,input)) d. Tentukan state akhir ditambah dengan state yang ε-closure nya menuju state akhir, rumusnya : F’ = F ∪ {q | (ε-closure(q) ∩ F ≠ ∅} Contoh : q0
ε
q1
a
q2
b q3
Tabel transisi-nya
34
ε-closure dari FSA tersebut -
ε-closure(q0) = [q0,q1]
-
ε-closure(q1) = [q1]
-
ε-closure(q2) = [q2]
-
ε-closure(q3) = [q3]
Cari tabel transisi yang baru (δ’) :
Hasilnya menjadi : a
q2 a
q0
q1 b b
4.4
q3
Penggabungan FSA Bila diketahui L1 adalah bahasa yang diterima oleh M1 dan L2 adalah bahasa yang diterima oleh M2 maka : a. FSA M3 yg dapat menerima L1+L2 dibuat dengan cara -
Tambahkan state awal untuk M3, hubungkan dengan state awal M1 dan state awal M2 menggunakan transisi ε
-
Tambahkan state akhir untuk M3, hubungkan dengan state-state akhir M1 dan state-state akhir M2 menggunakan transisi ε 35
b. FSA M4 yg dapat menerima L1L2 dibuat dengan cara -
State awal M1 menjadi state awal M4
-
State-state akhir M2 menjadi state-state akhir M4
-
Hubungkan state-state akhir M1 dengan state awal M2 menggunakan transisi ε
Contoh : - FSA M1 dan M2 0 qA0
1
1
qA1
qB0
1
qB1
0 - FSA M3
0 qA0
1
qA1
ε qS
ε 1
ε
ε qB0
1
qF
qB1
0
- FSA M4
0 qA0
1
1 qA1
ε
qB0
1 0
36
qB1
Bab V Ekspresi Reguler
5.1
Bahasa regular Bahasa disebut reguler jika terdapat FSA yang dapat menerimanya. Bahasa reguler dinyatakan secara sederhana dengan ekspresi reguler/regular expression (RE). Contoh penerapan : searching string pada file Hubungan RE dan NFA : Setiap RE ada satu NFA dengan ε-move yang ekuivalen. Konversi bentuk dari ekspresi regular menjadi bentuk DFA: RE -> NFA dengan ε Move -> DFA
Definisi ekspresi reguler Jika Σ merupakan himpunan simbol, maka -
∅ , ε , dan a ∈ Σ adalah ekspresi reguler dasar
-
Jika r dan t masing masing merupakan ekspresi reguler maka komposisi berikut merupakan ekspresi reguler : Ekspresi
Makna
r+t
himpunan string gabungan R∪T
rt
operasi penyambungan string thd himpunan
r*
Kleene closure dari R
(r)
r
Contoh ekspresi reguler -
(0+1)* : himpunan seluruh string yang dapat dibentuk dari simbol ‘0’ dan ‘1’
-
(0+1)*00(0+1)* : himpunan string biner yang mengandung paling sedikit satu substring ‘00’
-
(0+1)*00 : himpunan string biner yang diakhiri dengan ‘00’
Apabila r adalah RE, maka L(r) adalah bahasa reguler yang dibentuk menggunakan ekspressi reguler r. 37
1. Tentukan bahasa reguler yang dibentuk oleh r = (aa)* Jawab: L(r)
=
L( (aa)* )
=
{ε, aa, aaaa, aaaaaa, ... }
=
{ a2 n | n ≥ 0 }
menyatakan himpunan string a dengan jumlah genap 2. Tentukan ekspresi reguler pembentuk bahasa pada Σ = {0,1}, yaitu L(r)
= { w ∈ Σ* | w memiliki substring ‘00’}
Jawab: r = (0+1)*00(0+1)*
5.2
Sifat Bahasa Reguler a. Tertutup terhadap operasi himpunan sederhana Jika L1 dan L2 adalah bahasa reguler, maka L1∪L2, L1∩L2, L1L2, ~(L1) dan L1* adalah bahasa reguler juga b. Tertutup terhadap homomorphic image -
Jika L1 adalah bahasa reguler, maka homomorphic image h(L1) adalah bahasa reguler juga.
-
Dimisalkan Σ dan Γ adalah alfabet, maka fungsi homomorphic dinyatakan dengan h : Σ → Γ
-
Jika w = a1 a2 ... an, maka h(w) = h(a1) h(a2 ) ... h(an)
-
Jika L adalah bahasa pada Σ maka homomorphic image bahasa L adalah h(L)= { h(w) | w∈L}
Contoh: Dimisalkan Σ = {a,b} dan Γ = {a,b,c} dan didefinisikan h(a) = ab dan h(b) =bbc homomorphic image bahasa L = {aa,aba } adalah : Jawab: h(L)= { abab, abbbcab}
38
5.3
Konversi ekspresi reguler ke FSA
Contoh : Tentukan FSA untuk ekspresi reguler r = 0(1 | 23)*
5.4
DFA dan Tatabahasa Reguler 5.4.1
Tatabahasa Linier kiri dan linier kanan Suatu tatabahasa G(T,N,S,P) disebut linier kiri jika seluruh aturan produksinya berbentuk A → xB dengan A, B ∈ N dan x ∈ T*
Suatu tatabahasa G(T,N,S,P) disebut linier kanan jika seluruh aturan produksinya berbentuk A → Bx dengan A, B ∈ N dan x ∈ T* Tatabahasa reguler bisa bersifat linier kiri atau linier kanan.
39
Contoh : -
Tatabahasa G = { {a,b}, {S}, S, P } dengan aturan produksi P adalah S → abS |a adalah tatabahasa linier kanan /regular
-
Tatabahasa G = {{a,b}, {S, S1,S2}, S, P } dengan aturan produksi P adalah S → S1ab, S1→ S1ab | S2, S2→ a adalah tatabahasa linier kiri /reguler
-
Tatabahasa G = {{a,b}, {S, A, B}, S, P } dengan aturan produksi P adalah S → A, A → aB | ε, B → Ab, adalah bukan tatabahasa regular.
5.4.2
Konversi DFA ke tatabahasa linier Setiap DFA dapat diubah menjadi tatabahasa yang memiliki aturan produksi yang linier. Aturan pengubahan ini adalah sebagai berikut : - setiap transisi status δ(A,a)=B diubah menjadi aturan produksi A → aB - setiap status akhir P diubah menjadi aturan produksi Pε→ Contoh FSA berikut q0
ε
q1
a
q2
b q3
Tatabahasa linier untuk FSA tersebut yaitu G = ({a,b}, {S,S1,S2,S3}, S, P ) dengan aturan produksi P adalah : S → S1, S1 → aS2, S1 → bS3, S3 → ε 5.4.3
Konversi tatabahasa linier ke DFA - setiap aturan produksi A → aB diubah menjadi transisi status δ(A,a)=B - setiap aturan produksi A → a diubah menjadi δ(A,a)=SF - untuk a ∈ T* dengan |a|>1 dapat dibuat state tambahan - setiap aturan produksi A → B diubah menjadi δ(A,ε)=B Contoh: Tata bahasa G = ({a,b}, {V0,V1}, V0, P ) dengan P: V0 →aV1
40
V1 →abV0 | b Mesin FSA nya menjadi V0
a
V1
b
5.5
b
Vf
a
Penerapan ekspresi regular Digunakan untuk memerinci unit-unit leksikal sebuah bahasa pemrograman (token). Contoh: -
ekspresi reguler ‘bilangan real positif’ (0+1+...+9)(0+1+...+9)*.(0+1+...+9) (0+1+...+9)*
5.6
-
ekspresi reguler ‘bilangan bulat’ (‘+’ + ’-‘ + λ) (0+1+...+9)(0+1+...+9)*
-
Editor text
Pumping lemma Apabila suatu bahasa merupakan bahasa reguler maka akan dapat diterima oleh mesin DFA M=(Q,Σ,δ,q0,F), dgn sejumlah state n. Apabila string w dengan |w| ≥ n diinputkan dalam DFA, maka pasti ada simpul k dalam DFA yang dikunjungi lebih dari satu kali. Apabila string diantara simpul k yang sama tersebut ‘dipompa’, maka sisanya pasti masih diterima oleh DFA tersebut. Contoh : Bahasa yang menerima ekspresi reguler 0(10)*11 q0
0
q1
1
0
q3
1 q2
Ambil string w∈L , dengan |w|≥ n: w= 01011 q0
0 q1 1 q2
0
41
q1
1
q3 1
q4
1
q4
simpul q1 dikunjungi 2 kali. String diantara simbol q1 tersebut dapat ‘dipompa’ keluar menjadi
q0
0 q1 1
q3 1
q4
string 011 tersebut masih dapat diterima oleh FSA. Secara formal, Misal L adalah sebuah bahasa reguler infinite, maka terdapat sebuah konstanta n dengan sifat bahwa jika w adalah sebuah string dalam L yang panjangnya lebih besar atau sama dengan n maka kita bisa menulis w = uvx sedemikian sehingga uvix ∈ L untuk semua i ≥ 0. dengan |v|≥1 dan |uv| ≤ n . Notasi matematisnya
(∀L )(∃n )(∀z )
z∈L∧ z ≥ n
(∃u, v, w)(z = uvw ∧ uv ≤ n ∧ v ≥ 1 ∧ (∀i )(uv i w ∈ L ))
Penjelasan, Untuk memperlihatkan bahwa suatu bahasa infinite tidak reguler, maka kita tunjukkan bahwa untuk nilai n yang cukup besar, sekurang-kurangnya satu untai yang panjangnya n atau lebih besar gagal untuk dapat ‘dipompa’ Contoh :
L=
{ai^2 | i≥1} {a1, a4,a9, a16, ...} {a , aaaa , aaaaaaaaa , aaaaaaaaaaaaaaaa, ... }
Suatu string dalam L harus mempunyai panjang yang berupa nilai kuadrat (1,4,9,16, ..., n2, ...). Misal bahwa L adalah bahasa reguler. Perhatikan bahwa terdapat sebuah nilai n sedemikian sehingga an^2 ∈L, Menurut pumping lemma dapat kita tuliskan an^2 = uvx, sedemikian hingga -
1 ≤|v|≤ n
-
(∀i) (uviw ∈ L)
karena |v| ≥1 maka jelas bahwa |uvw|<|uv2w|<|uv2w|< ... ambil i = 2 maka kita dapatkan n2 = |uvw| < |uv2w| ≤ n2 + n < (n+1)2 Jelas bahwa n2 < |uv2w| < (n+1)2 Panjang |uv2w| bukan merupakan kuadrat sempurna, karena berada diantara 2 nilai kuadrat sempurna yang berurutan.Berarti uv2w ∉ L Jadi disimpulkan bahwa L = {ai^2 | i≥1} bukan merupakan bahasa reguler. 42
Bab VI FSA dengan Output
Konsep FSA dengan output FSA: merupakan accepter, dapat menerima atau tidak. FSA dengan output : transducer -
Mesin Moore :output berasosiasi dengan state
-
Mesin Mealy :output berasosiasi dengan transisi
6.1 Mesin Moore M = (Q,Σ,δ,S,∆,λ) Q : himpunan state Σ : himpunan simbol input δ : fungsi transisi S : state awal S ∈Q ∆ : himpunan output λ : fungsi output untuk setiap state Contoh: Mesin moore untuk memperoleh modulus 3 pada suatu bilangan biner: M = (Q,Σ,δ,S,∆,λ) Q : q0,q1,q2 Σ : [0,1] S : q0 ∆ : [0,1,2] λ(q0) =0 λ(q1) =1 λ(q2) =2 Prinsip: -
jika i diikuti dengan 0, maka hasilnya 2i
43
1012 =5 -
jika i diikuti dengan 1, maka hasilnya 2i+1 1012=5
-
10102 = 2*5 =10 10112 = 2*5+1 =11
jika i/3 mempunyai sisa p, maka untuk input berikutnya bernilai 0 maka 2i/3 mempunyai sisa 2p mod 3 a. untuk p=0 maka 2p mod 3 = 0 b. untuk p=1 maka 2p mod 3 = 2 c. untuk p=2 maka 2p mod 3 = 1
-
jika i/3 mempunyai sisa p, maka untuk input berikutnya bernilai 1 maka (2i+1)/3 mempunyai sisa (2p+1) mod 3 a. untuk p=0 maka (2p+1) mod 3 = 1 b. untuk p=1 maka (2p+1) mod 3 = 0 c. untuk p=2 maka (2p+1) mod 3 = 2
-
Sehingga didapat mesin FSA sbb : 0 q0/0
1 1 1
-
q1/1
0
q2/2
0
Contoh : a. input 5 (1012) , state terakhir q2/2 , 5 mod 3 = 2 b. input 10 (10102) ,state terakhir q1/1, 10 mod 3=1
6.2 Mesin Mealy M = (Q,Σ,δ,S,∆,λ) Q : himpunan state Σ : himpunan simbol input δ : fungsi transisi S : state awal S ∈Q ∆ : himpunan output λ : fungsi output untuk setiap transisi Contoh: Mesin Mealy untuk mendeteksi ekspresi reguler (0+1)*(00+11) 44
Jawab : M = (Q,Σ,δ,S,∆,λ) Q : q0,q1,q2 Σ : [0,1]
0/Y q1
S : q0
0/T
∆ : [0,1,2] q0
λ(q0,0) =T
1/T
λ(q0,1) =T
1/T q2
λ(q1,0) =Y 1/Y
λ(q1,1) =T λ(q2,0) =T λ(q2,1) =Y
6.3 Ekuivalensi mesin Moore dengan mesin Mealy 6.3.1
Mesin Moore ke mesin Mealy Jml state = jml state sebelum * jml output 1 1 q0T
0
q1T
0
0
0 q0Y
q2T 1
1
q1Y 0
6.3.2
0
q2Y 1
Mesin Mealy ke mesin Moore -
Menambah label output pada transisi
-
Menghapus label output pada state
45
0/T
0/0 q0
1/2 1/1
q1
1/0
0/2
q2
0/1
Contoh kasus 1: Tentukan FSA dari rangkaian sirkuit berikut ini. Asumsi bahwa terdapat waktu yang cukup untuk perambatan sinyal menuju kondisi yang stabil.
y1
F input x
y2
Contoh kasus 2 Kelereng dijatuhkan dari A atau B. Percabangan x1,x2 dan x3 menentukan saluran mana yang akan dilewati kelereng (kiri / kanan). Ketika percabangan dilewati, kelereng berikutnya akan melewati dengan saluran berbeda. Buatlah FSA nya A
B
X1
X2 X3
C
D
46
Bab VII Bahasa Bebas Konteks
7.1 Tata Bahasa Bebas Konteks Deskripsi bahasa alami
→ <subjek> <predikat>
<subjek>
→
<predikat>
→
→ kucing
→ berlari
→ menyapu
Contoh kalimat yang dapat dihasilkan kucing berlari kucing menyapu (sintaks yes, semantik no) Dalam tatabahasa bebas konteks -
Ruas kiri dari aturan produksi terdiri dari SATU simbol non terminal
-
Ruas kanan dapat berupa string yang dibentuk dari simbol terminal dan non terminal.
Contoh 1. S →aSb | ε Kalimat-kalimat yang dibangkitkan dari aturan produksi itu adalah ε,ab,aabb,aaabbb,... , anbn 2. A →0A0 A →1A1 A→a Kalimat-kalimat yang dibangkitkan dari aturan produksi itu adalah a,01a10, 1001a1001 , 110a011 βaβR 3. S → aSb | SS |ε
47
Bahasa yang dihasilkan oleh tatabahasa dengan aturan produksi di atas: L = {w ∈ (a + b)* |na(w) =nb(w) }
7.2 Leftmost dan Rightmost Derivation Suatu penguraian/ penurunan dikatakan leftmost derivation bila setiap tahapan penurunan variabel / non terminal terkiri yang diuraikan. Apabila setiap tahapan penurunan variabel / non terminal paling kanan yang diuraikan disebut rightmost derivation. Contoh 1: -
G = ({A,B,S}, {a,b},S,P} dengan aturan produksi P : S → AB A→ aaA | λ B→Bb | λ
-
Menspesifikasikan bahasa L(G) = {a2nbm | n≥0 , m≥0}
-
Leftmost derivation untuk menghasilkan string aab S
-
AB
aaAB
aaB
aaBb
aab
Righmost derivation untuk menghasilkan string aab S
AB
ABb
aaABb
aaAb
aab
Contoh 2: -
G = ({A,B,S}, {a,b},S,P} dengan aturan produksi P : S → aAB A→ bBb B→ A | λ
-
Leftmost derivation untuk menghasilkan string abbbb S
-
aAB
abBbB
abAbB
abbBbbB
abbbbB
Righmost derivation untuk menghasilkan string aab S
aAB
aA
abBb
abAb
48
abbBbb
abbbb
abbbb
7.3 Pohon urai Untuk menampilkan penguraian, dapat dilakukan dengan membentuk pohon urai (urutan penguraian tidak terlihat). Pohon urai untuk contoh sebelumnya : S a
A b
B λ
B b
A b
B
b
λ
7.4 Parsing dan Keanggotaan Untuk menentukan apakah string w berada di L(G), dengan cara secara sistematis membangun semua kemungkinan penurunan, dan mencocokkan hasilnya apakah ada yang sama dengan string w. (disebut exhaustive search parsing) Contoh : Menentukan apakah string ab berada pada bahasa yang dibentuk oleh grammar dengan aturan produksi
S → SS | aSb | bSa | λ
Untuk penguraian pertama 1. S
SS
2. S
aSb
3. S
bSa
4. S
λ
Penguraian nomor 3 dan 4 tidak perlu dilanjutkan. Penguraian 1 membentuk:
Penguraian 2 membentuk:
1a. S
SS
SSS
2a. S
aSb
aSSb
1b. S
SS
aSbS
2b. S
aSb
aaSbb
1c. S
SS
bSaS
2c. S
aSb
abSab
1d. S
SS
S
2d. S
aSb
ab
49
7.5 Ambiguitas pada Tatabahasa dan Bahasa Tatabahasa bebas konteks G disebut ambigu jika terdapat beberapa w ∈ L(G) yang mempunyai paling sedikit dua buah pohon penurunan. Contoh pada tatabahasa dengan aturan produksi S → SS | aSb | λ string aabb mempunyai 2 pohon penurunan :
S
S
a
S
b
a
S
b
S λ
λ
S a
S
b
a
S
b
λ 7.6 Pumping Lemma untuk bahasa bebas konteks Jika suatu rangkaian simbol /string yang cukup panjang yang merupakan sebuah bahasa bebas konteks, maka kita dapat menemukan dua substring yang jaraknya berdekatan yang jika dipompa, string baru yang diperoleh merupakan bahasa bebas konteks juga. Secara formal, lemma diatas dinyatakan dengan z∈L∧ z ≥ n
(∀L )(∃n )(∀z )
(∃u, v, w, x, y )
z = uvwxy ∧ vwx ≤ n ∧ vx ≥ 1
(∀i )(uv i wx i y ∈ L )
Syarat “ kedua lokasi berdekatan” dinyatakan dengan kondisi |vwx| ≤ n Jika salah satu v atau x diambil sebagai string kosong, maka lemma diatas berubah menjadi lemma untuk bahasa regular. Contoh tatabahasa dengan aturan produksi: S →uAy A → vAx A→w maka aturan derivasinya 50
S
uAy
uwy
S
uAy
uvAxy
uvwxy
S
uAy
uvAxy
uvvAxxy
uvvwxxy
sehingga untuk setiap i ≥0 , uviwxiy ∈ L
7.7 Sifat - sifat tertutup bahasa bebas konteks
1. Gabungan dua CFL merupakan CFL juga Jika diketahui dua buah CFG G1= (N1,T1,S1,P1) dan G2=(N2,T2,S2,P2) yang menghasilkan bahasa L1 dan L2 , maka CFG L1 ∪ L2 dapat dibentuk dengan cara : -
Menggabungkan kedua himpunan dan menambahkan satu simbol variabel baru S.
-
Menggabungkan kedua himpunan simbol terminal.
-
Menggabungkan kedua himpunan aturan produksi dan menambahkan satu aturan produksi baru S → S1|S2 yang digunakan untuk memilih salah satu simbol awal S1 atau S2 dari simbol awal baru S. G3 = (N1∪N2∪{S},T1∪T2 ,S,P1∪P2 ∪{S→S1|S2}}
2. Penyambungan dua CFL merupakan CFL juga Jika diketahui dua buah CFG G1= (N1,T1,S1,P1) dan G2=(N2,T2,S2,P2) yang menghasilkan bahasa L1 dan L2 , maka bahasa L1L2 dapat dibentuk oleh : G4 = (N1∪N2∪{S},T1∪T2 ,S,P1∪P2 ∪{S→S1S2}} 3. Kleene Klosure dari CFL adalah CFL juga. Kleene Klosure dari tatabahasa G=(N,T,S1,P) adalah G5 = (N ∪ {S} , T , S , P ∪ {S → S1S | ε } ) 4. Bahasa bebas konteks tertutup terhadap substitusi Contoh: La = {0 n1n | n ≥1 } dan Lb = { wwR | w ∈ (0+2)* } dihasilkan oleh tatabahasa Ga dengan aturan produksi Sa → 0Sa1 | 01 serta tatabahasa G2 dengan aturan produksi Sb → 0Sb0 | 2Sb2 | ε
51
7.8 Substitusi
Didefinisikan tatabahasa G dengan aturan produksi
S → aSbS | bSaS | ε
jika f adalah substitusi f(a)= La dan f(b) = Lb maka f(L) adalah bahasa yang dihasilkan oleh tatabahasa dengan aturan produksi S → SaSSbS | SbSSaS | ε Sa → 0Sa1 | 01 Sb → 0Sb0 | 2Sb2 | ε
7.9 Tatabahasa Bebas Konteks dan Bahasa Pemrograman
Tatabahasa bebas konteks digunakan untuk mendefinisikan sintaks bahasa pemrograman menggunakan notasi BNF (Backus-Naur Form) -
variabel / non terminal : <...>
-
terminal : tanpa tanda
-
← diganti dengan ::=
Contoh statemen if then else < if_statement> ::= if <expression> <else_clause>
52
Bab VIII Penyederhanaan Tata Bahasa Bebas Konteks
Tujuan Melakukan pembatasan sehingga tidak menghasilkan pohon penurunan yang memiliki kerumitan yang tidak perlu atau aturan produksi yang tidak berarti. Contoh 1. S
AB | a
A a Aturan produksi S
AB tidak berarti karena B tidak memiliki penurunan
2. S A A B B C C D D
a|A
Memiliki kelemahan terlalu panjang jalannya padahal berujung pada S produksi D
a,
A juga menyebabkan kerumitan.
Cara Penyederhanaan: 1. Penghilangan produksi useless (tidak berguna) 2. Penghilangan produksi unit 3. Penghilangan produksi
8.1
Penghilangan Produksi Useless
Di sini produksi useless didefinisikan sebagai produksi yang memuat simbol variabel yang tidak memiliki penurunan yang akan menghasilkan terminal-terminal seluruhnya. Produksi yang tidak akan pernah dicapai dengan penurunan apapun dari simbol awal, sehingga produksi itu redundan (berlebih) Prinsipnya Setiap kali melakukan penyederhanaan diperiksa lagi aturan produksi yang tersisa, apakah semua produksi yang useless sudah hilang.
53
Contoh : 1. S
aSa | Abd | Bde
A
Ada
B
BBB | a
Maka, -
Simbol variabel A tidak memiliki penurunan yang menuju terminal, sehingga bisa dihilangkan.
-
Konsekuensinya, aturan produksi S
Abd tidak memiliki penurunan
Penyederhanaan menjadi: S aSa | Bde B 2. S
BBB | a
Aa | B
A ab | D B
b|E
C
bb
E
aEa
Maka, -
Aturan produksi A
D, simbol variabel D tidak memiliki penurunan.
-
Aturan produksi C
bb, Penurunan dari simbol S, dengan jalan manapun
tidak akan pernah mencapai C -
Simbol variabel E tidak memiliki aturan produksi yang menuju terminal
-
Konsekuensi no (3) Aturan produksi B
E, simbol variabel E tidak
memiliki penurunan. Maka produksi yang useless:
3. S
Penyederhanaannya menjadi:
A
D
S
C
bb
A
ab
E
aEa
B
b
B
E
aAb | cEB
54
Aa | B
A
dBE | eeC
B
ff
C
ae
D
h
Analisa : -
Aturan produksi S
cEB, A
dBE dapat dihilangkan (E tidak memiliki
penurunan) -
Aturan produksi D
h, redundan
Sisa aturan produksi S
aAb
A
eeC
B
ff
C
ae
Hasil penyederhanaan : S
aAb
A
eeC
C
ae
B
ff juga redundan,
Analisis lagi
8.2
Penghilangan Produksi Unit
Produksi dimana ruas kiri dan kanan aturan produksi hanya berupa satu simbol variabel, misalkan: A
B, C
D. Keberadaannya membuat tata bahasa memiliki
kerumitan yang tak perlu. Penyederhanaan dilakukan dengan melakukan penggantian aturan produksi unit. Contoh : 1. S
Sb
S
C
C
D
C
ef
D
dd
55
Dilakukan penggantian berturutan mulai dari aturan produksi yang paling dekat menuju ke penurunan terminal-terminal (‘=>’ dibaca ‘menjadi’): C
D => C
dd
S
C => S
dd | ef
Sehingga aturan produksi setelah penyederhanaan:
2. S
S
Sb
S
dd | ef
C
dd
C
ef
C
dd
A
S
Aa
A
B
B
C
B
b
C
D
C
ab
D
b
Penggantian yang dilakukan : C
D => C
b
B
C => B
b | ab, karena B
b sudah ada, maka cukup dituliskan B
A
B => A
S
A => ab | b
ab | b
Sehingga aturan produksi setelah penyederhanaan: S
ab | b
B
b
S
Aa
C
b
A
ab | b
C
ab
B
ab
D
b
56
ab
8.3
Penghilangan Produksi
Produksi
adalah produksi dalam bentuk
produksi kosong (empty). Penghilangan produksi
, atau bisa dianggap sebagai dilakukan dengan melakukan
penggantian produksi yang memuat variabel yang bisa menuju produksi , atau biasa disebut nullable. Prinsip penggantiannya bisa dilihat kasus berikut: S
bcAd
A A nullable serta A
satu-satunya produksi dari A, maka variabel A bisa
ditiadakan, hasil penyederhanaan tata bahasa bebas konteks menjadi: S
bcd
Contoh: 1. Tetapi bila kasusnya: S
bcAd
A
bd |
A nullable, tapi A
bukan satu-satunya produksi dari A, maka hasil
penyederhanaan:
2. S
S
bcAd | bcd
A
bd
Ab | Cd
A
d
C Variabel yang nullable adalah variabel C. Karena penurunan C merupakan penurunan satu-satunya dari C, maka kita ganti S S
d. Kemudian produksi C
kita hapus.
Setelah penyederhanaan menjadi: S
Ab | d
A
d
3. Contoh tata bahasa bebas konteks: S
AaCD
57
Cd menjadi
A
CD | AB
B
b|
C
d|
D Variabel yang nullable adalah variabel B, C, D. Kemudian dr A
CD, maka variabel A juga nullable ( A
hanya memilki penurunan D S
AaCD => S
A
CD => A
D
). Karena D
, maka kita sederhanakan dulu:
AaC C
kita hapus
Selanjutnya kita lihat variabel B dan C memiliki penurunan , meskipun bukan satu-satunya penurunan, maka dilakukan penggantian: A
AB => A
AB | A | B
S
AaC => S
AaC | aC | Aa | a
B
dan C
kita hapus
Setelah penyederhanaan: S
AaC | aC | Aa | a
A
C | AB | A | B
B
b
C
8.4
Pengembangan praktek
Ketiga penyederhanaan tersebut dilakukan bersama pada suatu tata bahasa bebas konteks, yang nantinya menyiapkan tata bahasa bebas konteks tersebut untuk diubah kedalam suatu Bentuk Normal Chomsky (BNF) Urutan penghapusan aturan produksi : -
Hilangkan produksi
-
Hilangkan produksi unit
-
Hilangkan produksi useless
Contoh: S
AA | C | bd
58
A
Bb |
B
AB | d
C
de
Jawab: -
-
Hilangkan produksi , sehingga menjadi: S
A | AA | C | bd
A
Bb
B
B | AB | d
C
de
Selanjutnya penghilangan produksi unit menjadi: S
Bb | AA | de | bd
A
Bb
B
AB | d
C
de
Penghilangan produksi unit bisa menghasilkan produksi useless. -
-
Terakhir dilakukan penghilangan produksi useless: S
Bb | AA | de | bd
A
Bb
B
AB | d
Hasil akhir aturan produksi tdk lagi memiliki produksi , produksi unit, maupun produksi useless.
59
Bab IX Bentuk Normal Chomsky
9.1 Pengertian
Bentuk normal Chomsky / Chomsky Normal Form (CNF) merupakan salah satu bentuk normal yang sangat berguna untuk tata bahasa bebas konteks (CFG). CNF dapat dibuat dari sebuah tata bahasa bebas konteks yang telah mengalami penyederhanaan yaitu penghilangan produksi, useless, unit, dan . Dengan kata lain, suatu tata bahasa bebas konteks dapat dibuat menjadi CNF dengan syarat tata bahasa bebas konteks tersebut : o
Tidak memiliki produksi useless
o
Tidak memiliki produksi unit
o
Tidak memiliki produksi
9.2 Aturan produksi
Aturan produksi dalam CNF ruas kanannya tepat berupa sebuah terminal atau dua variabel. Misalkan: o
A
BC
o
A
b
o
B
a
o
C
BA | d
9.3 Pembentukan CNF
Langkah-langkah pembentukan CNF secara umum sbb: 1. Biarkan aturan produksi yang sudah dalam CNF. 2. Lakukan penggantian aturan produksi yang ruas kanannya memuat simbol terminal dan panjang ruas kanan > 1. 3. Lakukan penggantian aturan produksi yang ruas kanannya memuat > 2 simbol variabel.
60
4. Penggantian-penggantian tersebut bisa dilakukan berkali-kali sampai akhirnya semua aturan produksi dalam CNF. 5. Selama dilakukan penggantian, kemungkinan kita akan memperoleh aturan-aturan produksi baru, dan juga memunculkan simbol-simbol variabel baru.
9.4 Bagan Tahapan Pembentukan CNF
Contoh (kita anggap CFG sudah mengalami penyederhanaan )
1. S
bA | aB
A
bAA | aS | a
B
aBB | bS | b
-
-
-
Aturan produksi yang sudah dalam CNF: A
a
B
b
Dilakukan penggantian aturan produksi yang belum CNF S
bA => S
P1A
S
aB => S
P1B
A
bAA => S
A
aS => A
B
aBB => B
B
bS => B
P1AA => A
P1P3
P2S P2BB => B
P2P4
P1S
Terbentuk aturan produksi dan simbol variabel baru:
61
-
2. S
P1
b
P2
a
P3
AA
P4
BB
Hasil akhir aturan produksi dalam CNF : A
a
B
b
S
P1A
S
P2B
A
P1P3
A
P2S
B
P2P4
B
P1S
P1
b
P2
a
P3
AA
P4
BB
aB | CA
A
a | bc
B
BC | Ab
C
aB | b
-
-
Aturan produksi yang sudah dalam CNF : S
CA
A
a
B
BC
C
b
Penggantian aturan produksi yang belum dalam CNF : S
aB => S
P1B
A
bc => S
P2P3
B
Ab => B
A P2
62
C -
-
aB => C
P1B
Terbentuk aturan produksi dan simbol variabel baru: P1
a
P2
b
P3
c
Hasil akhir aturan produksi dalam CNF : S
CA
A
a
B
BC
C
b
S
P1B
S
P2P3
B
A P2
C
P1B
P1
a
P2
b
P3
c
9.5 Algoritma CYK untuk Tata Bahasa Bebas Konteks
Algoritma CYK merupakan algoritma parsing dan keanggotaan (membership) untuk tata bahasa bebas konteks. Algortima ini diciptakan oleh J. Cocke, DH. Younger, dan T. Kasami. Syarat untuk penggunaan algortima ini adalah tata bahasa harus berada dalam bentuk CNF. Obyektif dari algortima ini adalah untuk menunjukkan apakah suatu string dapat diperoleh dari suatu tata bahasa. Algoritma CYK sebagai berikut: begin 1. for i:= 1 to n do 2. Vi1 := {A| A
a aturan produksi dimana simbol ke- i adalah a };
3. for j:= 2 to n do
63
4.
for i:= 1 to (n-j+1) do
begin
5.
Vij:=Ø;
6.
for k:=1 to (j – 1) do
7.
Vij:= Vij
(A|A
BC adalah suatu produksi, dimana B di Vik
dan C di Vi+k,j-k } end end
Penjelasan •
n = panjang untai yang akan diperiksa, missal : untuk untai ‘ada’, n = | ada | = 3
•
i akan menyatakan kolom ke-
•
j akan menyatakan baris ke-
•
tahapan no (1) dan (2) untuk mengisi table baris pertama kolom 1 – n
•
no (3), interasi dari baris ke- 2 sampai n
•
no (4), interasi untuk mengisi kolom 1 sampai ( n – baris + 1) pada suatu baris.
•
no (5) inisialisasi Vij dengan Ø
•
no (6) dan no (7), interasi untuk memeriksa mana saja yang menjadi anggota Vij
Contoh kasus terdapat tata bahasa bebas konteks (simbol awal S ) : S
AB | BC
A
BA | a
B
CC | b
C
AB | a
Periksalah apakah untai ‘baaba’ termasuk kedalam bahasa tersebut ! Pertama – tama kita akan membuat tabel untuk Vij ( Vkolom,baris ) sebagai berikut :
64
Tabel diatas kita gunakan untuk mempermudah kita dalam menyelesaikan persoalan, i akan menyatakan kolom, j akan menyatakan baris. Kita ketahui n = 5. Dari Algoritma langkah (1) dan (2) kita bisa mengisi baris pertama pada tabel, sebagai berikut: •
Untuk V11, kita periksa variabel yang bisa menurunkan ‘b’, dari B
b kita isi
V11= {B} •
Untuk V21, kita periksa variabel yang bisa menurunkan ‘a’, dari A
a dan C
a kita isi V21={A,C} •
Untuk V31, kita periksa varibel yang bisa menurunkan ‘a’, dari A
a dan C
a kita isi V31={A,C} •
Untuk V41, kita periksa variabel yang bisa menurunkan ‘b’, dari B
b kita isi
V41={B} •
Untuk V51, kita periksa variabel yang bisa menurunkan’a’, dari A
a dan C
A kita isi V51={A,C} Dari hasil tersebut kita bisa mengisi tabel :
Selanjutnya kita akan mengisi baris ke-2 sampai n sebagai berikut : Pada baris ke -2 ( k =1 ) •
Untuk V12, periksa Vik- Vi+k, j-k, berarti V11-V21, yaitu B-A,C, variabel yang bisa menurunkan BA atau BC adalah S dan A, maka V12 kita isi {S, A}
•
Untuk V22, periksa Vik – Vi+k, j-k, berarti V21-V31, yaitu A,C-A,C, variabel yang bisa menurunkan AA, AC, CA, atau CC adalah B maka V22 kita isi {B}
•
Untuk V32, periksa Vik-Vi+k, j-k, berarti V31-V41 yaitu A, C-B, variabel yang bisa menurunkan AB atau CB adalah S dan C, maka V32 kita isi {S, C}
•
Untuk V42, periksa Vik-Vi+k, j-k berarti V41-V51, yaitu A,C-B, variabel yang bisa menurunkan AB atau CB adalah S dan C, maka V42 kita isi {S,A}
65
Dari hasil tersebut kita bisa mengisi tabel:
Pada baris ke –3 (k = 1 sampai 2): •
Untuk V13, periksa Vik-Vi+k, j-k, berarti V11-V22 & V12-V31, yaitu B-B & S,AA,C, variabel yang bisa menurunkan BB, SA,SC,AA, atau AC adalah tidak ada, maka V13 kita isi ∅
•
Untuk V23, periksa Vik-Vi+k, j-k, berarti V21-V32 & V22-V41, yaitu A,C-S,C & BB, variabel yang bisa menurunkan AS, AC, CS, CC, atau BB adalah B , maka V23 kita isi {B}
•
Untuk V33, periksa Vik-Vi+k, j-k, berarti V31-V42 & V32-V51, yaitu A,C-S,A & S,C-A,C variabel yang bisa menurunkan AS, AA, CS, CA, SA, SC, CA, atau CC adalah B, maka V33 kita isi {B}
Dari hasil tersebut kita bisa mengisi tabel:
Pada baris ke –4 ( k = 1 sampai 3): •
Untuk V14, periksa Vik-Vi+k, j-k, berarti V11-V23 & V12-V32 & V13-V41, yaitu BB & S,A-S,C & ∅-B, variabel yang bisa menurunkan BB, SS, SC, AS AC adalah tidak ada, maka V14 kita isi ∅
•
Untuk V24, periksa Vik-Vi+k, j-k, berarti V21-V33 & V22-V42 & V23-V51, yaitu A,C-B & B-S,A & B-S,A & B-A,C, variabel yang bisa menurunkan AC, AB, BS, BA, BC adalah S, C, A, maka V24 kita isi {S,A,C}
66
Dari hasil tersebut kita bisa mengisi tabel:
Pada baris ke –5 ( k = 1 sampai 4 ) •
Untuk V15, periksa Vik-Vi+k, j-k, berarti V11-V24 & V12-V33 & V13-V42 & V14V51 yaitu B-S,A,C & S,A-B & ∅-S,A & ∅-A,C, variabel yang bisa menurunkan BA, BC, SA, SC, SB, atau AB adalah A,S,C maka V15 kita isi {S,A,C}
Dari hasil tersbut kita bisa mengisi tabel:
Perhatikan •
Syarat suatu untai dapat diturunkan dari simbol awal, V1n memuat simbol awal.
•
Terlihat pada tabel, simbol awal S termuat di V15, maka untai ‘baaba’ dapat diturunkan oleh tata bahasa tersebut.
•
Kita bisa mencoba-coba untuk membuat pohon penurunan dari untai ‘baaba’,
67
Pohon penurunan untuk untai ‘baaba’
68
Bab X Penghilangan Rekursif Kiri
10.1 Aturan Produksi Rekursif
Aturan Produksi yang rekursif memiliki ruas kanan (hasil produksi) yang memuat simbol variabel pada ruas kiri. - Sebuah aturan produksi dalam bentuk: A rekursif kanan.
A merupakan aturan produksi yang
= (V∪T)* atau kumpulan simbol variabel dan terminal.
Contoh aturan produksi yang rekursif kanan: S
dS
B
adB
- Produksi dalam bentuk: A
A merupakan aturan produksi yang rekursif kiri,
Contohnya: S
Sd
B
Bad
Produksi yang rekursif kanan menyebabkan pohon penurunan tumbuh ke kanan, sebaliknya produksi yang rekursif kiri menyebabkan pohon penurunan tumbuh ke kiri.
10.2 Pohon Penurunan
Bisa dilihat pohon penurunan pada gambar dari tata bahasa bebas konteks dengan aturan produksi: S
aAc
A
Ab |
Pohon penurunan sebuah CFG yang rekursif kiri
69
Dalam banyak penerapan tata bahasa, rekursif kiri tak diinginkan. Untuk menghindari penurunan yang bisa mengakibatkan loop kita perlu menghilangkan sifat rekursif kiri dari aturan produksi. Penghilangan rekursif kiri disini memungkinkan suatu tata bahasa bebas konteks nantinya diubah ke dalam bentuk normal Greibach.
10.3 Tahapan Penghilangan Rekursif Kiri
1. Pisahkan aturan produksi yang rekursif kiri dan yang tidak, -
Misal : aturan produksi rekursif kiri: A
-
Aturan produksi yang tidak rekursif kiri (termasuk produksi ): A
1
|
|
2
3
| ........
2. Dari situ kita bisa tentukan
A 1|A 2|A 3|....... A
n
m
1,
2,
....
n,
dan
1,
2,
....
m
dari setiap aturan
produksi yang memiliki simbol ruas kiri yang sama 3. Lakukan penggantian aturan produksi yang rekursif kiri, menjadi sebagai berikut: -
A
1Z
-
Z
1|
-
Z
1Z
|
2Z 2
|
| 2Z
| ....
3
| ....
|
3Z
mZ n
| ....
nZ
Penggantian diatas dilakukan untuk setiap aturan produksi dengan simbol ruas kiri yang sama. Bisa muncul simbol variabel baru Z1,Z2 dan seterusnya, sesuai banyaknya variabel yang menghasilkan produksi yang rekursif kiri. 4. Hasil akhir berupa aturan produksi pengganti ditambah dengan aturan produksi semula yang tidak rekursif kiri. 5. Tahapan-tahapan tersebut bisa dilihat pada Gambar berikut : Aturan produksi yang tidak rekursif kiri
CFG mengandung aturan produksi yang rekursif kiri
Lakukan penggantian munculkan aturan produksi baru dan simbol variabel baru
Aturan produksi yang rekursif kiri
70
CFG bebas dari aturan produksi yang rekursif kiri
Contoh : 1. Tata bahasa bebas konteks: S -
Sab | aSc |dd | ff | Sbd
Pertama-tama kita lakukan pemisahan aturan produksi Aturan produksi yang rekursif kiri: S
Sab | Sbd
Dari situ kita tentukan untuk simbol ruas kiri S:
1=ab,
2=bd
Aturan produksi yang tidak rekursif kiri: S
aSc | dd | ff
Dari situ kita dapatkan untuk simbol ruas kiri S: -
1=aSc,
2=dd,
3=ff
Kita lakukan penggantian aturan produksi yang rekursif kiri: Untuk yang memiliki simbol ruas kiri S: S
Sab | Sbd, digantikan oleh: S
-
aScZ1 | dd Z1 | ffZ1
Z1
ab | bd
Z1
abZ1 | bd Z1
Hasil akhir setelah penghilangan rekursif kiri adalah: S
aSc | dd | ff
S
aScZ1 | dd Z1 | ffZ1
Z1
ab | bd
Z1
abZ1 | bd Z1
* Pada kasus diatas S adalah satu-satunya simbol variabel yang menghasilkan produksi rekursif kiri. 2. Terdapat tata bahasa bebas konteks:
-
S
Sab | Sb | cA
A
Aa | a | bd
Pertama-tama kita lakukan pemisahan aturan produksi Aturan produksi yang rekursif kiri: S
Sab | Sb
A
Aa
71
Dari situ kita tentukan: Untuk simbol ruas kiri S:
1=
Untuk simbol ruas kiri A:
1
ab,
2
=b
=a
Aturan produksi yang tidak rekursif kiri: S
cA
A
a | bd
Dari situ kita dapatkan Untuk simbol ruas kiri S:
1
Untuk simbol ruas kiri A: -
= cA 1
= a,
2
= bd
Kita lakukan penggantian aturan produksi yang rekursif kiri: Untuk yang memiliki simbol ruas kiri S: S
Sab | Sb, digantikan oleh: S
cAZ1
Z1
ab | b
Z1
abZ1 | bZ1
Untuk yang memiliki simbol ruas kiri A : A
-
Aa, digantikan oleh: A
a Z2 | bdZ2
Z2
a
Z2
a Z2
Hasil akhir setelah penghilangan rekursif kiri adalah: S
cA
Z1
abZ1 | bZ1
A
a | bd
A
a Z2 | bdZ2
S
cAZ1
Z2
a
Z2
aZ2
Z1
ab | b
* Perhatikan bahwa penghilangan rekursif kiri memunculkan simbol variabel baru, dan aturan produksi baru yang rekursif kanan.
72
Bab XI Bentuk Normal Greibach
11.1 Pengertian Bentuk Normal Greibach
Bentuk normal Greibach merupakan bentuk normal yang memiliki banyak konsekuensi teoritis dan prkatis. Dalam bentuk normal Greibach kita membatasi posisi munculnya terminal-terminal dan variabel-variabel. Suatu tata bahasa bebas konteks (CFG) dikatakan dalam bentuk normal Greibach/ Greibach Normal Form (GNF), jika setiap aturan produksinya ada dalam bentuk:
A
a
a: simbol terminal (tunggal), a T : rangkaian simbol-simbol variabel (V*) Atau dengan kata lain, suatu tata bahasa bebas konteks dalam bentuk normal Greibach bila hasil produksinya (ruas kanan) diawali dengan satu simbol terminal, selanjutnya bisa diikuti oleh rangkaian simbol variabel. Contoh tata bahasa bebas konteks dalam bentuk bentuk normal Greibach: S
a | aAB
A
aB
B
cS
Untuk dapat diubah ke dalam bentuk normal Greibach, tata bahasa semula harus memenuhi syarat: •
Sudah dalam bentuk normal Chomsky
•
Tidak bersifat rekursif kiri
•
Tidak menghasilkan
Terdapat dua cara pembentukan bentuk normal Greibach , yaitu melalui substitusi dan perkalian matriks.
11.2 Pembentukan GNF dengan Substitusi
Secara umum langkah-langkah untuk mendapatkan bentuk normal Greibach: 1. Tentukan urutan simbol-simbol variabel yang ada dalam tata bahasa. Misalkan terdapat m variabel dengan urutan A1,A2,..,Am
73
2. Berdasarkan urutan simbol yang ditetapkan pada langkah (1) seluruh aturan produksi yang ruas kanannya diawali dengan simbol variabel dapat dituliskan dalam bentuk Ah
Ai
dimana h <> i (rekrusif kiri sudah dihilangkan), bisa berupa simbol variabel a. Jika h < i, aturan produksi ini sudah benar ( tidak perlu diubah) b. Jika h > i, aturan produksi belum benar. Lakukan substitusi berulangulang terhadap Ai (ganti Ai pada produksi ini dengan ruas kanan produksi dari variabel Ai ) sehingga suatu saat diperoleh produksi dalam bentuk Ah Ap (dimana h ≤ p ) - Jika h = p , lakukan penghilangan rekursif kiri - Jika h < p, aturan produksi sudah benar 3. Jika terjadi penghilangan rekursif kiri pada tahap (2b), sejumlah simbol variabel baru yang muncul dari operasi ini dapat disisipkan pada urutan variabel semula dimana saja asalkan ditempatkan tidak sebelum Ah (di kiri) 4. Setelah langkah (2) & (3) dikerjakan maka aturan-aturan produksi yang ruas kanannya dimulai simbol variabel sudah berada dalam urutan yang benar Ax
Ay γ ( di mana x < y )
Produksi-produksi yang lain ada dalam bentuk: Ax
a γ ( a = simbol terminal )
Bx
γ
(B2 = simbol variabel baru yang akan muncul sebagai akibat dari operasi penghilangan rekursif kiri) 5. Bentuk normal Greibach diperoleh dengan cara melakukan substitusi mundur mulai dari variabel Am, lalu Am-1, Am-2, ..... Dengan cara ini aturan produksi dalam bentuk Ax
Ay γ dapat diubah sehinga ruas kanannya dimulai dengan simbol
terminal. 6. Produksi dalam bentuk Bx
γ juga dapat diubah dengan cara substitusi seperti
pada langkah (5)
Contoh
74
(tata bahasa bebas konteks sudah dalam bentuk normal Chomsky dan memenuhi syarat untuk diubah ke bentuk normal Greibach), simbol awal adalah S: S
CA
A
a|d
B
b
C
DD
D
AB
Kita tentukan urutan simbol variabel, misalnya S, A, B, C, D (S
S
CA ( sudah memenuhi aturan karena S
•
C
DD (sudah memenuhi karena C
•
D
AB (tidak memenuhi, karena D>A)
Yang belum memenuhi urutan yang telah kita tentukan adalah: D
AB, karena ruas kiri > simbol pertama pada ruas kanan. Maka kita lakukan
substitusi pada simbol variabel A, aturan produksi menjadi: D
aB | dB
Setelah semua aturan produksi sudah memenuhi ketentuan urutan variabel, kita lakukan substitusi mundur pada aturan produksi yang belum dalam bentuk normal Greibach (‘=>’ dibaca ‘menjadi’): •
C
DD => C
aBD | dBD
•
S
CA => S
aBDA | dBDA
*Perhatikan substitusi mundur dimulai dari aturan produksi yang memiliki ruas kiri dengan urutan variabel paling akhir (kasus di atas:S
75
S
aBDA | dBDA
A
a|d
B
b
C
aBD | dBD
D
aB | dB
*Perhatikan : setiap substitusi kita lakukan pada simbol variabel pertama pada ruas kanan ( pada aturan produksi yang belum bentuk normal Greibach tentunya ).
Prinsipnya:
•
Biarkan aturan produksi yang sudah dalam bentuk normal Greibach
•
Tentukan pengurutan simbol variabel, berdasarkan kondisi aturan produksi yang ada buatlah urutan sedemikian sehingga memudahkan untuk proses selanjutnya. Mulailah terlebih dahulu dari seimbol awal.
•
Lakukan perubahan pada aturan produksi yang belum memenuhi ketentuan urutan tersebut dan bila perlu selama proses itu bisa dilakukan substitusi dan penghilangan rekursif kiri
•
Lakukan substitusi mundur sedemikian rupa sehingga semua aturan produksi akan diawali dengan tepat sebuah simbol terminal. Proses substitusi mundur dimulai dari aturan produksi dengan urutan paling akhir.
•
Lakukan substitusi mundur juga pada aturan produksi baru yang muncul sebagai hasil penghilangan rekursif kiri.
76
Bab XII PUSHDOWN AUTOMATA (PDA)
12.1 Pendahuluan
FA tidak mampu mengenali bahasa yang memiliki karakteristik xnyn. Hal ini dikarenakan FA tidak memiliki kemampuan untuk “mengingat” jumlah kemunculan x untuk digunakan pada saat memeriksa jumlah kemunculan y. Kita akan tambahkan kemampuan “mengingat” berbentuk stack pada mesin modifikasi FA sehingga dapat memecahkan permasalahan ini. Mesin ini dikenal dengan Pushdown Automata (PDA). PDA memiliki beberapa bagian yakni: a. Input stream b. Finite state c. Mekanisme kontrol yang memungkinkan berpindah dari state 1 ke state lain. d. Tepat 1 initial state e. Minimal 1 final state/ accepted state f. Stack yang berguna mengingat. g. Machine symbol. Machine symbol merupakan finite symbol yang dapat disimpan didalam stack. •
Mungkin semua alphabet,
•
Mungkin beberapa alphabet,
•
Dan mungkin beberapa symbol yang tidak dikenal oleh alphabet (contoh#).
12.2 Transisi
Dengan adanya pengingat, maka mesin harus dapat melakukan beberapa hal pada saat melakukan transisi: •
Membaca simbol input,
•
Mem-pop simbol,
•
Mem-push simbol,
77
•
Bertransisi ke state lain.
12.3 Definisi Formal PDA
PDA adalah pasangan 7 tuple M = (Q, Σ, Γ, q, Z, δ, F), dimana : Q : himpunan hingga state, Σ : alfabet input, Γ : alfabet stack, q∈ Q : state awal, Z∈ Γ : simbol awal stack, F ⊆ Q : himpunan state penerima, fungsi transisi δ : Q × (Σ ∪ {ε}) × Γ → 2 Q × Γ* (himpunan bagian dari Q × Γ*) Untuk state q ∈ Q, simbol input a ∈ Σ, dan simbol stack X∈ Γ, δ(q, a, X) = (p, α) berarti PDA bertransisi ke state p dan mengganti X pada stack dengan string α. Konfigurasi PDA pada suatu saat dinyatakan sebagai triple (q, x, α), dimana : -
q ∈ Q : state pada saat tersebut, x ∈ Σ* : bagian string input yang belum dibaca, dan
-
α ∈ Γ* : string yang menyatakan isi stack dengan karakter terkiri menyatakan top of stack.
Misalkan (p, ay, Xβ) adalah sebuah konfigurasi, dimana : a ∈ Σ, y ∈ Σ*, X ∈ Γ, dan β ∈ Γ*. Misalkan pula δ(p, a, X) = (q, γ) untuk q ∈ Q dan γ ∈ Γ*. Dapat kita tuliskan bahwa : (p, ay, Xβ)
(q, y, βγ).
Contoh (PDA Deterministik): PDA : M = (Q, Σ, Γ, q0, Z0, δ, F) pengenal palindrome L = {xcxx ∈ (ab)*}, dimana mempunyai tuple : Q = {q0,q1,q2}, F = {q2},
78
x
adalah
cermin(x),
Σ = {a, b, c}, Γ = {A, B, Z0}, dan fungsi transisi δ terdefinisi melalui tabel :
Sebagai contoh, perhatikan bahwa fungsi transisi No. 1 dapat dinyatakan sebagai : δ(q, a, Z) = (q, aZ). Pada tabel transisi tersebut terlihat bahwa pada state q PDA akan melakukan PUSH jika mendapat input a atau b dan melakukan transisi state ke state q jika mendapat input c. Pada state q PDA akan melakukan POP. Berikut ini pengenalan dua string oleh PDA di atas : - abcba : (q0, abcba, Z0)
- acb : (q, acb, Z)
- ab : (q, ab, Z)
(q0, bcba, AZ0)
(1)
(q0, cba, BAZ0)
(4)
(q1, ba, BAZ0)
(9)
(q1, a, AZ0)
(11)
(q1, ε, Z0)
(10)
(q2, ε, Z0)
(12)
(q, cb, AZ)
(1)
(q, b, AZ)
(8),
(q, b, AZ)
(1)
(q, ε, BAZ)
(4)
(diterima)
(crash → ditolak)
(crash → ditolak)
Penerimaan dan penolakan 3 string di atas dapat dijelaskan sebagai berikut :
79
•
string abcba diterima karena tracing sampai di state penerima (q2) dan string “abcba” selesai dibaca (string yang belum dibaca = ε)
•
string acb ditolak karena konfigurasi akhir (q1, b, a Z0) sedangkan fungsi transisi δ(q1, b, a) tidak terdefinsi
•
string ab ditolak karena konfigurasi akhir (q0, ε, baZ0) sedangkan fungsi transisi δ(q0, ε, b) tidak terdefinsi
Ilustrasi graf fungsi transisi PDA di atas ditunjukkan melalui gambar berikut :
Notasi (p, ay, Xβ)
(q, y, βγ) dapat diperluas menjadi : (p, x, α)
yang berarti konfigurasi (q, y, β) di
(q, y, β)*,
capai melalui sejumlah (0 atau lebih)
transisi. Ada dua cara penerimaan sebuah kalimat oleh PDA, yang masing-masing terlihat dari konfigurasi akhir, sebagaimana penjelasan berikut : Jika M = (Q, Σ, Γ, q0, Z0, δ, F) adalah PDA dan x ∈ Σ*, maka x diterima dengan state akhir (accepted by final state) oleh PDA M jika: (q0, x, Z0)
* (q, ε, α) untuk
α ∈ Γ * dan q ∈ A. x diterima dengan stack hampa (accepted by empty stack) oleh PDA M jika : (q0, x, Z0)
* (q, ε, ε) untuk q ∈ Q.
Contoh (PDA Non-Deterministik):
80
PDA M = (Q, Σ, Γ, q0, Z0, δ, F) pengenal palindrome L = {xxx ∈ (ab)*} mempunyai komponen tuple berikut : Q = {q0,q1,q2}, F = {q2}, Σ = {a, b}, Γ = {a, b, Z0}, dan fungsi transisi δ terdefinisi melalui tabel :
Pada tabel transisi tersebut terlihat bahwa pada state q0 PDA akan melakukan PUSH jika mendapat input a atau b dan melakukan transisi state ke state q1 jika mendapat input ε. Pada state q1 PDA akan melakukan POP. Kedua Contoh di atas menunjukkan bahwa PDA dapat dinyatakan sebagai mesin PUSH-POP. Berikut ini pengenalan string “baab” oleh PDA di atas : - (q0, baab, Z0)
- (q0, baab, Z0)
(q0, aab, bZ0)
(2 kiri)
(q0, ab, abZ0)
(5 kiri)
(q1, ab, abZ0)
(3 kanan)
(q1, b, bZ0)
(11)
(q1, ε, Z0)
(10)
(q2, ε, Z0)
(12)
(q1, baab, Z0)
(2 kanan) (crash → ditolak)
81
(diterima)
- (q0, baab, Z0)
- (q0, baab, Z0)
(q0, aab, bZ0)
(2 kiri)
(q0, ab, abZ0)
(5 kiri)
(q0, b, aabZ0)
(3 kiri)
(q1, b, aabZ0)
(4 kanan) (crash → ditolak)
(q0, aab, bZ0)
(2 kiri)
(q0, ab, abZ0)
(5 kiri)
(q0, b, aabZ0)
(3 kiri)
(q0, ε, baabZ0)
(4 kiri)
(q1, ε, baabZ0)
(9) (crash → ditolak)
q0,aba,z = q0,ba,az = q1, a, az = q1, ε, z =q2, ε,ε
82
Bab XIII Mesin Turing
13.1 Sejarah
Mesin Turing adalah model komputasi teoritis yang ditemukan oleh Alan Turing (1936), berfungsi sebagai model ideal untuk melakukan perhitungan matematis. Walaupun model ideal ini diperkenalkan sebelum komputer nyata dibangun, model ini tetap diterima kalangan ilmu komputer sebagai model komputer yang sesuai untuk menentukan apakah suatu fungsi dapat selesaikan oleh komputer atau tidak (menentukan computable function). Mesin Turing terkenal dengan ungkapan " Apapun yang bisa dilakukan oleh Mesin Turing pasti bisa dilakukan oleh komputer.
13.2 Mekanisme TM
-
Sebuah mesin turing terdiri atas barisan sel tersusun berupa pita yang dapat bergerak maju mundur, komponen aktif baca/ tulis pita yang memiliki status perhitungan serta dapat mengubah/ menulisi sel aktif yang ada di pita tadi, dan suatu kumpulan instruksi bagaimana komponen baca/ tulis ini harus melakukan modifikasi terhadap sel aktif pada pita, serta bagaimana menggerakkan pita tersebut.
-
Pada setiap langkah dalam komputasi, mesin ini akan dapat mengubah isi dari sel yang aktif, mengubah status dari komponen baca/ tulis, dan mengubah posisi pita kekiri atau kekanan.
13.3 Definisi Formal
Sebuah Mesin Turing dinyatakan dalam 7 tupel M = (Q, Σ, S, δ, F, Γ, ), dimana : Q : himpunan hingga state, Σ : alfabet input, Γ : alfabet Pita , Σ ⊆ Γ S∈ Q : state awal, ∈ Γ : simbol pita kosong (blank)
83
F ⊆ Q : himpunan state akhir/penerima, fungsi transisi
δ : Q × Γ → (Q × Γ × (R,L)) δ(q0,0) = (q1,1,R)
13.4 Ilustrasi TM sebagai sebuah ‘mesin’
13.5 Ilustrasi TM sebagai sebuah graf berarah
1. Sebagaimana graf, TM terdiri dari beberapa node dan beberapa edge. Dari satu node mungkin terdapat satu atau lebih edge yang menuju node lainnya atau dirinya sendiri. 2. Sebuah node menyatakan sebuah stata (state). Dua stata penting adalah stata awal S (start) dan stata penerima H (halt). Sesaat sebelum proses pengenalan sebuah kalimat, TM berada pada stata S. Jika kalimat tersebut dikenali maka, setelah selesai membaca kalimat tersebut, TM akan akan berhenti pada stata H. 3. Sebiya edge mempunyai ‘bobot’ yang dinotasikan sebagai triple : (a, b, d). a adalah karakter acuan bagi karakter dalam sel pita TM yang sedang dibaca head. Jika yang dibaca head adalah karakter a maka a akan di-overwrite dengan karakter b dan head akan berpindah satu sel ke arah d (kanan atau kiri). 4. Kondisi crash akan terjadi jika ditemui keadaan sebagai berikut :
84
Contoh Rancanglah sebuah mesin turing pengenal bahasa L = {anbn| n ≥ 0). Jawab : L tersebut terdiri dari 2 kelompok kalimat yaitu ε dan non-ε. Kelompok non-ε adalah : ab, aabb, aaabbb, dan seterusnya. Untuk dapat menerima kalimat ε TM harus mempunyai edge dari S ke H dengan bobot (ε ,ε , R). TM menerima kalimatkalimat : ab, aabb, aaabbb, dan seterusnya, dengan algoritma sebagai berikut : 1. Mulai dari S, head membaca simbol a. 2. Head membaca simbol a. Tandai simbol a yang sudah dibaca tersebut, head bergerak ke kanan mencari simbol b pasangannya. 3. Head membaca simbol b. Tandai simbol b yang sudah dibaca tersebut, head bergerak ke kiri mencari simbol a baru yang belum dibaca/ditandai. 4. Ulangi langkah 2 dan 3. 5. Head sampai ke H hanya jika semua simbol a dan simbol b dalam kalimat anbn selesai dibaca. Algoritma di atas lebih diperinci lagi sebagai berikut : 1. Mulai dari S, head membaca simbol a. 2. Overwrite a tersebut dengan suatu simbol (misalkan A) untuk menandakan bahwa a tersebut sudah dibaca. Selanjutnya head harus bergerak ke kanan untuk mencari sebuah b sebagai pasangan a yang sudah dibaca tersebut. i.
Jika yang ditemukan adalah simbol a maka a tersebut harus dilewati (tidak boleh dioverwrite), dengan kata lain a dioverwrite dengan a juga dan head bergerak ke kanan.
ii.
Jika TM pernah membaca simbol b ada kemungkinan ditemukan simbol B. Simbol B tersebut harus dilewati (tidak boleh dioverwrite), artinya B diover-write dengan B juga dan head bergerak ke kanan.
3. Head membaca simbol b, maka b tersebut harus dioverwrite dengan simbol lain (misalnya B) untuk menandakan bahwa b tersebut (sebagai pasangan dari a) telah dibaca, dan head bergerak ke kiri untuk mencari simbol A.
85
i.
Jika ditemukan B maka B tersebut harus dilewati (tidak boleh dioverwrite), dengan kata lain B dioverwrite dengan B juga dan head bergerak ke kiri.
ii.
Jika ditemukan a maka a tersebut harus dilewati (tidak boleh dioverwrite), dengan kata lain a dioverwrite dengan a juga dan head bergerak ke kiri.
4. Head membaca simbol A, maka A tersebut harus dilewati (tidak boleh dioverwrite), dengan kata lain A dioverwrite dengan A juga dan head bergerak ke kanan. 5. Head membaca simbol a, ulangi langkah 2 dan 3. 6. (Setelah langkah 3) head membaca simbol A, maka A tersebut harus dilewati (tidak boleh dioverwrite), dengan kata lain A dioverwrite dengan A juga dan head bergerak ke kanan. 7. Head membaca simbol B, maka B tersebut harus dilewati (tidak boleh dioverwrite), dengan kata lain B dioverwrite dengan A juga dan head bergerak ke kanan. 8. Head membaca simbol ε, maka ε dioverwrite dengan ε dan head bergerak ke kanan menuju stata H. Skema graf Mesin Turing di atas adalah :
86
Bab XIV Aplikasi FSA dan CFG pada Pengembangan Kompilator
14.1 Scanner
Tata bahasa bebas konteks dapat diaplikasikan pada penganalisis sintaksis dari suatu source code. Dimana simbol terminal maupun simbol variabelnya sudah bukan satu karakter, tetapi berupa besaran leksik sebagai simbol terminalnya dan besaran sintaks sebagai simbol variabelnya. Penganalisis leksikal biasa disebut dengan scanner. Scanner bekerja berdasarkan mesin FSA yang ada pada Bahasa Reguler. Untuk membantu mengkonstruksi scanner dapat digunakan Diagram Keadaan. Tugas Scanner •
Merunut karakter demi karakter.
•
Mengenali besaran leksik.
•
Mentransformasi menjadi sebuah token.
•
Mengirimkan token.
•
Membuang/mengabaikan blank dan komentar dalam program.
•
Menangani kesalahan.
•
Menangani tabel simbol.
14.2 Parser
Penganalisis sintaktik disebut parser. Proses parsing merupakan tahapan analisis sintaksis yang berguna untuk memeriksa urutan kemunculan token. Recursif descent parser adalah salah satu cara untuk mengaplikasikan tata bahasa bebas konteks untuk melakukan analisis sintaksis suatu source code. Ciri – ciri Recursif descent parser a. Ciri dari Recursif descent parser adalah secara rekursif menurunkan semua variabel dari awal sampai bertemu terminal dan tidak pernah mengambil
87
token secara mundur (no backtrack). Hal ini berbeda dengan mesin Turing yang dapat maju dan mundur dalam melakukan parsing. b. Ciri lain adalah sangat bergantung pada algoritma Scan dalam mengambil token.
14.3 Tool bantuan untuk konstruksi Scanner dan Parser
a. Diagram Keadaan (State Transition Diagram) b. Notasi BNF (Backus Naur Form) c. Diagram Sintaks A. Diagram Keadaan Digunakan untuk mendapatkan token melalui analisis leksikal terhadap program sumber. Misalkan suatu bahasa memiliki himpunan simbol terminal (token) berikut: •
t_PLUS
•
t_MIN
•
t_ID
•
t_INT
Token t_ID (identifier) bisa berupa nama atau keyword (kata kunci yang sudah didefinisikan oleh suatu bahasa). Misalkan terdapat statement: VAR jumlah : integer Maka VAR dan integer adalah keyword. jumlah adalah sebuah nama yang dideklarasikan sendiri oleh pemrogram. Token t_ID harus diawali dengan karakter huruf (A – Z, a – z), dan bisa diikuti didit (0 – 9) atau huruf. Token t_INT harus diawali dengan digit dan bisa diikuti dengan digit pula. Blank merupakan bagian program sumber yang diabaikan (dilewati) saja, misalnya spasi kosong.
88
Gambar Diagram Keadaan
B. Notasi BNF (Backus Naur Form) Aturan-aturan produksi dapat dinyatakan dalam bentuk BNF. BNF telah banyak digunakan untuk melakukan definisi formal bahasa pemrograman. Beberapa simbol yang dipakai dalam notasi BNF sebagai berikut: ::=
Identik dengan simbol
pada aturan produksi
Idem dengan simbol serupa pada aturan produksi
| <>
Mengapit simbol variabel/ non terminal
{}
Pengulangan 0 sampai n kali
Contoh -
Aturan Produksi E
-
T | T + E | T – E, T
Notasi BNF E ::= | + <E> | - <E>, T ::=
89
C. Diagram Sintaks Diagram Sintaks merupakan alat bantu dalam pembentukan parser/ analisis sintaksis. Notasi yang tedapat pada diagram sintaks: •
Empat persegi panjang melambangkan simbol variabel/ non terminal,
•
Bulatan melambangkan simbol terminal.
Contoh -
Misalkan terdapat aturan produksi: T
-
F*T | F / T | F
Diagram sintaksnya sbb:
Biasanya diagram sintaks digunakan untuk memperoleh deskripsi dari suatu notasi BNF. Misalkan notasi BNF untuk block: ::= t_BEGIN <statement> { t_SEMICOL <statement> } t_END Diagram sintaksnya sbb:
14.4 Implementasi Scanner dan Parser
Contoh source code berikut ini:
90
Pada contoh diatas, besaran leksik (token)nya adalah simbol yang bernilai program’, ‘coba’, ‘var’, ‘A’, ‘integer’, ‘:’, ‘+’, ‘2’, ‘.’, ‘;’, ‘:=‘,‘begin’, ‘end’. Sedangkan besaran sintaksnya tidak kelihatan karena diterapkan dalam aturan produksinya. Rincian dari tata bahasa yang dipergunakan untuk penganalisis sintaksis adalah sebagai berikut: •
V = { <program>, , <statement>, <exp>, <simple_exp>, , <sign>, <arit_op> }
•
T = { t_PROG, t_BEGIN, t_END, t_IF, t_THEN, t_ELSE, t_PLUS, t_MIN, t_MUL, t_DIV, t_INT, t_EQ, t_LT, t_GT, t_ASS, t_COL, t_SEMICOL, t_DOT, t_ID }
•
S = <program>
•
P = (ditulis dalam notasi BNF) <program> ::= t_PROG t_ID t_SEMICOL t_DOT ::= t_BEGIN <statement> { t_SEMICOL <statement> } t_END <statement> ::= t_ID t_ASS <simple_exp> | t_IF <exp> t_THEN <statement> | t_IF <exp> t_THEN <statement> t_ELSE <statement> <exp> ::= <simple_exp> t_EQ <simple_exp> | <simple_exp> t_LT <simple_exp> | <simple_exp> t_GT <simple_exp> simple_exp> ::= { <arit_op> } | <sign> { <arit_op> } <sign> ::= t_PLUS | t_MIN <arit_op> ::= t_PLUS | t_MIN | t_MUL | t_DIV ::= t_INT | t_ID
Himpunan simbol terminal/ token yang diperoleh: ‘<‘, ‘>’, ‘=‘, ‘<=‘, ‘>=‘, ‘<>’ Atau bisa dibaca sebagai token-token: t_L, t_G, t_E, t_LE, t_GE, t_NE (G = greater, L = less, E = Equal, N = Not)
91
Untuk token lainnya bisa ditambahkan sendiri. Bahasa tersebut juga mendukung penulisan komentar yang di awali dengan ‘{“ dan diakhiri ‘}’. Diagram Keadaan untuk memperoleh token:
Scanner biasanya di implementasikan sebagai sebuah prosedur yang di panggil oleh Parser. Kita bisa membuat prosedur scan sederhana yang akan membaca input dan memberikan token hasilnya. Misalnya didefinisikan dulu Procedure GetChar yang berguna mengambil sebuah karakter dari file input.
!" # $
Dimana, FileInput : text, Kar: character Ingat bahwa pada scanner kita akan maju satu per satu karakter untuk mendapatkan token. Selanjutnya kita buat Procedure Scan. Pada program yang akan kita buat di batasi delimiternya hanyalah spasi. Diasumsikan karakter pertama sudah dibaca sebelum Procedure Scan dipanggil. Procedure Scan yang dibuat belum memperhitungkan kemungkinan token yang tidak dikenali (error). %
92
&
"
'' ()
*
)
) "
.
)
+
),
) "
. '/'
' '
*
01$
2
'34
*
05$
2
) *
' '
01
*
2
0$
2
'34 ."
' ' *
0 $
*
0
+ )
*
2
) 2
'(' ( "
7
2 ( *
. ) () *
) *
* *
+ *
+
*
. , )
*
,
$
93
,
',4 (
$6
*
*
. !
*
,
Aturan Produksi dalam notasi BNF diatas, dapat dibuat diagram sintaksnya untuk lebih mempermudah. a. Diagram Sintaks Program
b. Diagram Sintaks Block
c. Diagram Sintaks Statement
d. Diagram Sintaks Exp
94
Pada diagram sintaks di atas, langsung digambarkan karakter token-nya, misal : -
‘;’ untuk t_SEMICOL,
-
‘.’ untuk t_DOT,
-
‘<‘ untuk t_LT,
-
‘:=‘ untuk t_ASS,
-
dan seterusnya.
Implementasi Untuk mengimplementasikan aturan-aturan produksi memakai teknik RecursifDescent dengan aturan sebagai berikut: •
Semua simbol variabel dijadikan prosedur/ fungsi.
•
Jika ketemu simbol terminal pada aturan produksi, maka panggil prosedur Scan.
•
Jika ketemu simbol variabel pada aturan produksi, maka panggil prosedurnya.
Selanjutnya akan membuat prosedur Program, Block, Statement, dan Exp, berdasarkan notasi BNF di atas.
Prosedur Program
95
.
*
0 -6 % .
*
08
% .
*
0%$9 61 % * ( .
)
*
*,
086: %
$
Prosedur Block * .
*
0 $ 5 % %
(
&
*
) 0%$9 61
% % .
*
0$58
%
$
Prosedur Statement % .
*
08
96
%
,
% .
*
0 %% % %
0 2
) .
*
0 % $2 .
*
0:;$5 % % .
*
0$1%$
% %
$
Prosedur Exp $2 % .
0 2 *
0$<# 6-
*
01:# 6-
% %
0 2
$
97
*
0 :#
Diasumsikan sebelum pemanggilan procedure diatas, sudah ada token atau prosedur Scan yang sudah dipanggil. Yang penting diketahui adalah bahwa tiap prosedur yang mewakili simbol variabel diatas, selesai dipanggil meninggalkan sebuah token jika tidak terjadi kesalahan. Dalam program diatas belum meng-handle penanganan kesalahan. Beberapa hal yang perlu diperhatikan: •
Dalam penanganan error, cukup dilakukan proses halt dengan pemberian pesan kesalahan sebelumnya.
•
•
Beberapa kesalahan yang mungkin, antara lain: -
Jika kesalahan akibat token tak dikenal,
-
Jika kesalahan akibat token tidak pada tempat yang seharusnya.
Untuk contoh parser sederhana, dapat dilihat pada buku “Teori Bahasa dan Otomata” karangan Firrar Utdirartatmo
98
Daftar Pustaka
•
Hopcroft, J.E. and Ullman, J.D., Introduction Automata Theory, Language and Computation, Addison-Wesley, 1979.
•
Kohavi , Switching and Finite Automata Theory, McGraw-Hill, 1972
•
Williams, E., Theory of Computation, WMU, 1987.
•
Dean Kelley.,Otomata dan Bahasa–bahasa Formal, Prehallindo Jakarta, 1999.
•
Firrar Utdirartatmo,Teori Bahasa & Otomata, J & J Learning Yogyakarta, 2001.
•
Firrar Utdirartatmo., Teknik Kompilasi, J & J Learning Yogyakarta, 2001.
•
John C Martin, Introduction to Languages and the theory of Computation.
•
D Suryadi HS, Pengantar Automata Bahasa Formal dan Kompilasi.
•
Bambang Heriyanto, Otomata dan Komputasi serta Penerapannya.
•
Dari berbagai sumber di Internet.
99
