Automata ngôn ngữ hình thức

LỜI NÓI ĐẦU
Đối với mỗi người làm tin học, các ngôn ngữ là một phần không thể thiếu
trong công việc. Để có thể hiểu sâu sắc về các ngơn ngữ lập trình (giải thuật và
cú pháp) thì khơng thể khơng ngiên cứu về các ngơn ngữ hình thức, về các văn
phạm và các Outomat . Cũng chính vì vậy Ngơn Ngữ Hình Thức được đưa vào
làm mơn học cho tất cả các sinh viên công nghệ thông tin . Trong đề tài này
chúng em xin trình bày về thương của 2 automat hữu hạn đơn định.
Chúng em chia đề tài ra làm 3 phần chính :
1. Tìm hiểu về DFA
2. Tìm hiểu về thương đúng của 2 DFA
3. Chương trình minh họa.
Trong suốt quá trình làm BÀI TẬP LỚN, với sự cố gắng của từng thành
viên trong nhóm. Chúng em đã hoàn thành được BÀI TẬP LỚN này. Tuy nhiên
chương trình khơng thể tránh khỏi những sai sót. Chúng em hy vọng sẽ nhận
được nhiểu hơn những sự đóng góp từ phía thầy để chương trình này được hồn
thiện hơn!
Qua đây chúng em cũng muốn gửi lời cám ơn đến thầy Trần Hùng Cường
đã tận tình hướng dẫn và giúp đỡ chúng em hoàn thành bài tập lớn này .
Chúng em xin chân thành cảm ơn!

3


MỤC LỤC
LỜI NĨI ĐẦU.......................................................................................................3
MỤC LỤC.............................................................................................................4
PHẦN 1: ƠTƠMÁT HỮU HẠN ĐƠN ĐỊNH......................................................5
1. Giới thiệu.....................................................................................................5
2. Định nghĩa....................................................................................................6
3. Hàm chuyển trạng thái mở rộng..................................................................7
4. Ngôn ngữ được chấp nhận bởi DFA............................................................8

PHẦN 2: PHÉP THƯƠNG ĐÚNG CỦA 2 DFA...............................................11
1. Giới thiệu...................................................................................................11
2. Bổ đề..........................................................................................................11
3. Định lý.......................................................................................................11
PHẦN 3 : CHƯƠNG TRÌNH MINH HỌA........................................................13
1. Giao diện....................................................................................................13
1.1 Giao diện khởi động............................................................................13
1.2 Giao diện giới thiệu.............................................................................14
1.3 Giao diện nhập M1..............................................................................16
1.4 Giao diện nhập M2..............................................................................18
1.5 Giao diện kết quả thương của 2 DFA M1/M2.....................................20
2. CODE chương trình chính.........................................................................21
2.1 Hàm tạo DFA.......................................................................................21
2.2 Hàm vẽ sơ đồ của DFA vừa tạo...........................................................22
2.3 Hàm lưu lại DFA vừa tạo....................................................................23
2.4 Hàm kiểm tra hợp lệ của DFA.............................................................23
2.5 Hàm tính thương của hai DFA............................................................24
TÀI LIỆU THAM KHẢO...................................................................................26

4


PHẦN 1: ÔTÔMÁT HỮU HẠN ĐƠN ĐỊNH
DFA (Deterministic Finite Automata)
1. Giới thiệu
Một ôtômát hữu hạn đơn định (DFA) gồm một tập hữu hạn các trạng thái
và một tập các phép chuyển từ trạng thái này tới trạng thái khác trên các ký hiệu
nhập (input symbols) được chọn từ một bộ chữ cái Σ nào đó. Mỗi ký hiệu nhập
có đúng một phép chuyển khỏi mỗi trạng thái (có thể chuyển trở về chính nó).
Một trạng thái, thường ký hiệu là q0, gọi là trạng thái bắt đầu (trạng thái ôtômát

bắt đầu). Một số trạng thái được thiết kế như là các trạng thái kết thúc hay trạng
thái chấp nhận.
Một đồ thị có hướng, gọi là sơ đồ chuyển (transition diagram) tương ứng
với một DFA như sau: các đỉnh của đồ thị là các trạng thái của DFA; nếu có một
đường chuyển từ trạng thái q đến trạng thái p trên input a thì có một cung nhãn a
chuyển từ trạng thái q đến trạng thái p trong sơ đồ chuyển. DFA chấp nhận một
chuỗi x nếu như tồn tại dãy các phép chuyển tương ứng trên mỗi ký hiệu của x
dẫn từ trạng thái bắt đầu đến một trong những trạng thái kết thúc.
Chẳng hạn, sơ đồ chuyển của một DFA được mơ tả trong hình 1. Trạng
thái khởi đầu q0 được chỉ bằng mũi tên có nhãn "Start". Chỉ có duy nhất một
trạng thái kết thúc, cũng là q0 trong trường hợp này, được chỉ ra bằng hai vòng
tròn. Ôtômát này chấp nhận tất cả các chuỗi số 0 và số 1 với số số 0 và số số 1 là
số chẵn.

Hình 1 - Sơ đồ chuyển của một DFA
5


Một điều cần lưu ý, DFA sử dụng mỗi trạng thái của nó để giữ chỉ một
phần của chuỗi số 0 và 1 chứ không phải chứa một số thực sự, vì thế DFA cần
dùng một số hữu hạn trạng thái.

2. Định nghĩa
Một cách hình thức ta định nghĩa ơtơmát hữu hạn là bộ gồm năm thành phần
(Q, Σ, δ, q0, F), trong đó :
. Q là tập hợp hữu hạn các trạng thái.
. Σ là bộ chữ cái nhập hữu hạn.
. δ là hàm chuyển ánh xạ từ Q × Σ → Q, tức là δ(q, a) là một trạng thái
được cho bởi phép chuyển từ trạng thái q trên ký hiệu nhập a.
. q0  Q là trạng thái bắt đầu.

. F  Q là tập các trạng thái kết thúc.
Ta vẽ DFA như là bộ điều khiển hữu hạn, với mỗi trạng thái thuộc Q,
DFA đọc một chuỗi các ký hiệu a từ Σ viết trên băng (như hình vẽ).

Hình 2 - Mơ tả một DFA
Trong một lần chuyển, DFA đang ở trạng thái q đọc ký hiệu nhập a trên
băng, chuyển sang trạng thái được xác định bởi hàm chuyển δ(q, a), rồi dịch đầu
đọc sang phải một ký tự. Nếu δ(q, a) chuyển đến một trong những trạng thái kết
thúc thì DFA chấp nhận chuỗi được viết trên băng input phía trước đầu đọc,
nhưng khơng bao gồm ký tự tại vị trí đầu đọc vừa dịch chuyển đến. Trong
trường hợp đầu đọc đã dịch đến cuối chuỗi trên băng, thì DFA mới chấp nhận
tồn bộ chuỗi trên băng.
6


3. Hàm chuyển trạng thái mở rộng
Để có thể mơ tả một cách hình thức hoạt động của một DFA trên chuỗi, ta
mở rộng hàm chuyển δ để áp dụng đối với một trạng thái trên chuỗi hơn là một
trạng thái trên từng ký hiệu. Ta định nghĩa hàm chuyển δ như một ánh xạ từ Q ×
Σ* → Q với ý nghĩa δ(q, w) là trạng thái DFA chuyển đến từ trạng thái q trên) là trạng thái DFA chuyển đến từ trạng thái q trên
chuỗi w) là trạng thái DFA chuyển đến từ trạng thái q trên. Một cách hình thức, ta định nghĩa :
1. δ (q, ε) = q
2. δ (q, w) là trạng thái DFA chuyển đến từ trạng thái q trêna) = δ(δ (q, w) là trạng thái DFA chuyển đến từ trạng thái q trên), a), với mọi chuỗi w) là trạng thái DFA chuyển đến từ trạng thái q trên và ký hiệu nhập a.
Một số quy ước về ký hiệu :
- Q là tập các trạng thái. Ký hiệu q và p (có hoặc khơng có chỉ số) là các
trạng thái, q0 là trạng thái bắt đầu.
- Σ là bộ chữ cái nhập. Ký hiệu a, b (có hoặc khơng có chỉ số) và các chữ
số là các ký hiệu nhập.
- δ là hàm chuyển.
- F là tập các trạng thái kết thúc.

- w) là trạng thái DFA chuyển đến từ trạng thái q trên, x, y và z (có hoặc khơng có chỉ số) là các chuỗi ký hiệu nhập.
Ví dụ :
Ta xét ví dụ sau để hiểu rõ hơn về vấn đề :
Cho một Ôtomat hữu hạn đơn định M có :
Q = {q0, q1}
∑ = {a,b}
F = {q1}
Và các hàm chuyển đổi sau :
δ(q0, a) = q1
δ(q0, b) = q0
δ(q1, a) = q1
δ(q1, b) = q0
Sau đây sẽ là các chuyển đổi và miêu tả về hoạt động của M khi xâu đầu vào là
aba.
q0aba → q1ba → q0a → q1.
7


Ta có là xâu aba được đốn nhận bởi Ơtomat M.
Sau đây là hình miêu tả sự thay đổi hình trạng của M khi xử lí xâu trên:
Hình sau minh họa cho các quá trình chuyển đổi trạng thái của M:

4. Ngôn ngữ được chấp nhận bởi DFA
Một chuỗi w) là trạng thái DFA chuyển đến từ trạng thái q trên được chấp nhập bởi ôtômát hữu hạn M (Q, Σ, δ, q0, F) nếu
δ(q0, w) là trạng thái DFA chuyển đến từ trạng thái q trên) = p với p F. Ngôn ngữ được chấp nhận bởi M, ký hiệu L(M) là tập
hợp:
L(M) = { w) là trạng thái DFA chuyển đến từ trạng thái q trên | δ (q0, w) là trạng thái DFA chuyển đến từ trạng thái q trên)  F }
Ví dụ : Xét sơ đồ chuyển ở hình 1. Theo khái niệm hình thức, ta có DFA được
xác định bởi M (Q, Σ, δ, q0, F) với Q = {q0, q1, q2, q3}, Σ = {0, 1}, F = {q0} và
hàm chuyển δ như sau:

8


Giả sử chuỗi w) là trạng thái DFA chuyển đến từ trạng thái q trên = 110101 được nhập vào M.
Ta có δ(q0, 1) = q1 và δ(q1, 1) = q0 ,vậy δ(q0, 11) = δ(δ(q0,1),1) = δ(q1,
1) = q0.
Tiếp tục δ(q0, 0) = q2, vậy δ(q0, 110) = δ(δ(q0, 11), 0) = q2.
Tiếp tục ta có δ(q0, 1101) = q3, δ(q0, 11010) = q1
Và cuối cùng δ(q0, 110101) = q0  F.
(Hay δ(q0, 110101) = δ(q1, 10101) = δ(q0, 0101) = δ(q2, 101) = δ(q3, 01)
= δ(q1, 1) = q0  F)
Vậy 110101 thuộc L(M). Ta có thể chứng minh rằng L(M) là tập mọi chuỗi có
số chẵn số 0 và số chẵn số 1.
Theo mô tả DFA như trên, ta thấy cũng có thể dùng bảng hàm chuyển
(transition table) để mô tả các phép chuyển trạng thái của một ôtômát hữu hạn.
Trong bảng hàm chuyển, hàng chứa các trạng thái thuộc tập trạng thái của
ôtômát và cột là các ký hiệu thuộc bộ chữ cái nhập. Bảng hàm chuyển gợi ý cho
chúng ta một cấu trúc dữ liệu để mô tả cho một ôtômát hữu hạn, đồng thời cũng
cho thấy có thể dễ dàng mơ phỏng hoạt động của DFA thơng qua một chương
trình máy tính, chẳng hạn dùng cấu trúc vòng lặp.

9


Giải thuật mơ phỏng hoạt động của một DFA
Mục đích: kiểm tra một chuỗi nhập x có thuộc ngơn ngữ L(M) đýợc chấp
nhận bởi automata M.
Input: chuỗi nhập x$
Output: câu trả lời ‘YES’ hoặc ‘NO’

Giải thuật:
q := q0 ;
c := nextchar ; {c là ký hiệu nhập được đọc tiếp theo}
While c <> $ do
begin
q := δ(q, c);q, c);
c := nextchar ;
end
If (q, c);q in F) then write(q, c);"YES") else write(q, c);"NO");

Nhận xét :
Một cách tổng quát, ta thấy tập Q của DFA thể hiện các trạng thái lưu trữ
của ơtơmát trong q trình đốn nhận ngơn ngữ, và như vậy khả năng lưu trữ
của ôtômát là hữu hạn. Mặt khác, hàm chuyển δ là hàm toàn phần và đơn trị, cho
nên các bước chuyển của ôtômát luôn luôn được xác định một cách duy nhất.
Chính vì hai đặc điểm này mà DFA mô tả như trên được gọi là ôtômát hữu hạn
đơn định.

10


PHẦN 2: PHÉP THƯƠNG ĐÚNG CỦA 2 DFA
1. Giới thiệu
Cho w) là trạng thái DFA chuyển đến từ trạng thái q trên, v thuộc Σ* thì thương đúng (right quotient) của w) là trạng thái DFA chuyển đến từ trạng thái q trên cho v được kí
hiệu và định nghĩa là w) là trạng thái DFA chuyển đến từ trạng thái q trên/v = u nếu w) là trạng thái DFA chuyển đến từ trạng thái q trên = uv, nghĩa là nếu v là tiếp vĩ ngữ của w) là trạng thái DFA chuyển đến từ trạng thái q trên thì
w) là trạng thái DFA chuyển đến từ trạng thái q trên/v là tiếp đầu ngữ tương ứng của w) là trạng thái DFA chuyển đến từ trạng thái q trên.
Cho L và L là các ngôn ngữ trên bảng chữ cái giống nhau, thì thương
đúng của L với L được định nghĩa là:
L /L = {w) là trạng thái DFA chuyển đến từ trạng thái q trên/v: w) là trạng thái DFA chuyển đến từ trạng thái q trên  L,v  L }
= {x : xy  L với một y nào đó  L }

Nói cách khác, nếu trong chuỗi L1 có tiếp vĩ ngữ của L2, loại bỏ các tiếp
vĩ ngữ và kết quả là chuỗi ký tự trong L1 / L2.
2. Bổ đề
Cho M1 = (Q,Σ, δ ,q, F ) là một dfa cho L.Nếu một trạng thái q nào đó 
Q có tính chất tồn tại một chuỗi y nào đó  L sao cho δ*(q,y)  F thì  x mà δ
*(q,x) = q, x sẽ  L /L .
Và vì vậy nếu thay những trạng thái kết thúc của M bằng những trạng thái
q có tính chất này thì ta sẽ có một DFA mà chấp nhận L/L .

3. Định lý
Nếu L và L là các NNCQ, thì L/L cũng chính qui. Chúng ta nói rằng họ
NNCQ là đóng dưới phép thương đúng.
Chứng minh
Cho L1 = L(M) trong đó M = (Q, Σ, δ, q,F) là một dfa. Ta xây
dựng một dfa

=( Q, Σ, δ, q,

), chấp nhận L/L ,bằng
11


cách chỉ thay đổi tập F thông qua thủ tục sau.
Thủ tục: Right quotient
Input: dfa M = (Q, Σ, δ,q,F ) và dfa M = (P, Σ, δ,p,F )
Output: dfa

= (Q, Σ, δ, q,

)

Ta xác định

bằng cách xác định với mỗi qi  Q, có tồn tại hay khơng

chuỗi y thuộc L2 sao cho δ*(qi, y)  F. Nếu đúng thì đưa qi vào .
Điều này có thể thực hiện được bằng cách xét các dfa:
Mi= (Q,Σ, δ, q,F). chính là M nhưng trạng thái khởi đầu q được thay bằng q.
Rồi xét xem L ∩ L(M ) có ≠ ∅ khơng. Nếu khác thì qi có tính chất đã nói ở trên
và thêm qi vào

. Thực hiện điều này với mọi q thuộc Q, ta sẽ xác định được

và vì vậy xây dựng được

.

Ví dụ :
Tìm L1/L2 cho
L1 = L(a*baa*)
L2 = L(ab*)

12


PHẦN 3: CHƯƠNG TRÌNH MINH HỌA
1. Giao diện
1.1

Giao diện khởi động

- Khi chương trình bắt đầu chạy thì xuất hiện giao diện này.

Hình 1: Giao diện khởi động.

13


1.2

Giao diện giới thiệu

- Khi chương trình khởi động xong thì giao diện này (hình 2).
- Gồm chức năng sau:
+ Giới thiệu (hình 2.1).
+ Thốt chương trình (hình 2.1).
+ Gọi form nhập M1 (hình 2.2).
+ Gọi form nhập M2 (hình 2.2).
+ Tính kết quả của thương hai DFA: M1/M2 (hình 2.2).

Hình 2: Giao diện giới thiệu.

14


Hình 2.1: Giao diện giới thiệu.

Hình 2.2: Giao diện giới thiệu.
15

1.3

Giao diện nhập M1

- Từ giao diện giới thiệu \ Run \ Nhập M1 sẽ xuất hiện form nhập M1 như
hình 3.1.
- Chức năng của form này gồm:
+ Nhập và tạo DFA M1.
+ Xem sơ đồ của DFA M1 vừa tạo ở trên (hình 3.2).
+ Lưu lại DFA M1 vừa tạo ở trên để thực hiện chia cho DFA M2 (nhập
sau).
+ Kiểm tra một chuỗi có thuộc DFA này khơng.

Hình 3.1: Giao diện nhập M1

16


Hình 3.2: Sơ đồ của M1 (khi nhập như hình 3).

17


1.4

Giao diện nhập M2

- Từ giao diện giới thiệu \ Run \ Nhập M2 sẽ xuất hiện form nhập M2 như
hình 4.1.

- Chức năng của form này gồm:
+ Nhập và tạo DFA M2.
+ Xem sơ đồ của DFA M2 vừa tạo ở trên (hình 4.2).
+ Lưu lại DFA .
+ Kiểm tra một chuỗi có thuộc DFA này khơng.

Hình 4.1: Giao diện nhập M2.

18


Hình 4.2: Sơ đồ M2 (khi nhập như hình 5).

19


1.5

Giao diện kết quả thương của 2 DFA M1/M2

- Từ giao diện giới thiệu \ Run \ “M1/M2” sẽ xuất hiện form kết quả của
thương của hai DFA M1 và M2 như hình 4.1.

Hình 5: Giao diện kết quả M1/M2.

20


2. CODE chương trình chính
2.1

Hàm tạo DFA

private void btnOutputMaTrix_Click(object sender, EventArgs e)
{
if (txtStatusNumber.Text == "" || txtXichMa.Text == "")
{
MessageBox.Show("Vui lòng nhập Xích Ma và số trạng thái");
return;
}
btnImageDFA.Visible = true;
grpValid.Visible = true;
lblNote.Visible = true;
//add status
status_number = Convert.ToInt16(txtStatusNumber.Text);
pnlStatus.Controls.Clear();
pnlMaTrix.Controls.Clear();
for (int i = 0; i < status_number; i++)
{
CheckBox chkStatus = new CheckBox();
chkStatus.Name = "chkStatus" + i;
chkStatus.Text = "Q" + i;
chkStatus.Width = 50;
chkStatus.Location = new Point(10, (i + 1) * 20);
pnlStatus.Controls.Add(chkStatus);
}
//add matrix
strXichMa = txtXichMa.Text;
for (int i = 0; i <= status_number; i++)
{

for (int j = 0; j <= strXichMa.Length; j++)
{
if (!(i == 0 && j == 0))
{
GroupBox grpMatrixLocal = new GroupBox();
grpMatrixLocal.Height = 40;
grpMatrixLocal.Width = 60;
grpMatrixLocal.Location = new Point((j + 1) * 60 40, (i + 1) * 36 - 20);
pnlMaTrix.Controls.Add(grpMatrixLocal);
if (i == 0)
{
Label lblXichMa = new Label();
lblXichMa.Text = strXichMa[j - 1].ToString();
lblXichMa.Width = 30;
lblXichMa.Location = new Point(10, 15);
grpMatrixLocal.Controls.Add(lblXichMa);
}
else if (j == 0)
{
Label lblStatus = new Label();
lblStatus.Text = "Q" + (i - 1);
lblStatus.Width = 25;
lblStatus.Location = new Point(10, 15);
grpMatrixLocal.Controls.Add(lblStatus);
}
else

21

{
(j - 1);

ComboBox cboStatus = new ComboBox();
cboStatus.Name = "cboStatus" + (i - 1) + "_" +
for (int k = 0; k < status_number; k++)
cboStatus.Items.Add("Q" + k);
cboStatus.Width = 40;
cboStatus.SelectedIndex = 0;
cboStatus.Location = new Point(10, 10);
grpMatrixLocal.Controls.Add(cboStatus);

}
}

}

}

}

2.2

Hàm vẽ sơ đồ của DFA vừa tạo

private void btnImageDFA_Click(object sender, EventArgs e)
{
DataTable dt_diagram = new DataTable();
foreach (char c in strXichMa)
dt_diagram.Columns.Add(c.ToString());

for (int i = 0; i < status_number; i++)
{
DataRow row = dt_diagram.NewRow();
for (int j = 0; j < strXichMa.Length; j++)
{
ComboBox cboStatus =
(ComboBox)this.Controls.Find("cboStatus" + i + "_" + j, true)[0];
row[j] = cboStatus.Text.Substring(1);
}
dt_diagram.Rows.Add(row);
}
DataTable dt_status = new DataTable();
for (int i = 0; i < status_number; i++)
{
dt_status.Columns.Add();
}
DataRow row1 = dt_status.NewRow();
for (int i = 0; i < status_number; i++)
{
CheckBox chkStatus =
(CheckBox)this.Controls.Find("chkStatus" + i, true)[0];
row1[i] = chkStatus.Checked;
}
dt_status.Rows.Add(row1);
DrawingDFA draw = new DrawingDFA();
draw.strXichMa = strXichMa;
draw.status_number = status_number;
draw.dt_diagram = dt_diagram;
draw.dt_status = dt_status;
draw.Show();

}

22