Rangkuman TBO

AHMAD RIZKI RAMADHAN

11351100538 (4H)
 Rangkuman TBO

(Teori Bahasa Dan Otomata)

A. Kelompok 1
Pembahasan : FSA ( finite state automata ).
a. Pengertian dari FSA

Finite State Automata (FSA) merupakan suatu mesin abstrak yang

digunakan untuk merepresentasikan penyelesaian suatu persoalan dari suatu
sistem diskrit.Sebagai sebuah mesin,maka FSA akan bekerja jika diberikan
suatu masukan.Hasil proses adalah suatu nilai kebenaran diterima atau
tidaknya masukan yang diberikan.Finite State Automata memiliki state yang
banyaknya berhingga, jika diberikan suatu simbol input, maka dapat terjadi
suatu perpindahan dari sebuah state ke state lainnya.Perubahan state tersebut
dinyatakan oleh suatu simbol transisi.

Komponen dasar yang dimiliki oleh Finite Automata adalah

Alphabet yaitu Himpunan symbol/ lambang yang dikenali. Himpunan
Alfabet diwakili dengan symbol ∑ jika dan hanya jika ∑ merupakan
himpunan symbol yang bersifat tetap dan bukan merupakan himpunan
kosong.

• ∑ = {a, b}, maka contoh words yang dapat dibentuknya yaitu “aab”,
“abab”, “a”, “bbbbbb”, dan lain- lain.

• ∑ = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}, maka contoh words yang dapat

dibentuknya yaitu “26498098”, “100103”, “0000”, dan lain- lain.

• Lebih lanjut, Concatenation adalah proses menggabungkan dua buah

words menjadi satu word baru, yaitu terdiri dari rangkaian alphabet
dari word pertama dan disambung dengan rangkaian alphabet dari
word ke-dua.

•  ∑ = {a, b}, words = “aaa” dan y = “bbb” dimana setiap a

merupakan anggota himpunan ∑, a ∈ ∑ dan setiap b anggota
himpunan ∑, b ∈ ∑. Maka, gabungan atau concatenation x dan y,
dinyatakan dengan x, y = “aaabbb”.
b. Macam-macam FSA (finete state automata)

Dalam pembahasan sebuah FSA memiliki 2 jenis aturan yang di miliki,

seperti yang kita ketahui bahwa FSA tidak memiliki aturan yang harus di ikuti.
Maka FSA bisa mencakup dua bagian yang FSA miliki. FSA memiliki dua
pembagian sebagai berikut :

1. DFA ( determinite state automata ).

Pada Otomata Berhingga Deterministik/Deterministic Finite

Automata, selanjutnya kita sebut sebagai DFA, dari suatu state terdapat
tepat satu state berikutnya untuk setiap simbol masukan yang diterima.

Sebagai contoh, kita memiliki sebuah otomata seperti pada gambar

dibawah ini :

Konfigurasi Deterministic Finite Automata (DFA) di atas secara

formal dinyatakan sebagai berikut :
Q = {qo, q1. q2}
Σ = {a,b}
S = qo
F = {q2}

Fungsi transisi yang ada sebagai berikut.

d(q0,a) = qo
d(q0,b) = qi
d(q1,a) = q1
d(q1,b)= q2
d(q2,a) = ql
 d(q2,b) = q2

Biasanya fungsi-fungsi transisi ini kita sajikan dalam sebuah tabel

transisi. Tabel transisi tersebut menunjukkan state-state berikutnya untuk
kombinasi state-
state dan input. Tabel transisi dari fungsi transisi di atas sebagai berikut :

δ a b
qo qo q1
q1 q1 q2
q2 q1 q2

Perhatkan pada tabel diatas, dapat kita simpulkan bahwa DFA sesuai
dengan pengertian yang di berikan, “dari suatu state terdapat tepat satu
state berikutnya untuk setiap simbol masukan yang diterima”.
Bisa kita ibaratkan DFA adalah sebuah aturan yang harus kita
penuhi, seperti sebuah aturan yang harus ditaati, sama halnya dengan
computer yang mengikuti semua perintah yang di berikan kepadanya, jika
tidak mengikuti aturan maka komputer tidak jalan seperti yang kita lihat
saat ini.

2. N-DFA ( non-determinite state automata ).

Pada Non-deterministic Finite Automata (NFA) dari suatu state bisa

terdapat 0, 1, atau lebih busur keluar (transisi) berlabel simbol input yang
sama. Non-deterministic Finite Automata memiliki lima (5) tupel M ={Q, Σ,
δ, S, F), dengan arti yang serupa pada DFA. Di sini perbedaan ada pada fung-
si transisinya, di mana untuk setiap pasangan state- input, kita bisa memiliki
O (nol) atau lebih pilihan untuk state berikutnya. Bisa kita lihat contoh pada
gambar dibawah ini .

Contoh lainnya ditunjukkan pada gambar dibawah ini:

 Mesin otomata NFA

Terlihat tidak ada busur keluar dari state q1 untuk simbol

input 'b', atau secara formal dinyatakan:
δ(q1,b) = Ø

Kita bisa melihat tabel transisinya dibawah ini.

δ a b
qo {q1} {qo}
q1 {qo} 0

Seperti halnya pada Deterministic Finite Automata, pada

Nondeterministic Finite Automata kita bisa membuat diagram transisi dari
tabel transisinya dan sebaliknya.
Jika kita simpulkan bahwa sebuah N-DFA ini adalah kehidupan
yata yang kita rasakan saat ini, semua aturan yang kita miliki terkadang
tidak terlaksana dengan semestinya.
B. Kelompok 2
Pembahasan : Ekuivalensi Non-deterministic finite state automata ke
determinitic finite state automata (N-DFA  DFA).

Dalam pembahasan sebelumnya kita telah membahas apa itu DFA dan N-DFA
yang mana kedua bagian tersebut termasuk dalam FSA (finite state automata).
Dalam pembahasan kedua ini, membahasa bagaimana peubahan dari N-DFA ke
DFA. Jika kita ibaratkan seperti, sebuah model yang tidak mengikuti aturan, mebuat
ke model yang mengikuti sebuah aturan.
Atau seperti model perancangan yang kita buat untuk sebuah komputer,
otomatis yang kita buat adalah NFA, setelah itu untuk memasukkan kedalam sebuah
aturan sebuah perangkat harus di buat dalam sebuah model DFA.
Untuk merubah itu semua, kita harus mengikuti tahapan dibawah ini :
a. Tahapan pengubahan NFA ke DFA
Sebuah mesin NFA dapat dibuat atau dimuatkan kedalam DFA yang ekuivalen
(bersesuaian). Ang di maksud denagan ekuivalen disini adalah bisa menerima
bahasa yang sama.
1. Buatlah kumpulan state sebagai subset dari state awal - ∅ .

NFA
2. Telusuri state dari state yang terbentuk.
3. Tentukan state awal.
4. Tentukan state akhir.
5. Reduksi state yang tidak digunakan.
 Kumpulan state sebagai subset awal: {}, q0, q1, q2, {q0, q1}, {q0, q2}, {q1, q2},
{q0, q1, q2}
  Tabel transisi

State p r
Ø Ø Ø
Q0 {q1,q2} Ø
Q1 Ø {q2}
Q2 {q1} {q1}
{q0,q1} {q1,q2} {q2}
{q0,q2} {q1,q2} {q1}
{q1,q2} {q1} {q1,q2
}
{q0,q1,q2 {q1,q2} {q1,q2
} }
 State awal: q0
 State akhir: q1, {q1, q2} (yang ada terdapat q1). Untuk membuat state pada DFA
dapat di tentukan dari mereduksi tabel transisi diatas.

Dari tabel transisi diatas dapat kita bentuk sebuah state DFA yang ekuivalen dengan NFA
di atas.

DFA
Dari gambar mesin DFA diatas dibentuk dari NFA.
C. Kelompok 3
Pembahasan : NFA dengan ε −move

Dalam pemabahan kali ini akan membahas, bagaimana cara menghilangkan

ε −move yang terletak pada sebuah NFA.

a. NFA dengan ε −move

Disini kita mempunya outomata yang baru yang disebut NFA dengan
ε −move ( ε disini bisa dianggap sebagai ‘empaty’ atau kosong). Pada
NFA dengan ε −move , diperbolehkan untuk mengubah state tanpa membaca
input, atau bisa disebut juga dengan himpunan kosong atau hanya sebagai
jembatan atara state satu dengan lainnya.
b. ε −closure untuk suatu NFA dengan ε −move
Sekarang kita akan menambahkan sebuah pengertian yaitu
ε −closure . ε −closure adalah himpunan state-state yang dapat didapat
dari suat state tanpa membaca inputan. Kita dapat melihat ε −closure yang
dapat dicapai pada state pada gambar dibawah ini :

Pada gambar diatas dapat kita ketahui bahwa ε −closure untuk

setiap state adalah sebagai berikut :
ε-closure(qo) = {qo, q1, q3)
ε-closure(q1) = {q1, q3}
ε-closure(q2) = {q2,q4}
ε-closure(q3) = {q3}
 ε-closure(q4) = {q4}
Catatan:
Perhatikan bahwa pada suatu state yang tidak memiliki transisi e, maka
e- closure-nya adalah state itu sendiri.
c. Ekuivalensi NFA dengan ε −move ke NFA tampa menggunakan
ε −move
Pada kali ini kita akan membahas bagi mana cara menghilangkan
ε −move seperti yang telah kita ketahui diatas, seperti bagaimana
menentukan ε −move dan ε −closure pada setiap state-state yang ada
pada mesin NFA.
Dari sebuah NFA dengan ε −move kita dapat memperoleh NFA
tampa ε −move yang ekuivalen. Seperti pada gamabar dibawah ini NFA
dengan ε −move :

Dari model state diatas dapat kita peroleh sebuah mesin NFA tampa ε −move ,
tentu saja untuk membuat ke NFA tampa ε −move tadak sederhana, perlu
melakukan beberapa tahapan yang harus di lewati seperti dengan cara sebagai
berikut :
1. Buatlah tabel transisi dari NFA dengan ε −move semula

δ a b
qo Ø Ø
q1 q2 q3
q2 Ø Ø
q3 Ø Ø
 2. Tentukan ε −closure untuk setiap state-state

ε_cl(qo) = {qoq1}
ε_cl(q1) = {q,}
ε_cl(q2) = {q2}
ε_cl(q3) = {q3}
3. Kemudian, carilah setiap fungsi transisi hasil perubahan dari NFA
ε −move ke NFA tamapa ε −move (kita sebut saja dengan δ' )
dimana δ ' didapat dengan rumus :
δ ' (state,input) = ε −closure ( δ ( ε −closure (state),input))

δ'(q0, a) = ε_closure( δ (ε_closure(q0), a))

= ε_closure( δ ({q0, q1}, a))
= ε_closure(q2)
= {q2}

δ'(q0, b) = ε _closure( δ (ε _closure(qo), b))

= ε _closure( δ ({q0, q1}, b))
= ε _closure(q3)
= {q3}

δ'(q1, a) = ε _closure( δ (e.closure(qo), a))

= ε _closure( δ ({q1}, a) )
= ε _closure(q2)
= {q2}

δ'(q1, b) = ε _closure{ δ (ε.closure(q1), b))

= ε _closure( δ {{q1}, b))
= ε _closure(q3)
= {q3}

δ'(q2, a) = ε _closure( 5 (ε_closure(q2), a))

= ε _closure( 8 ({q2}, a))
= ε _closure(0)
= Ø
 δ'(q2, b) = ε closure( 8 (ε_closure(q2), b))
= ε _closure( 8 ({q2}, b))
= e_closure(0)
= Ø
δ'(q3, a) = e_closure( 8 (e_closure{q3), a))
= e_closure( 8 ({q3}, a))
= e_closure(0)
= Ø
δ'(q3, b) = e_closure( δ (e_closure(q3), b))
= e_closure( δ ({q3}, b))
= e_closure(0)
= Ø

4. Berdasarkan hasil no. 3, kita dapat membuat tabel transisi diagram transisi
dari NFA tampa ε_move yang ekuivaen dengan NFA dengan ε_move
tersebut.

δ' a b
qo q2 q3
q1 q2 q3
q2 Ø Ø
q3 Ø Ø
Akhirnya kita tentuka himpunan state akhir untuk NFA tampa ε_move ini.
Himpunan state akhit semula (q3). Karena tidak ada state lain yang
ε_closure memuat q3 maa himpnan state akhir sekarang tetap q3.
Dapat kita lihat NFA tampa ε_move-nya sebagai berikut :

d. Penggabungan dan Konkatenasi FSA?

Pada dua mesin FSA kita dapat melakukan operasi penggabungan atau dikenal juga
sebagai Union dan Konkatenasi. Berikut penjelasan lebih lanjut:

 Union
L (M’) = L(M1) + L(M2)

 Konkatenasi
L(M’’) = L(M1) L(M2)

Dari dua operasi tersebut, kita dapat menggabungkan dua mesin fsa, misalkan
L(M1) adalah bahasa yang diterima di M1 dan L(M2) adalah bahasa yang
diterima di M2, maka kita dapat membuat M yang menerima bahasa L(M)
dengan langkah sbb :

 Tambahkan state awal untuk M, hubungkan dengan state awal M1 dan

state awal M2 menggunakan transisi e
 Tambahkan state akhir M, hubungkan dengan state-state akhir M1 dan
state-state akhir M2 menggunakan transisi e Maka didapat
gabungan/union dimana L(M’)=L(M1)+L(M2)
 State awal M1 menjadi state awal M’’
 State-state akhir M2 menjadi state akir M’’
 Hubungkan State akhir M1 dengan state awal M2 dengan transisi e. Maka
kita dapatkan hasil konkatenasi dimana L(M’’)=L(M1)L(M2)
D. Kelompok 4.
Pembahasan : Ekspresi Reguler (ER).

Pada pembahasna kali ini kita akan membahas tentang ER tentang penerapan ER,
Notasi ER, Hubungan ER dengan FSA. Kita akan membahas satu persatu dari setiap
bagian ER.

a. Penerapan Ekspresi Reguler (ER).

Sebuah bahasa dinyatakan regular jika terdapat Finite State Automata
yang dapat menerimanya. Bahasa-bahasa yang diterima oleh suatu Finite State
Automata bisa dinyatakan secara sederhana dengan ekspresi regular. ER
memberikan suatu pola(pattern) atau template untuk untai atau string dari suatu
bahasa.

Contoh penerapan lain adalah pembatasan data masukan yang

diperkenankan, misalnya suatu field input hanya menerima input bilangan 0..9
seperti gambar dibawah :

Gambar tersebut menerima input antara 0 sampai 9, sedangkan ekspresi

regularnya dinyatakan sebagai berikut : (digit) (digit)*digit = 0..9.
b. Notasi ER
Notasi ER memiliki berbagai macama yang akan kita gunakan dalam
pembahasan ER sebagai berikut :
yaitu ‘*’, ‘+’, ‘U’, ‘.’
* Yaitu karakter asterisk, berarti bisa tidak muncul bisa juga muncul berhingga
kali, (0-n).
(pada posisi superscript/ diatas) berarti minimal muncul satu kali (1-n).
+ Atau U berati union
. (titik) berarti konkatenasi, biasanya titik bisa dihilangkan, misalnya: ab
bermakna sama seperti a.b.

Contoh ER sebagai berikut:

 ER: ab*cc
 Contoh string yang dibangkitkan: abcc, abbcc, abbbcc, abbbbcc, acc (b bisa
tidak muncul atau muncul sejumlah berhingga kali).
 ER: 010*
Contoh string yang dibangkitkan: 01, 010, 0100, 01000, (jumlah 0 di ujung
bisa tidak muncul, bisa muncul berhingga kali).
 ER: a*d
Contoh string yang dibangkitkan: d, ad, aad.
 ER: a+d
Contoh string yang dibangkitkan: ad, aad, aaad, (a minimal muncul sekali).
 ER: a*b* (ingat ‘’ berarti atau).
Contoh string yang dibangkitkan: a, b, aa, bb, aaa, bbb, aaaa, bbbb.
 ER: (ab)
Contoh string yang dibangkitkan: a, b.
 ER: (ab)*
Contoh string yang dibangkitkan: a, b, ab, ba, abb, bba, aaaa, bbbb (untai
yang memuat a atau b).
 ER: 01*+0
Contoh string yang dibangkitkan: 0, 01, 011, 0111, 01111, (string yang
berawalan dengan 0, dan selanjutnya boleh di ikuti deretan 1).

c. Hubungan ER dengan FSA

Hubungannya dapat kita lihat dari gamabar dibawah ini :

Dapat kita simpulkan bahwa hubungan ER dengan FSA adalah saling

berkalitan satu sama dengan lainnya seperti gambar diatas dapat kita lihat, dari
ER ke NFA ε_move ke NFA ke DfA ke ER. Terus berputar membentuk sisklus
hidup yang saling berkaitan dengan lainnya.

NFA ε_move
Untuk setiap ER ada Non-deterministik Finite Automata dengan transisi
ε (NFA ε-move) yang ekuivalen. Sementara dari bahasa yang diterima oleh DFA
ada satu ekspresi ER hanya kita bisa membuat suatu Non-deterministik Finite
Automata, ε-move dari suatu ER. Contoh yang bisa dilihat pada gambar dibawah
ini, yang perlu di perhatikan di sini, state akhir akan menandakan apakah suatu
input di terima atau tidak.

NFA ε −move untuk ER: ab.

NFA ε −move untuk ER a*b

Contoh-contoh Non-deterministic NFA �−𝑚𝑜𝑣� diatas dapat di rubah

kedalam bentuk Non-deterministic NFA, selanjutnya dapat di rubah ke
deterministic NFA. Bila ER-nya cukup sederhana bisa langsung mengkonstriksi
NFA-nya, tampa melalui NFA �−𝑚𝑜𝑣�. Misalkan saya NFA tampa �−𝑚𝑜𝑣�
untuk ER: ab bisa di lihat pada gambar di bawah.

NFA untuk ER : ab.

 NFA untuk ER : a  b

Kita dapat mengubah suatu ER ke NFA dan ke DFA sesuai dengan

hubungan ER dengan FSA diatas.
Contoh permasalahan :

seperti, membuat mesin DFA yang menerima bahasa yang berupa semua
string yang berakhiran dengan ‘00’. Diketahui ∑ = (0,1).
Langkah pertama, membuat ekpresi reguler:

(0+1)*00

Bisa juga di tulis sebagai (01)*00 , karena simbol ‘+’ bisa menggantikan
‘’. Dari ekpresi reguler tersebut, lebih mudah membuat NON-DFA-nya ebih
dulu, dari pada langsung ke DFA . mesin NFA-nya dapat di lihar pada gambar
dibawah ini :

Mesin NFA

Tabel transisi untuk NFA gambar diatas adalah sebagai berikut :

δ 0 1
q0 {q0,q1 } {q0}
q1 {q2} -
q2 - -
 Akhirnya buat DFA pada gambar dibawah yang ekiuvalen dengan Non-
DFA tersebut. Hal ini bisa cek dengan untai/ string yang harus bisa di terima oleh
mesin, seperti 00, 100, 000, 0100, 0000, 1100.

Mesin DFA.

Dapat kita simpulkan dari pembahasan diatas bahawa sebuah ER dapat di bentuk
kedalam NFA dan NFA dapat dirubah kembali ke DFA dan DFA dapat di rumah
ke ER kemabali seperti gambar hubungan ER dengan ER diatas.

E. Kelompok 5
Pembahasan : Aturan Produks untuk FSA

Dalam pembahasan ini kita kan membhasa tentang aturan produksi ER,
mengkonstruksi aturan suatu FSA, dan FSA untuk suatu tata bahasa ER.

a. Aturan produksi Ekspresi Reguler

 Sebuah automata berhingga menspesifikasikan sebuah bahasa sebagai himpunan
semua untai yang menggerakkannya dari state awal ke salah satu state yang di
terimanya ( himpunan akhir).

Batasan aturan produksi untuk bahasa regular :

α→β
Suatu tata bahasa (grammar) didefinisikan dengan 4 Tupel yaitu : V, T, P, dan S
Di mana,
V = Himpunan simbol variabel / non termina
T = Himpunan simbol terminal
P = Kumpulan aturan produksi
S = Simbol awal

b. Mengkonstruksi aturan produksi dari suatu FSA

Dalam mengkonstruksi suatu aturan produksi tata bahasa reguler dari suatu FSA,
perlu kita ingat adalah state-state yang bisa menuju ke state akhir. Bisa kita lihat
pada mesin FSA dibawah ini :

Misalnya kita tentukan simbol awal adalah S kita identikan S dengan state awal
q0. Dari q0 mendapat input a menuju q1. Bisa kita tuliskan aturan produksi :
SaE

Di sini kita gunakan sebagai E dan bukan A karena menyatakan bagian yang
belum
terbangkitkan mulai dari state q1.
Dari q1 mendapat transisi – є (tanpa menerima input) ke q2 dan q3 . Bisa kita
tuliskan :
E→A
E→B
(Di sini kita identikkan q2 sebagai A dan q3 sebagai B)
 Dari q2 jika mendapat input a menuju ke state q2 itu sendiri dan jika mendapat
input b
menuju ke state q4 yang merupakan state akhir dan tidak menuju ke state yang
lainnya
sehingga dapat dituliskan menjadi :
A → aA
A→b
Dari q3 jika mendapat input b menuju ke state q3 itu sendiri dan jika mendapat
input b
juga menuju ke state q4 yang merupakan state akhir dan tidak menuju ke state
yang
lainnya sehingga dapat dituliskan menjadi :
B → bB
B→b
Kumpulan aturan produksi yang kita peroleh bisa kita tuliskan sebagai berikut.
S → aE
E →A| B
A → aA | b
B → bB | b
Secara formal tata bahasa yang diperoleh dari otomata adalah sebagai berikut.
V = {S, E, A, B}
T = {a, b}
P = { S → aE, E → A | B, A → aA | b, B → bB | b }
S=S

c. FSA untuk suatu tata bahasa reguler

Bila sebelumnya dari suatu diagram transisi FSA kita bisa membuat aturan-aturan
produksinya, sebalikna kita juga bisa mengkontruksi diagram transisi FSA untuk
suatu tata bahasa reguler yang di ketahui aturan produksinya.

Misalkan terdapat tata bahasa regular dengan aturan produksi.

S → aB | bA | є
 A → abaS
B → babS
Maka diagram transisinya dapat digambar sebagai berikut.

Contoh lain, akan dibuat diagram transisi untuk tata bahasa regular :
S → abA | B | baB | є
A → bS | b
B → aS
Jawab :

Contoh lain, akan dibuat diagram transisi untuk tata bahasa regular :
S → aS | bB | b
B → cC
C → aS

F. Kelompok 6
Pembahasan : FSA dengan output

dalam pembahasan kalini kita akan membahasn tentang Mesin Moore, Mesin Mealy,
dan Ekuivalensi mesin moore dan mesin mealy.

Keterbatasan dari finite state automata adalah diterima atau ditolak. Otomata tersebut
biasa disebut sebagai accepter (finite state accepter). Kita bisa membangun sebuah
finite state automata yang memiliki keputusan beberapa keluaran/output.
a. Mesin Moore
Mesin Moore memiliki 6(enam) Tupple, Mo = (Q,S,d,S,D,l), dimana :
Q = Himpunan state
S = Himpunan symbol input
d = Fungsi Transisi
S = State awal, S Î Q
D = Himpunan symbol output / karakter
l = Fungsi output untuk setiap state

Kita lihat contoh penerapan dari Mesin Moore. Misal kita ingin memperoleh sisa
pembagian(modulus) suatu bilangan dengan 3. Di mana input dinyatakan dalam biner.
Q = {q0,q1,q2}
Σ = {0,1} (input dalam biner)
Δ = {0,1,2}
(untuk output-nya pada kasus mod dengan 3, maka sisanya kemungkinan
adalah 0,1,2).

S = q0
λ (q0) = 0
λ (q1) = 1
λ (q2) = 2

1. 5 mod 3 = ?
Input 5 dalam biner 101
Bila kita masukkan 101 ke dalam mesin, urutan state yang dicapai:
q0,q1,q2,q2
perhatikan state terakhir yang dicapai adalah q2, λ(q2) = 2, maka 5 mod 3 = 2
2. 10 mod 3 = ?
Input 10 dalam biner 1010
Bila kita masukkan 1010 ke dalam mesin, urutan state yang di capai:
q0,q1,q2,q2,q1
λ (q1) = 1, maka 10 mod 3 = 1.

b. Mesin Mealy
Bila ouput pada mesin Moore berasosiasi dengan state, maka ouput pada mesin Mealy
akan berasosiasi dengan transisi. Mesin Mealy sendiri dedefinisikan dalam 6 tupel, M
= (Q, Σ, δ, S, Δ, λ), dimana:

Q = Himpunan state
Σ = Himpunan Simbol input
d = Fungsi Transisi
S = State Awal, S ∈ Q
Δ = Himpunan Output
λ = Fungsi Output untuk setiap transisi
 Mesin diatas akan mengeluarkan output apakah menerima(Y) atau menolak (T), suatu
masukan, di mana mesin akan mengeluarkan ouput ‘Y’ bila menerima untai yang
memilki akhiran 2 simbol berturutan yang sama, atau secara formal dalam ekspresi
regular:

(0+1)*(00+11)

Contoh input yang diterima: 01011, 01100, 1010100, 10110100, 00, 11, 100, 000, 111.
Konfigurasi dari mesin Mealy tersebut adalah sebagai berikut:

Q = {q0,q1,q2}
Σ = {0,1}
Δ = {Y, T}
S = q0

λ (q0, 0) = T
λ (q0, 1) = T
λ (q1, 0) = Y
λ (q1, 1) = T
λ (q2, 0) = T
λ (q2, 1) = Y

c. Ekuivalensi Mesin Moore dan Mesin Mealy

Dari suatu mesin Moore dapat dibuat mesin Mealy yang eki-valen, begitu juga
sebaliknya. Untuk mesin Mealy dapat kita buat mesin Moore yang ekuivalen. Bisa
kita lihat state pada mesin Moore dibentuk dari kombinasi state pad Mealy dan
banyaknya output. Karena jumlah state Mealy = 3, dan jumlah output = 2, maka
jumlah state pada Moore yang ekuivalen = 6.

Konfigurasi mesin Moore yang dibentuk adalah sebagai berikut.

Q = {q0Y, q0T,q1Y, q1T,q2Y, q2T}

Σ = {0,1}
Δ = {Y, T}
S = q0T

λ (q0, Y) = Y
λ (q0, T) = T
λ (q1, Y) = Y
λ (q1, T) = T
λ (q2, Y) = Y
λ (q2, T) = T