OpenStax-CNX module: m Ôtômat hữu hạn và biểu thức chính quy ThS. Võ Huỳnh Trâm This work is produced by OpenStax-CNX and licensed under the Cr

OpenStax-CNX module: m30085 1 Ôtômat hữu hạn và biểu thức chính quy ThS. Võ Huỳnh Trâm This work is produced by OpenStax-CNX and licensed under the Creative Commons Attribution License 3.0 Tóm tắt nội dung Nội dung chính: Trong chương này, ta sẽ nghiên cứu một loại "máy trừu tượng" gọi là ôtômát hữu hạn. Chúng là công cụ dùng đoán nhận một lớp ngôn ngữ khá đơn giản gọi là lớp ngôn ngữ chính quy. Trước hết, hai dạng của ôtômát hữu hạn sẽ lần lượt được trình bày và có sự chứng minh rằng chúng tương đương nhau về khả năng đoán nhận ngôn ngữ. Tiếp đó, ta sẽ đề cập đến biểu thức chính quy - một phương tiện khác để xác định ngôn ngữ và ta lại thấy rằng lớp ngôn ngữ do các ôtômát hữu hạn chấp nhận chính là lớp ngôn ngữ chính quy. Phần tiếp theo của chương sẽ đề cập đến mối quan hệ giữa cơ chế ôtômát và các biểu thức chính quy dùng ký hiệu cho ngôn ngữ. Cuối chương này, một vài ứng dụng cụ thể của ôtômát hữu hạn sẽ được trình bày. Mục tiêu cần đạt: Kết thúc chương này, sinh viên cần nắm vững : [U+F0D8] Khái niệm ôtômát hữu hạn, các thành phần, các dạng và sự khác biệt cơ bản giữa hai dạng. [U+F0D8] Cách thức chuyển đổi tương đương từ dạng đơn định sang không đơn định và ngược lại. [U+F0D8] Viết biểu thức chính quy ký hiệu cho tập ngôn ngữ chính quy. [U+F0D8] Mối liên quan giữa ôtômát hữu hạn và biểu thức chính quy. [U+F0D8] Vẽ sơ đồ chuyển trạng thái (đơn định hoặc không đơn định) từ một biểu thức chính quy. [U+F0D8] Tìm các ứng dụng thực tế khác từ mô hình ôtômát hữu hạn. Kiến thức cơ bản: Để tiếp thu tốt nội dung của chương này, sinh viên cần có một số các kiến thức liên quan về lý thuyết đồ thị, lý thuyết mạch; hiểu các khái niệm cơ bản về kiến trúc máy tính; có sử dụng qua một số trình soạn thảo văn bản thông thường... Tài liệu tham khảo : [1] John E. Hopcroft, Jeffrey D.Ullman Introduction to Automata Theory, Languages and Computation Addison Wesley Publishing Company, Inc 1979 (Chapter 2 : Finite Automata and Regular Expressions). [2] Phan Thị Tươi Trình biên dịch Nhà xuất bản Giáo dục 1986 (Chương 3 : Bộ phân tích từ vựng). [3] J.A.Garcia and S.Moral- Theory of Finite Automata : http://decsai.ugr.es/ jags/fat.html [4] Donald R. Biggar - Regular Expression Matching Using Finite Automata: http://www3.sympatico.ca/dbiggar/fa.home.html 1 ÔTÔMÁT HỮU HẠN (FA : Finite Automata) Ôtômát hữu hạn FA là một mô hình tính toán của hệ thống với sự mô tả bởi các input và output. Tại mỗi thời điểm, hệ thống có thể được xác định ở một trong số hữu hạn các cấu hình nội bộ gọi là các trạng thái (states). Mỗi trạng thái của hệ thống thể hiện sự tóm tắt các thông tin liên quan đến những input đã chuyển qua và xác định các phép chuyển kế tiếp trên dãy input tiếp theo. Trong khoa học máy tính, ta có thể tìm thấy nhiều ví dụ về hệ thống trạng thái hữu hạn, và lý thuyết về ôtômát hữu hạn là một công cụ thiết kế hữu ích cho các hệ thống này. Chẳng hạn, một hệ chuyển mạch như bộ điều khiển (Control Unit) trong máy tính. Một chuyển mạch thì bao gồm một số hữu hạn các cổng Version 1.1: Jul 22, 2009 1:51 am +0000 http://creativecommons.org/licenses/by/3.0/

OpenStax-CNX module: m30085 2 (gate) input, mỗi cổng có 2 giá trị 0 hoặc 1. Các giá trị đầu vào này sẽ xác định 2 mức điện thế khác nhau ở cổng output. Mỗi trạng thái của một mạng chuyển mạch với n cổng bất kỳ sẽ là một trường hợp trong 2n phép gán của 0 và 1 đối với các cổng khác nhau. Các chuyển mạch thì được thiết kế theo cách này, vì thế chúng có thể được xem như hệ thống trạng thái hữu hạn. Các chương trình sử dụng thông thường, chẳng hạn trình sọan thảo văn bản hay bộ phân tích từ vựng trong trình biên dịch máy tính cũng được thiết kế như các hệ thống trạng thái hữu hạn. Ví dụ bộ phân tích từ vựng sẽ quét qua tất cả các dòng ký tự của chương trình máy tính để tìm nhóm các chuỗi ký tự tương ứng với một tên biến, hằng số, từ khóa,...trong quá trình xử lý này, bộ phân tích từ vựng cần phải nhớ một số hữu hạn thông tin như các ký tự bắt đầu hình thành những chuỗi từ khóa. Lý thuyết về ôtômát hữu hạn thường được dùng đến nhiều cho việc thiết kế các công cụ xử lý chuỗi hiệu quả. Máy tính cũng có thể được xem như một hệ thống trạng thái hữu hạn. Trạng thái hiện thời của bộ xử lý trung tâm, bộ nhớ trong và các thiết bị lưu trữ phụ ở mỗi thời điểm bất kỳ là một trong những số rất lớn và hữu hạn của số trạng thái. Bộ não con người cũng là một hệ thống trạng thái hữu hạn, vì số các tế bào thần kinh hay gọi là neurons là số có giới hạn, nhiều nhất có thể là 235. Lý do quan trọng nhất cho việc nghiên cứu các hệ thống trạng thái hữu hạn là tính tự nhiên của khái niệm và khả năng ứng dụng đa dạng trong nhiều lĩnh vực thực tế. Ôtômát hữu hạn (FA) được chia thành 2 loại: đơn định (DFA) và không đơn định (NFA). Cả hai loại ôtômát hữu hạn đều có khả năng nhận dạng chính xác tập chính quy. Ôtômát hữu hạn đơn định có khả năng nhận dạng ngôn ngữ dễ dàng hơn ôtômát hữu hạn không đơn định, nhưng thay vào đó thông thường kích thước của nó lại lớn hơn so với ôtômát hữu hạn không đơn định tương đương. 1.1 Ôtômát hữu hạn đơn định - DFA (Deterministic Finite Automata) Một ôtômát hữu hạn đơn định (DFA) - gọi tắt là FA -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 [U+F053] 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 3.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. Thí dụ 3.1 :

OpenStax-CNX module: m30085 3 Figure 1 Hình 3.1 - Sơ đồ chuyển của một DFA 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. Đị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, [U+F053], [U+F064], q0, F), trong đó :. Q là tập hợp hữu hạn các trạng thái.. [U+F053] là bộ chữ cái nhập hữu hạn.. [U+F064] là hàm chuyển ánh xạ từ Q [U+F0B4] [U+F053] [U+F0AE] Q, tức là [U+F064](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 [U+F0CE] Q là trạng thái bắt đầu. F [U+F0CD] 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ừ [U+F053] viết trên băng (như hình vẽ).

OpenStax-CNX module: m30085 4 Figure 2 Hình 3.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 [U+F064](q, a), rồi dịch đầu đọc sang phải một ký tự. Nếu [U+F064](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 toàn bộ chuỗi trên băng. 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 [U+F064] để á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 [U+F064] như một ánh xạ từ Q [U+F0B4] [U+F053]* [U+F0AE] Q với ý nghĩa [U+F064](q, w) là trạng thái DFA chuyển đến từ trạng thái q trên chuỗi w. Một cách hình thức, ta định nghĩa : 1. d (q, [U+F065]) = q 2. [U+F064] (q, wa) = [U+F064]([U+F064] (q, w), a), với mọi chuỗi w 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. [U+F053] 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. [U+F064] là hàm chuyển. F là tập các trạng thái kết thúc. w, x, y và z (có hoặc không có chỉ số) là các chuỗi ký hiệu nhập. Ngôn ngữ được chấp nhận bởi DFA Một chuỗi w được chấp nhập bởi ôtômát hữu hạn M (Q, [U+F053], [U+F064], q0, F) nếu [U+F064](q0, w) = p với p [U+F0CE] 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 [U+F07C] [U+F064] (q0, w) [U+F0CE] F } Thí dụ 3.2 : Xét sơ đồ chuyển ở hình 3.1. Theo khái niệm hình thức, ta có DFA được xác định bởi M (Q, [U+F053], [U+F064], q0, F) với Q = {q0, q1, q2, q3}, [U+F053] = {0, 1}, F = {q0} và hàm chuyển [U+F064] như sau:

OpenStax-CNX module: m30085 5 d Inputs Trạng thái 0 1 q0 q2 q1 q1 q3 q0 q2 q0 q3 q3 q1 q2 Table 1 Giả sử chuỗi w = 110101 được nhập vào M. Ta có [U+F064](q0, 1) = q1 và [U+F064](q1, 1) = q0,vậy [U+F064](q0, 11) = [U+F064]([U+F064](q0,1),1) = [U+F064](q1, 1) = q0. Tiếp tục [U+F064](q0, 0) = q2, vậy [U+F064](q0, 110) = [U+F064]([U+F064](q0, 11), 0) = q2. Tiếp tục ta có [U+F064](q0, 1101) = q3, [U+F064](q0, 11010) = q1 Và cuối cùng [U+F064](q0, 110101) = q0 [U+F0CE] F. (Hay d(q0, 110101) = d(q1, 10101) = d(q0, 0101) = d(q2, 101) = d(q3, 01) = d(q1, 1) = q0 [U+F0CE] 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. Giải thuật mô phỏng hoạt động của một DFA. Input : Chuỗi nhập x kết thúc bởi $. Output : Câu trả lời "YES" nếu DFA chấp nhận chuỗi x và "NO" nếu ngược lại.. Giải thuật :q := q0 ;c := nextchar ; { c là ký hiệu nhập được đọc tiếp theo }While c < > $ dobeginq := d(q, c);c := nextchar ;endif q in F then write ("YES") else write("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 quá trình đoá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 d 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. 1.2 Ôtômát hữu hạn không đơn định - NFA (Nondeterministic Finite Automata) Xét một dạng sửa đổi mô hình DFA để chấp nhận không, một hoặc nhiều hơn một phép chuyển từ một trạng thái trên cùng một ký hiệu nhập. Mô hình mới này gọi là ôtômát hữu hạn không đơn định (NFA). Một chuỗi ký hiệu nhập a1 a2... an được chấp nhận bởi một NFA nếu có tồn tại một chuỗi các phép chuyển, tương ứng với chuỗi nhập, từ trạng thái bắt đầu đến trạng thái kết thúc. Chẳng hạn, chuỗi 01001 được chấp nhận bởi ôtômát trong hình dưới đây vì có chuỗi phép chuyển qua các trạng thái q0, q0, q0, q3, q4, q4 có nhãn tương ứng là 0, 1, 0, 0, 1. NFA này chấp nhận tất cả các chuỗi có hai số 0 liên tiếp hoặc hai số 1 liên tiếp. Thí dụ 3.3 :

OpenStax-CNX module: m30085 6 Figure 3 Hình 3.3 - Sơ đồ chuyển của một NFA Chú ý rằng có thể xem ôtômát hữu hạn đơn định - DFA (hay gọi tắt là FA) là một trường hợp đặc biệt của NFA, trong đó mỗi trạng thái chỉ có duy nhất một phép chuyển trên mỗi ký hiệu nhập. Vì thế trong DFA, với một chuỗi nhập w và trạng thái q, chỉ có đúng một đường đi nhãn w bắt đầu từ q. Để xác định chuỗi w có được chấp nhận bởi DFA hay không chỉ cần kiểm tra đường đi này. Nhưng đối với NFA, có thể có nhiều đường đi có nhãn là w, và do đó tất cả phải được kiểm tra để thấy có hay không có đường đi tới trạng thái kết thúc. Tương tự như DFA, NFA cũng hoạt động với một bộ điều khiển hữu hạn đọc trên băng nhập. Tuy nhiên, tại mỗi thời điểm, bộ điều khiển có thể chứa một số bất kỳ trạng thái. Khi có sự lựa chọn trạng thái kế tiếp, chẳng hạn như từ trạng thái q0 trên ký hiệu nhập 0 ở hình 3.3, ta phải tưởng tượng như có các bản sao của ôtômát đang thực hiện đồng thời. Mỗi trạng thái kế tiếp mà ôtômát có thể chuyển đến sẽ tương ứng với một bản sao của ôtômát mà tại đó bộ điều khiển đang chứa trạng thái đó. Chẳng hạn, với chuỗi 01001, ta có :

OpenStax-CNX module: m30085 7 Figure 4 Định nghĩa Một cách hình thức ta định nghĩa ôtômát hữu hạn không đơn định NFA là một bộ 5 thành phần (Q, [U+F053], [U+F064], q0, F) trong đó Q, [U+F053], q0 và F có ý nghĩa như trong DFA, nhưng [U+F064] là hàm chuyển ánh xạ từ Q [U+F0B4] [U+F053] [U+F0AE] 2Q. Khái niệm [U+F064](q, a) là tập hợp tất cả các trạng thái p sao cho có phép chuyển trên nhãn a từ trạng thái q tới p. Hàm chuyển trạng thái mở rộng Để thuận tiện trong việc mô tả hoạt động ôtômát trên chuỗi, ta mở rộng hàm chuyển [U+F064] ánh xạ từ Q [U+F0B4] [U+F053]* [U+F0AE] 2Q như sau : 1. d(q, e) = {q} 1. [U+F064](q, wa) = { p [U+F07C] có một trạng thái r trong [U+F064](q, w) mà p thuộc [U+F064](r, a)} = [U+F064]([U+F064](q, w), a) 1. d(p, w) = Èq [U+F0CE] P d(q, w), [U+F022]P [U+F0CD] Q. Ngôn ngữ được chấp nhận bởi NFA Ngôn ngữ L(M), với M là ôtômát hữu hạn không đơn định NFA (Q, [U+F053], [U+F064], q0, F) là tập hợp : L(M) = {w [U+F07C] [U+F064](q0, w) có chứa một trạng thái trong F } Thí dụ 3.4 : Xét sơ đồ chuyển của hình 3.3. Theo khái niệm hình thức, ta có : NFA M ({q0, q1, q2, q3, q4}, {0, 1}, d, q0, {q2, q4}) với hàm chuyển d như sau :

OpenStax-CNX module: m30085 8 Xét chuỗi nhập w = 01001 Ta có :d (q0, 0) = {q0, q3} d Inputs Trạng thái 0 1 q0 {q0,q3} {q0,q1} q1 Æ {q2} q2 {q2} {q2} q3 {q4} Æ q4 {q4} {q4} Table 2 d (q0, 01) = d(d(q0, 0),1) = d({q0, q3},1) = d (q0, 1) È d (q3, 1) = {q0, q1} Tương tự, ta có thể tính : d (q0, 010) = {q0, q3} d (q0, 0100) = {q0, q3, q4} và d (q0, 01001) = {q0, q1, q4} Do q4 [U+F0CE] F nên w [U+F0CE] L (M). Câu hỏi :? 1. Hãy cho nhận xét về điểm khác biệt quan trọng giữa DFA và NFA? 2. Theo bạn, dạng đơn định hay không đơn định sẽ dùng nhận dạng một chuỗi dễ dàng hơn? 1.3 Sự tương đương giữa DFA và NFA Vì mỗi DFA là một NFA, nên rõ ràng lớp ngôn ngữ được chấp nhận bởi NFA cũng bao gồm các tập chính quy (đây chính là ngôn ngữ được chấp nhận bởi DFA ). Tuy nhiên, không có cơ sở để nói rằng NFA chỉ chấp nhận duy nhất các tập hợp này. Điều đó cho thấy DFA có thể mô phỏng được hoạt động của NFA, nghĩa là với mỗi NFA, ta có thể xây dựng một DFA tương đương (chấp nhận cùng một ngôn ngữ với nó). Đặt một DFA mô phỏng hoạt động của NFA là cho phép các trạng thái của DFA tương ứng với tập các trạng thái của NFA. Tại mỗi thời điểm, DFA lưu giữ trong bộ điều khiển tất cả các trạng thái mà NFA có thể chuyển đến khi đọc cùng một input như DFA. ĐỊNH LÝ 3.1 : Nếu L là tập được chấp nhận bởi một NFA thì tồn tại một DFA chấp nhận L. Chứng minh Đặt M (Q, [U+F053], [U+F064], q0, F) là NFA chấp nhận L. Ta xây dựng DFA M (Q, [U+F053], [U+F064], q0, F ) tương đương như sau: - Các trạng thái của M là tất cả các tập hợp con của tập trạng thái của M, hay Q = 2Q. Tại mỗi thời điểm, M sẽ lưu giữ trong trạng thái của nó tất cả các trạng thái có thể của M. Một phần tử trong Q được ký hiệu là [q1, q2,..., qi], trong đó các trạng thái q1, q2,..., qi [U+F0CE] Q. Ta xem [q1, q2,..., qi] là một trạng thái đơn của DFA tương ứng với một tập trạng thái của NFA. - q0 = [q0]. - F là tập hợp các trạng thái của Q có chứa ít nhất một trạng thái kết thúc trong tập F của M. - Ta định nghĩa hàm chuyển [U+F064] như sau : d ([q1, q2,..., qi], a) = [p1, p2,..., pj] nếu và chỉ nếu [U+F064] ({q1, q2,..., qi }, a) = {p1, p2,..., pj} Bây giờ ta chứng minh quy nạp theo độ dài của chuỗi nhập x rằng:

OpenStax-CNX module: m30085 9 d (q0, x) = [q1, q2,..., qi] Û d(q0, x) = {q1, q2,..., qi} (1) Với [U+F0BD]x[U+F0BD]= 0, ta có x = [U+F065] và q0 = [q0] nên (1) hiển nhiên đúng Giả sử (1) đúng với các chuỗi nhập có độ dài tới m. Xét chuỗi nhập có độ dài m + 1, đặt chuỗi này là xa với a [U+F0CE] [U+F053], ta có : d (q0, xa) = d (d (q0, x), a) Theo định nghĩa : d ([p1, p2,..., pi], a) = [r1, r2,..., rk] Û d({p1, p2,..., pj}, a) = {r1, r2,..., rk}. Mặt khác theo giả thiết quy nạp d (q0, x) = [p1, p2,..., pj] Û d(q0, x) = {p1, p2,..., pj}, nên thay vào ta có : d (q0, xa) = [r1, r2,..., rk] Û d(q0, xa) = {r1, r2,..., rk}. Dễ thấy rằng d (q0, x) [U+F0CE] F khi và chỉ khi d(q0, x) có chứa ít nhất một trạng thái [U+F0CE] F. Vậy L(M) = L(M ) Vì NFA và DFA chấp nhận cùng các tập hợp, nên ta sẽ không phân biệt chúng trừ khi điều đó thật sự cần thiết, sẽ đơn giản hơn để hiểu cả hai cùng là ôtômát đơn định. Thí dụ 3.5 : Cho NFA M ({q0, q1}, {0, 1}, d, q0, {q1}) với hàm chuyển d như sau : d(q0, 0) = {q0, q1},d(q0,1) = {q1},d(q1, 0) = [U+F0C6], d(q1, 1) = {q0, q1} Ta xây dựng DFA tương đương M (Q, {0, 1}, d, [q0], F ) chấp nhận L(M) như sau :. Q : chứa tất cả các tập con của {q0, q1}, vậy Q = {[q0], [q1], [q0, q1], [U+F0C6]}. Hàm chuyển d : Vì d(q0, 0) = {q0, q1} nên d ([q0], 0) = [q0, q1] Tương tự : d ([q0], 1) = [q1] d ([q1], 0) = [U+F0C6] d ([q1], 1) = [q0, q1] Mặt khác : d ([U+F0C6], 0) = d ([U+F0C6], 1) = [U+F0C6] Cuối cùng : d ([q0, q1],0) = [q0, q1] ( vì d({q0, q1},0) = d(q0, 0) [U+F0C8] d(q1, 0) = {q0, q1} [U+F0C8] [U+F0C6] = {q0, q1}) d ([q0, q1], 1) = [q0, q1] ( vì d({q0, q1},1) = d(q0, 1) [U+F0C8] d(q1, 1) = {q1} [U+F0C8] {q0, q1} = {q0, q1}). Tập trạng thái kết thúc F = {[q1], [q0, q1]} Thực tế, có rất nhiều trạng thái của NFA không có hàm chuyển đến từ trạng thái bắt đầu [q0]. Do đó, thông thường, cách tốt nhất là ta nên xây dựng DFA tương đương bắt đầu từ trạng thái [q0] và thêm vào các trạng thái mới cho DFA chỉ khi có các hàm chuyển từ một trạng thái đã được thêm vào trước đó. Câu hỏi :? Bạn có nhận xét gì về kích thước giữa một DFA và một NFA tương đương với nó chấp nhận cùng một tập ngôn ngữ? 1.4 NFA với [U+F065]-dịch chuyển (NFA[U+F065]) Ta mở rộng mô hình NFA cho phép các phép chuyển trên nhãn rỗng [U+F065]. Sơ đồ chuyển sau đây của một NFA chấp nhận chuỗi gồm một số bất kỳ (có thể là 0) chữ số 0 sau đó là một số bất kỳ chữ số 1 và sau nữa là một số bất kỳ chữ số 2. Thông thường, ta nói NFA chấp nhận một chuỗi w nếu có đường truyền nhãn w từ trạng thái bắt đầu đến một trạng thái kết thúc. Chẳng hạn, chuỗi 002 được chấp nhận bởi đường truyền q0, q0, q0, q1, q2, q2 với các cung nhãn 0, 0, [U+F065], [U+F065], 2. Thí dụ 3.6 : Sơ đồ chuyển của một NFA với [U+F065]-dịch chuyển :

OpenStax-CNX module: m30085 10 Figure 5 Hình 3.4 - NFA với [U+F065]-dịch chuyển Định nghĩa: Một cách hình thức ta định nghĩa NFA với [U+F065]-dịch chuyển là bộ 5 thành phần (Q, [U+F053], [U+F064], q0, F) với tất cả các thành phần có ý nghĩa như trên, nhưng hàm chuyển [U+F064] là ánh xạ từ Q [U+F0B4] ([U+F053] [U+F0C8] {[U+F065]}) [U+F0AE] 2Q. Khái niệm [U+F064](q, a) gồm tất cả các trạng thái p sao cho có phép chuyển nhãn a từ q tới p, trong đó a là một ký hiệu thuộc [U+F053] hoặc là [U+F065]. Hàm chuyển trạng thái mở rộng: Ta mở rộng hàm chuyển [U+F064] thành hàm chuyển [U+F064]* ánh xạ từ Q [U+F0B4] [U+F053]* [U+F0AE] 2Q. [U+F064]*(q,w) chứa tất cả các trạng thái p sao cho có thể đi từ q tới p theo đường đi nhãn w (có thể chứa cạnh nhãn [U+F065]). Ta sử dụng [U+F065]-CLOSURE(q) để xác định tập tất cả các đỉnh p sao cho có đường đi từ q tới p với nhãn [U+F065]. Thí dụ 3.7 : Trong hình 3.4, [U+F065]-CLOSURE(q0) = {q0, q1, q2}. Vì đường đi chỉ có một đỉnh q0 (không có cung trên đường đi) là đường đi từ q0 tới q0 có tất cả các cạnh nhãn là [U+F065]. Đường đi q0, q1 chỉ ra rằng q1 thuộc [U+F065]-CLOSURE(q0). Và đường đi q0, q1, q2 chỉ ra rằng q2 thuộc [U+F065]-CLOSURE(q0). Đặt [U+F065]-CLOSURE(P) = [U+F0C8]q[U+F0CE]P [U+F065]-CLOSURE(q), trong đó P là một tập các trạng thái và q là một trạng thái. Ta định nghĩa hàm [U+F064]* như sau: 1. [U+F064]*(q, e) = e-closure(q) 2. [U+F064]*(q, wa) = e-closure(p), trong đó tập P = {p [U+F07C] có r trong [U+F064]*(q, w) sao cho p [U+F0CE] [U+F064](r, a)}, [U+F022]w [U+F0CE] [U+F053]* và a [U+F0CE] [U+F053] Hay [U+F064]*(q, wa) = e-closure(d([u+f064]*(q, w), a) Ta mở rộng [U+F064] và [U+F064]* trên tập hợp các trạng thái R như sau : 3. [U+F064] (R, a) = È q[u+f0ce]r [U+F064](q, a), và 4. [U+F064]*(R, w) = Èq[U+F0CE]R [U+F064]*(q, w) Câu hỏi :? Hãy so sánh sự khác biệt giữa hàm chuyển [U+F064] và [U+F064]*? Nhận xét : [U+F064]*(q, a) và [U+F064](q, a) không nhất thiết bằng nhau vì [U+F064]*(q, a) gồm tất cả các trạng thái có thể chuyển đến được từ q trên nhãn a gồm cả đường đi nhãn e, trong khi đó d(q, a) chỉ gồm các trạng thái có thể đến được từ q chỉ bằng các cung nhãn a. Tương tự [U+F064]*(q, e) có thể cũng không bằng [U+F064](q, e). Vì vậy ta phải phân biệt ký hiệu [U+F064] và [U+F064]* đối với NFA với e-dịch chuyển. Ngôn ngữ được chấp nhận bởi NFA[U+F065]: Ta định nghĩa L(M), ngôn ngữ được chấp nhận bởi NFA[U+F065] M = (Q, [U+F053], [U+F064], q0, F) là tập hợp các chuỗi : L(M) = {w [U+F07C] [U+F064]*(q0, w) có chứa ít nhất một trạng thái trong F} Thí dụ 3.8 : Xét sơ đồ chuyển của hình 3.4.

OpenStax-CNX module: m30085 11 Theo khái niệm hình thức, ta có NFA M ({q0, q1, q2}, {0, 1, 2}, [U+F064], q0, {q2}) với hàm chuyển [U+F064] như sau : d Inputs Trạng thái 0 1 2 e q0 {q0 } Æ Æ { q1} q1 Æ {q1} Æ {q1} q2 Æ Æ {q2} Æ Table 3 Xét chuỗi nhập w = 012. Ta cần tính [U+F064]*(q0, 012) Ta có : [U+F064]*(q0, e) = e-closure(q0) = {q0, q1, q2} vậy [U+F064]*(q0, 0) = e-closure([u+f064]([u+f064]*(q0, e), 0) = e-closure(d({q0, q1, q2}, 0)) = e-closure(d(q0, 0) È d(q1, 0) È d(q2, 0)) = e-closure({q0} È Æ È Æ ) = e-closure({q0}) = {q0, q1, q2} và [U+F064]*(q0, 01) = e-closure([u+f064]([u+f064]*(q0, 0), 1)) = e-closure(d({q0, q1, q2}, 1)) = e-closure(d(q0, 1) È d(q1, 1) È d(q2, 1)) = e-closure(æ È {q1} ÈÆ ) = e-closure({q1}) = {q1, q2} [U+F0DE] [U+F064]*(q0, 012) = e-closure(d( [U+F064]*(q0, 01), 2)) = e-closure(d({q1, q2}, 2)) = e-closure(d(q1, 2) È d(q2, 2)) = e-closure(æ È {q2}) = e-closure({q2}) = {q2} Do [U+F064]*(q0, 012) có chứa trạng thái q2 [U+F0CE] F nên chuỗi w [U+F0CE] L(M). Giải thuật mô phỏng hoạt động của một NFA[U+F065] :. Input : Chuỗi nhập x được kết thúc bởi $.. Output : Câu trả lời "YES" nếu NFA chấp nhận chuỗi x và "NO" nếu ngược lại.. Giải thuật : q := e-closure(q0); c := nextchar ; { c là ký hiệu nhập được đọc tiếp theo } While c <> $ do begin q := e-closure(d(q, c)); c := nextchar ; end If q in F then write ("YES") else write ("NO");

OpenStax-CNX module: m30085 12 1.5 Sự tương đương giữa NFA có và không có e-dịch chuyển Tương tự như NFA, khả năng có thể thực hiện phép chuyển trên nhãn e của NFAe cũng không làm cho NFAe chấp nhận được các tập hợp không chính quy. Ta có thể dẫn chứng điều này bằng cách mô phỏng hoạt động của một NFAe bởi một NFA không có e-dịch chuyển. ĐỊNH LÝ 3.2 : Nếu L được chấp nhận bởi một NFA có e-dịch chuyển thì L cũng được chấp nhận bởi một NFA không có e-dịch chuyển. Chứng minh Đặt M (Q, [U+F053], [U+F064], q0, F) là NFA với e-dịch chuyển. Ta xây dựng NFA M (Q, [U+F053], [U+F064], q0, F ) tương đương không có e-dịch chuyển, trong đó: F [U+F0C8] {q0} nếu e-closure(q0) chứa một trạng thái thuộc F. F = F trong các trường hợp còn lại. [U+F064] (q, a) là [U+F064]*(q, a) với q [U+F0CE] Q và a [U+F0CE] [U+F053]. Chú ý rằng M không có e-dịch chuyển nên ta có thể dùng [U+F064] thay cho [U+F064]*, nhưng phải phân biệt [U+F064] và [U+F064]*. Ta chứng minh bằng quy nạp trên [U+F07C] x [U+F07C] rằng [U+F064] (q0, x) = [U+F064] *(q0, x). Tuy nhiên, điều đó có thể không đúng với x = e vì [U+F064] (q0, e) = {q0} trong khi [U+F064] *(q0, e) = e-closure(q0). Do đó, cơ sở quy nạp bắt đầu với độ dài chuỗi là 1. Với x = 1 thì x là một ký hiệu a và [U+F064] (q, a) = [U+F064] *(q, a) theo định nghĩa [U+F064]. Xét x > 1: đặt x = wa với a là một ký hiệu trong [U+F053]. Ta có [U+F064] (q, wa) = [U+F064] ([U+F064] (q0, w), a) Theo giả thiết quy nạp thì [U+F064] (q0, w) = [U+F064] *(q0, w). Đặt [U+F064] *(q0, w) = P, ta cần chỉ ra rằng [U+F064](P, a) = [U+F064] *(q0, wa). Ta có [U+F064] (P, a) = Èq[U+F0CE]P [U+F064] (q, a) = Èq[U+F0CE]P [U+F064] *(q, a). Hơn nữa vì P = [U+F064] *(q0, w) nên Èq[U+F0CE]P [U+F064] *(q, a) = [U+F064] *(q0, wa) ( theo quy tắc 2 trong định nghĩa [U+F064] *). Vậy [U+F064] (q0, wa) = [U+F064] *(q0, wa) Để đầy đủ chứng minh ta còn phải chỉ ra rằng [U+F064] (q0, x) chứa một trạng thái trong F nếu và chỉ nếu [U+F064] *(q0, x) chứa một trạng thái trong F. Nếu x = e thì điều đó hiển nhiên đúng (theo định nghĩa của F ) Nếu x [U+F0B9] e thì ta đặt x = wa với a [U+F0CE] [U+F053]. Nếu [U+F064] *(q0, x) chứa một trạng thái trong F thì chắc chắn [U+F064] (q0, x) chứa cùng trạng thái trong F. Ngược lại, nếu [U+F064] (q0, x) chứa một trạng thái trong F khác hơn q0 thì [U+F064](q0, x) phải chứa một trạng thái trong F (vì tập F và F chỉ chênh lệch nhau trạng thái q0). Nếu [U+F064] (q0, x) có chứa trạng thái q0 và q0 cũng là một trạng thái thuộc tập trạng thái kết thúc F thì vì [U+F064] *(q0, x) = e-closure([u+f064]([u+f064] *(q0, w),a)), nên trạng thái chung trong e-closure(q0) và trong F phải ở trong [U+F064] *(q0, x). Thí dụ 3.9 : Chuyển NFA với e-dịch chuyển ở hình 3.4 sang dạng NFA không có chứa e-dịch chuyển. Ta xây dựng NFA tương đương M (Q, [U+F053], [U+F064], q0, F ) chấp nhận L(M) với các thành phần :. Q = {q0, q1, q2}. å = {0, 1, 2}. Trạng thái bắt đầu : q0. F = {q0, q2} do e-closure(q0) = {q0, q1, q2} có chứa q2 [U+F0CE] F. Hàm chuyển [U+F064] của M được xác định theo công thức : d (q, a) = d*(q, a) = e-closure(d(d*(q0, e), a) Kết quả được chỉ ra trong bảng hàm chuyển sau :

OpenStax-CNX module: m30085 13 d Inputs Trạng thái 0 1 2 q0 {q0, q1, q2} {q1, q2} {q2} q1 Æ {q1, q2} {q2} q2 Æ Æ {q2} Table 4 Sơ đồ chuyển trạng thái: Figure 6 Hình 3.5 - NFA tương đương cho thí dụ 3.9 1.6 Giải thuật xây dựng DFA từ NFA Qua khảo sát các dạng mở rộng từ mô hình ôtômát hữu hạn ban đầu, ta thấy DFA thực chất là một trường hợp đặc biệt của NFA, nhưng : - Nó không có sự truyền rỗng (truyền trên nhãn e) - Với mỗi trạng thái q và ký hiệu nhập a, chỉ có duy nhất một đường truyền đến một trạng thái khác. Giả sử mỗi trạng thái của DFA là một tập trạng thái của NFA, DFA dùng trạng thái của mình để lưu giữ tất cả các trạng thái của NFA đạt được sau khi NFA đọc một ký tự nhập. Như vậy sau khi đọc các ký tự nhập a1, a2,..., an, DFA ở trạng thái là tập con của các trạng thái thuộc NFA, đạt được khi NFA đi từ trạng thái bắt đầu theo một con đường nào đó có tên a1a2... an. Số trạng thái của DFA lúc đó phải bằng số phần tử trong tập lũy thừa của số trạng thái NFA. Song, trên thực tế trường hợp xấu nhất này ít khi xảy ra. Các trạng thái thực sự được dùng trong sơ đồ chuyển cho một DFA sẽ được xác định theo các phép chuyển trạng thái trên nhãn là mọi ký hiệu từ trạng thái bắt đẩu của DFA, và sau đó lần lượt được bổ sung thêm vào tập trạng thái nếu như nó chưa có trong đó. Giải thuật chi tiết được trình bày như sau : Input: Một ôtômát hữu hạn không đơn định NFA. Output: Một ôtômát hữu hạn đơn định DFA nhận dạng cùng ngôn ngữ như NFA. Phương pháp: Xây dựng bảng hàm chuyển cho DFA mô phỏng đồng thời tất cả các chuyển dịch của NFA trên chuỗi nhập cho trước. Ta dùng các tác vụ sau để lưu giữ các tập trạng thái của NFA : (q : là một trạng thái của NFA, T : là tập trạng thái của NFA) a) e-closure(q) : là tập trạng thái của NFA đạt được từ trạng thái q trên sự truyền rỗng.

OpenStax-CNX module: m30085 14 b) e-closure(t) : là tập trạng thái của NFA đạt được từ tất cả các trạng thái q thuộc tập T trên sự truyền rỗng. c) d(t, a) : là tập trạng thái của NFA đạt được từ tất cả các trạng thái q thuộc tập T trên sự truyền bằng ký hiệu a. Phân tích: Trước khi đọc vào một ký tự nhập, DFA có thể ở một trạng thái bất kỳ trong các trạng thái thuộc e-closure(q0) với q0 là trạng thái bắt đầu của NFA. Gọi trạng thái này là T. Giả sử các trạng thái của T là các trạng thái đạt được từ q0 trên các ký hiệu nhập và giả sử a là ký hiệu nhập kế tiếp. Khi đọc a, NFA có thể chuyển đến một trạng thái bất kỳ trong tập trạng thái d(t, a). Khi chúng ta cho phép sự truyền rỗng, NFA có thể ở bất kỳ trạng thái nào trong e-closure(d(t, a)) sau khi đã đọc a. Giải thuật : Trạng thái bắt đầu [U+F065]-closure(q0) chỉ là một trạng thái trong các trạng thái của DFA và trạng thái này chưa được đánh dấu; While Có một trạng thái T của DFA chưa được đánh dấu do Begin Đánh dấu T; { xét trạng thái T} For Với mỗi ký hiệu nhập a do begin U:= [U+F065]-closure([U+F064](T, a)) If U không có trong tập trạng thái của DFA then begin Thêm U vào tập các trạng thái của DFA và trạng thái này chưa được đánh dấu; [U+F064][T, a] := U; {[U+F064][T, a] là phần tử của bảng chuyển DFA}end; end; End; Ta xây dựng các trạng thái và bảng hàm chuyển cho DFA theo cách như sau : - Mỗi trạng thái của DFA tượng trưng bởi một tập trạng thái của NFA mà NFA có thể chuyển đến sau khi đọc một chuỗi ký hiệu nhập gồm: tất cả sự truyền rỗng có thể xảy ra trước hoặc sau các ký hiệu được đọc. - Trạng thái bắt đầu của DFA là e-closure(q0) - Các trạng thái và hàm chuyển sẽ được thêm vào D bằng giải thuật trên. - Một trạng thái của DFA là trạng thái kết thúc nếu nó là tập các trạng thái của NFA chứa ít nhất một trạng thái kết thúc của NFA. Việc tính toán e-closure(t) có thể xem như quá trình tìm kiếm một đồ thị của các nút từ các nút cho trước và đồ thị bao gồm toàn những cạnh có nhãn e của NFA. Giải thuật đơn giản để tìm e-closure(t) là dùng Stack để lưu giữ các trạng thái mà cạnh của chúng chưa được kiểm tra cho sự truyền rỗng. Thí dụ 3.10 : Tạo DFA từ NFAe sau

OpenStax-CNX module: m30085 15 Figure 7 Hình 3.6 Thí dụ chuyển NFA có [U+F065]-dịch chuyển Các bước xây dựng tập trạng thái cho DFA : 1. Trạng thái bắt đầu của DFA : [U+F065]-closure(0) = {0, 1, 2, 4, 7} = A* 2. [U+F065]-closure([U+F064](A, a)) = [U+F065]-closure({3, 8}) = {1, 2, 3, 4, 6, 7, 8} = B* 3. [U+F065]-closure([U+F064](A, b)) = [U+F065]-closure({5}) = {1, 2, 4, 5, 6, 7} = C* 4. [U+F065]-closure([U+F064](B, a)) = [U+F065]-closure({3, 8}) = B 5. [U+F065]-closure([U+F064](B, b)) = [U+F065]-closure({5, 9}) = {1, 2, 4, 5, 6, 7, 9} = D* 6. [U+F065]-closure([U+F064](C, a)) = [U+F065]-closure({3, 8}) = B 7. [U+F065]-closure([U+F064](C, b)) = [U+F065]-closure({5}) = C 8. [U+F065]-closure([U+F064](D, a)) = [U+F065]-closure({3, 8}) = B 9. [U+F065]-closure([U+F064](D, b)) = [U+F065]-closure({5, 10}) = {1, 2, 4, 5, 6, 7, 10} = E* 10. [U+F065]-closure([U+F064](E, a)) = [U+F065]-closure({3, 8}) = B 11. [U+F065]-closure([U+F064](E, b)) = [U+F065]-closure({5}) = C Từ các tập trạng thái này, ta xác định được A là trạng thái bắt đầu, E là trạng thái kết thúc (vì trong E có chứa trạng thái 10 là trạng thái kết thúc của NFA) và bảng hàm chuyển của DFA như sau : Trạng thái Ký hiệu nhập a b A B C B B D continued on next page

OpenStax-CNX module: m30085 16 C B C D B E E B C Table 5 Từ bảng hàm chuyển như trên, ta xây dựng sơ đồ chuyển trạng thái cho DFA tương đương nhận dạng cùng ngôn ngữ có dạng như sau : Figure 8 Hình 3.7 DFA tương đương cho thí dụ 3.10 Nhận xét : Mặc dù có sự khác nhau trong định nghĩa, ta thấy dạng không đơn định NFA được định nghĩa tổng quát hơn dạng đơn định DFA, nhưng rõ ràng khả năng nhận dạng cùng lớp ngôn ngữ của chúng là tương đương nhau. Trong thực tế, các máy tính số hoàn toàn là đơn định, trạng thái của chúng tại mỗi thời điểm là xác định được duy nhất từ một chuỗi nhập bất kỳ và trạng thái bắt đầu. Câu hỏi :? Tại sao cần định nghĩa dạng không đơn định? Một số gợi ý câu trả lời: 1. Trong một số các bài toán mang tính chọn lựa, có nhiều hướng giải quyết (nhiều cách đi) như trong các chương trình trò chơi (games) thì thông thường hướng giải quyết tốt nhất (cách đi tốt nhất) là không biết trước được, nhưng có thể tìm thấy được bằng cách sử dụng chiến lược tìm kiếm quay lui (back-tracking). Khi có một vài khả năng chọn lựa có thể, ta chọn một khả năng trong chúng và đi theo hướng đó cho đến khi xác định hướng đó là tốt nhất hay chưa. Nếu chưa phải là hướng tốt nhất, ta phải quay về điểm quyết định cuối cùng trước đó và thử khảo sát theo một hướng khác. Một giải thuật mô phỏng quá trình tìm kiếm quay lui này là một giải thuật không đơn định. 2. Không đơn định đôi khi còn rất hữu hiệu trong việc giúp giải quyết các bài toán dễ dàng. Chẳng hạn, trong một số bài toán thì việc xây dựng một NFA có vẻ tự nhiên và đơn giản hơn việc tìm một DFA cho chúng. Tương tự như vậy, không đơn định còn là một cơ chế hiệu quả dùng mô tả văn phạm sinh ra ngôn ngữ một cách súc tích (sự chọn lựa các luật sinh sinh từ cùng một biến). 3. Trong thực tế, một vài kết quả là dễ dàng được chứng minh đối với NFA hơn là DFA. Vì vậy việc cho phép cơ chế không đơn định thường làm đơn giản hóa các lý luận hình thức mà không ảnh hưởng đến tính tổng quát của kết luận.

OpenStax-CNX module: m30085 17 2 BIỂU THỨC CHÍNH QUY (RE : Regular Expressions) Lớp ngôn ngữ được chấp nhận bởi một ôtômát hữu hạn cũng có thể được mô tả thông qua một dạng biểu thức ngắn gọn và súc tích gọi là biểu thức chính quy. Trong phần này, chúng ta sẽ giới thiệu sự kết hợp của các phép toán hợp, nối kết và bao đóng Kleene trên các tập hợp chuỗi để định nghĩa biểu thức chính quy và chứng tỏ rằng lớp ngôn ngữ được chấp nhận bởi một ôtômát hữu hạn thì thực sự là lớp ngôn ngữ được mô tả bởi biểu thức chính quy. 2.1 Định nghĩa Cho [U+F053] là một bộ chữ cái. Biểu thức chính quy trên [U+F053] và các tập hợp mà chúng mô tả được định nghĩa một cách đệ quy như sau: 1) [U+F0C6] là biểu thức chính quy ký hiệu cho tập rỗng 2) [U+F065] là biểu thức chính quy ký hiệu cho tập {[U+F065]} 3) [U+F022]a [U+F0CE] [U+F053], a là biểu thức chính quy ký hiệu cho tập {a} 4) Nếu r và s là các biểu thức chính quy ký hiệu cho các tập hợp R và S thì (r + s), (rs) và ( r*) là các biểu thức chính quy ký hiệu cho các tập hợp R [U+F0C8] S, RS, R* tương ứng. Trong khi viết biểu thức chính quy ta có thể bỏ bớt các dấu ngoặc đơn với lưu ý rằng thứ tự ưu tiên của các phép toán xếp theo thứ tự giảm dần là: phép bao đóng, phép nối kết, phép hợp. Chẳng hạn : Biểu thức ((0(1*)) + 1) có thể viết là 01*+ 1. Câu hỏi :? Như trên ta nói, biểu thức chính quy dùng ký hiệu cho một lớp ngôn ngữ. Bạn hãy thử liệt kê một vài chuỗi và hình dung lớp ngôn ngữ được ký hiệu bởi biểu thức chính quy r = 01*+ 1 trên? Phép toán bao đóng dương cũng có thể được sử dụng khi viết biểu thức chính quy. Ta có thể viết rút gọn rr* hay r*r thành r+. Nếu cần thiết phân biệt thì ta sẽ dùng ký hiệu r cho biểu thức chính quy r và L(r) cho ngôn ngữ được ký hiệu bởi biểu thức chính quy r; ngược lại một cách tổng quát, ta có thể dùng r cho cả hai. Thí dụ 3.11 : Một số biểu thức chính quy ký hiệu cho các ngôn ngữ :. 00 là biểu thức chính quy biểu diễn tập {00}.. (0+1)* ký hiệu cho tập hợp tất cả các chuỗi số 0 và số 1, kể cả chuỗi rỗng = {e, 0, 1, 00, 01, 10, 11, 010, 011, 0010... }. (0+1)*00(0+1)* ký hiệu cho tập hợp tất cả các chuỗi 0,1 có ít nhất hai số 0 liên tiếp. = {00, 000, 100, 0000, 0001, 1000, 1001, 011001,... }. (1+10)* ký hiệu cho tất cả các chuỗi 0, 1 bắt đầu bằng số 1 và không có hai số 0 liên tiếp = {e, 1, 10, 11, 1010, 111, 101010,... }. (0+[U+F065])(1+10)* ký hiệu cho tất cả các chuỗi không có hai số 0 liên tiếp. = {e, 0, 01, 010, 1, 10, 01010, 0111,... }. (0+1)*011 ký hiệu cho tất cả các chuỗi 0, 1 tận cùng bởi 011. = {011, 0011, 1011, 00011, 11011,... }. 0*1*2* ký hiệu cho tất cả các chuỗi có một số bất kỳ các số 0, theo sau là một số bất kỳ số 1 và sau nữa là một số bất kỳ số 2. = {e, 0, 1, 2, 01, 02, 12, 012, 0012, 0112,... }. 00*11*22* ký hiệu cho tất cả các chuỗi trong tập 0*1*2* với ít nhất một trong mỗi ký hiệu. 00*11*22* có thể được viết gọn thành 0+1+2+ Thí dụ 3.12 : Biểu thức chính quy ký hiệu cho tập hợp các chuỗi tên biến đúng trong ngôn ngữ lập trình Pascal : Một chuỗi tên biến (identifiers) được gọi là hợp lệ trong một chương trình Pascal nếu như nó bắt đầu bằng ít nhất một chữ cái và theo sau đó là các chữ cái, số, ký hiệu underline hoặc một vài ký hiệu cho phép khác trên bàn phím máy tính.

OpenStax-CNX module: m30085 18 Biểu thức chính quy có dạng như sau : r = (A +...+ Z + a +... + z) (A +...+ Z + a +... + z + 0 +... + 9 + _ +... )* Thí dụ 3.13 : Biểu thức chính quy ký hiệu cho tập hợp các số nguyên trong ngôn ngữ lập trình Pascal : Một chuỗi số nguyên trong một chương trình Pascal có thể bắt đầu bằng dấu âm (-) hoặc dấu dương (+) hay không chứa ký hiệu dấu, và theo sau đó là một chuỗi các ký hiệu số với ít nhất là một số. Biểu thức chính quy có dạng như sau : r = ( + + - + [U+F065]) ( 0 +... + 9 (0 +... +9 )* Nhận xét : Thông thường, việc tìm một biểu thức chính quy ký hiệu cho một ngôn ngữ khó hơn việc xác định ngôn ngữ được ký hiệu bởi một biểu thức chính quy vì không có giải thuật cho loại bài toán này. 2.2 Một số tính chất đại số của biểu thức chính quy Dễ dàng chứng minh rằng, nếu cho r, s, t là các biểu thức chính quy thì ta có các đẳng thức sau : 1.r + s = s + r2. r + r = r 3.r + (s+t) = (r+s) + t4. r (st) = (rs) t 5. r (s+t) = rs + rt6. (r+s) t = rt + st 7. r[u+f065] = [U+F065] r = r8. [U+F0C6]r = r[u+f0c6] = [U+F0C6] 9. r + [U+F0C6] = r10.[u+f0c6]* = [U+F0C6] 11. ([U+F065] + r)* = r*12.r + r* = r* 13. ( r* )* = r*14. ( r* s* )* = (r+s)* Trong đó, ta có r = s có nghĩa là L(r) = L(s). 3 SỰ TƯƠNG ĐƯƠNG GIỮA ÔTÔMÁT HỮU HẠN VÀ BIỂU THỨC CHÍNH QUY Như trên đã nói, các ngôn ngữ được chấp nhận bởi ôtômát hữu hạn cũng là các ngôn ngữ được mô tả bởi biểu thức chính quy. Chính vì sự tương đương này, mà người ta gọi ngôn ngữ chấp nhận bởi ôtômát hữu hạn là các tập chính quy. Trong phần này, thông qua hai định lý, ta sẽ chỉ ra bằng quy nạp theo kích thước của (số phép toán trong) biểu thức chính quy rằng có tồn tại một NFA với e-dịch chuyển chấp nhận cùng ngôn ngữ; đồng thời với mỗi DFA cũng có một biểu thức chính quy xác định chính ngôn ngữ của nó. ĐỊNH LÝ 3.3: Nếu r là biểu thức chính quy thì tồn tại một NFA với e-dịch chuyển chấp nhận L(r). Chứng minh Ta sẽ chứng minh quy nạp theo số phép toán của biểu thức chính quy r rằng có tồn tại một NFA M với e-dịch chuyển có một trạng thái kết thúc và không có các phép chuyển khỏi trạng thái này chấp nhận biểu thức chính quy r: L(M) = L(r).. r không có phép toán: Vậy r phải là [U+F0C6], e hoặc a (với a [U+F0CE] [U+F053]). Các NFA dưới đây thoả mãn điều kiện: Figure 9

OpenStax-CNX module: m30085 19 Hình 3.7 - Các NFAe cho các kết hợp đơn. r có chứa các phép toán: Giả sử định lý đúng với r có ít hơn i phép toán, i [U+F0B3] 1. Xét r có i phép toán. Có 3 trường hợp : 1) r = r1+ r2. Cả hai biểu thức chính quy r1, r2 có ít hơn i phép toán, vậy ta có 2 ôtômát hữu hạn NFA M1 (Q1, [U+F053]1, [U+F064]1, q1, {f1}) và M2 (Q2, [U+F053]2, [U+F064]2, q2, {f2}) sao cho L(M1) = L(r1) và L(M2) = L(r2). Vì các trạng thái có thể thay đổi tên nên ta giả sử hai tập trạng thái Q1 và Q2 là rời nhau. Đặt q0 là trạng thái bắt đầu mới và {f0} là tập trạng thái kết thúc mới, ta xây dựng NFA M (Q1 [U+F0C8] Q2 [U+F0C8] {q0, f0}, [U+F053]1 [U+F0C8] [U+F053]2, [U+F064], q0, {f0}), trong đó [U+F064] được xác định như sau:. d(q0, e) = {q1, q2}. d(q, a) = d1(q, a) với q [U+F0CE] Q1 - {f1} và a [U+F0CE] [U+F053]1 [U+F0C8] {[U+F065]}. d(q, a) = d2(q, a) với q [U+F0CE] Q2 - {f2} và a [U+F0CE] [U+F053]2 [U+F0C8] {[U+F065]}. d(f1, e) = d(f2, e) = {f0} Chú ý do giả thiết quy nạp là không có phép chuyển nào ra khỏi f1, f2 trong M1, M2. Vì vậy tất cả các phép chuyển của M1 và M2 đều có trong M. Cách xây dựng M chỉ ra trong hình a. Bất kỳ đường đi nào trong sơ đồ chuyển của M từ q0 tới f0 phải bắt đầu bằng cách đi tới q1 hoặc q2 bằng nhãn [U+F065]. Nếu đường đi qua q1 thì nó theo một đường đi nào đó trong M1 tới f1 rồi sau đó tới f0 bằng nhãn [U+F065]. Tương tự trong trường hợp đường đi qua q2. Có một đưòng đi từ q0 đến f0 nhãn x khi và chỉ khi có đường đi nhãn x trong M1 từ q1 đến f1 hoặc có đường đi nhãn x trong M2 từ q2 đến f2. Vậy L(M) = L(M1) [U+F0C8] L(M2) Figure 10 Hình a - Phép hợp Figure 11

OpenStax-CNX module: m30085 20 Hình b - Phép nối kết Figure 12 Hình c - Phép bao đóng Hình 3.8 - Các NFAe cho kết hợp phức 2) r = r1 r2 Đặt M1 và M2 là các ôtômát NFA như trong trường hợp trên và ta xây dựng ôtômát M (Q, [U+F053], [U+F064], {q1}, {f2}), trong đó [U+F064] được xác định như sau:. [U+F064](q, a) = [U+F064]1(q, a) với q [U+F0CE] Q1 - {f1} và a [U+F0CE] [U+F053]1 [U+F0C8] {[U+F065]}. d(f1, e) = {q2}. [U+F064](q, a) = [U+F064]2(q, a) với q [U+F0CE] Q2 và a [U+F0CE] [U+F053]2 [U+F0C8] {[U+F065]} Cách xây dựng M chỉ ra trong hình b. Mỗi đường đi trong M từ q1 tới f2 là đường đi có nhãn x từ q1 tới f1 sau đó là một cung từ f1 tới q2 nhãn [U+F065] và tiếp đến là đường đi từ q2 tới f2. Vậy L(M) = {xy [U+F07C] x [U+F0CE] L(M1) và y [U+F0CE] L(M2)} hay L(M) = L(M1) L(M2). 3) r = r* Đặt M1 (Q1, [U+F053]1, [U+F064]1, q1, {f1}) và L(M1) = r1. Xây dựng M (Q1[U+F0C8] {q0, f0} [U+F053]1, [U+F064], q0, {f0}), trong đó [U+F064] được cho:. d(q0, e) = d(f1, e) = {q1, f0}. d(q, a) = d1(q, a) với q [U+F0CE] Q1 - {f1} và a [U+F0CE] [U+F053]1 [U+F0C8] {[U+F065]} Cách xây dựng M được chỉ ra trong hình c. Mỗi đường đi từ q0 tới f0 gồm: hoặc đường đi từ q0 tới f0 bằng nhãn [U+F065]; hoặc đường đi từ q0 tới q1 bằng nhãn [U+F065] và sau đó là đường đi từ q1 tới f1 trên chuỗi thuộc L(M), rồi đến f0 bằng nhãn [U+F065]. Như vậy có đường đi từ q0 tới f0 nhãn là x nếu và chỉ nếu ta có thể viết x = x1 x2... xj với j [U+F0B3] 0 (trường hợp j = 0 khi x = [U+F065]) [U+F022]xi [U+F0CE] L(M1). Vậy L(M) = L(M1)*. Thí dụ 3.14 : Xây dựng NFA[U+F065] chấp nhận lớp ngôn ngữ được ký hiệu bởi biểu thức chính quy r = 01* + 1. Ta thấy L(r) = { 1, 0, 01, 011, 0111, 01111, 011111,... } là tập ngôn ngữ chứa các bit đơn 0, 1 và các chuỗi bit nhị phân bắt đầu bằng bit 0, theo sau là một chuỗi bit 1 với độ dài tuỳ ý. Theo quy luật thứ tự ưu tiên, biểu thức 01* + 1 thực chất là (0(1*)) + 1, vì vậy nó có dạng r1 + r2 với r1 = 01* và r2 = 1. Ta sẽ lần lượt xây dựng các NFA cho các biểu thức chính quy con, sau đó dựa vào các quy tắc kết hợp để xây dựng NFA cho toàn bộ biểu thức chính quy đã cho.. NFA cho r2 = 1 dễ dàng để xây dựng :

OpenStax-CNX module: m30085 21 Figure 13. NFA cho r1 = 01*: Ta tách r1 = r3 r4, trong đó r3 = 0 và r4 = 1* + NFA cho r3 = 0 : Figure 14 + NFA r4 = 1* : Ta viết r4 = r5*, trong đó r5 = 1. NFA cho r5 = 1 : Figure 15 Theo quy tắc 3) ta xây dựng được NFA cho r4 = r5* = 1* như sau :

OpenStax-CNX module: m30085 22 Figure 16 Theo quy tắc 2) ta xây dựng được NFA cho r1 = r3 r4 = 01* như sau : Figure 17 Cuối cùng, theo quy tắc 1) ta xây dựng NFA cho r = r1 + r2 = 01*+ 1 như sau : Hình 3.9 - NFAe cho ví dụ 3.13 Phần chứng minh của Định lý 3.3 trên cũng chính là cơ sở của giải thuật chuyển đổi một biểu thức chính quy thành ôtômát hữu hạn. Một điểm cần lưu ý là thứ tự ưu tiên của các phép toán được sử dụng trong biểu thức chính quy, điều này rất quan trọng cho quá trình tách biểu thức chính quy thành các biểu thức con trong những trường hợp viết biểu thức chính quy ở dạng tắt (không có dấu ngoặc).

OpenStax-CNX module: m30085 23 Bây giờ, ta cần chứng tỏ rằng mọi tập hợp được chấp nhận bởi một ôtômát hữu hạn thì cũng được ký hiệu bởi một số biểu thức chính quy. ĐỊNH LÝ 3.4 : Nếu L được chấp nhận bởi một DFA, thì L được ký hiệu bởi một biểu thức chính quy. Chứng minh Đặt L là tập hợp được chấp nhận bởi DFA M ({q1, q2,..., qn}, [U+F053], [U+F064], q1, F). Đặt Rkij là tập hợp tất cả các chuỗi x sao cho [U+F064](qi, x) = qj và nếu [U+F064](qi, y) = ql, với y là tiền tố bất kỳ của x, khác x hoặc [U+F065], thì l [U+F0A3] k. Tức là Rkij là tập hợp tất cả các chuỗi làm cho ôtômát đi từ trạng thái qi tới qj không đi ngang qua trạng thái nào (được đánh số) lớn hơn k. (Chú ý, khái niệm "đi ngang qua một trạng thái" có nghĩa là có phép chuyển vào và ra khỏi trạng thái đó, nên i hoặc j đều có thể lớn hơn k). Vì chỉ có n trạng thái nên Rnij sẽ là tập hợp tất cả các chuỗi làm ôtômát đi từ qi tới qj. Ta định nghĩa Rkij một cách đệ quy như sau: Rkij = Rk-1ik (Rk-1kk )* Rk-1kj È Rk-1ij (1) { a [U+F07C] [U+F064](qi, a) = qj } nếu i [U+F0B9] j R0ij = { a [U+F07C] [U+F064](qi, a) = qj } [U+F0C8] {[U+F065]} nếu i = j Một cách hình thức, Rkij định nghĩa như trên là các chuỗi nhập hay nguyên nhân đưa M từ qi tới qj không đi ngang qua trạng thái cao hơn qk, nghĩa là xảy ra hoặc một trong hai trường hợp sau : 1. Nằm trong Rk-1ij (để không bao giờ đi ngang qua một trạng thái nào cao như qk). 2. Bao gồm một chuỗi trong Rk-1ik (chuỗi làm M chuyển đến qk), theo sau bởi không hoặc nhiều chuỗi trong Rk-1kk (chuỗi làm M chuyển từ qk trở về qk mà không ngang qua qk hoặc một trạng thái nào cao hơn) và cuối cùng là một chuỗi trong Rk-1kj (chuỗi làm M chuyển từ qk đến qj ). Ta sẽ chỉ ra rằng với mỗi i, j và k tồn tại biểu thức chính quy rkij ký hiệu cho ngôn ngữ Rkij. Ta quy nạp theo k như sau:. k = 0 : khi đó R0ij là tập hợp hữu hạn các chuỗi có một ký hiệu hoặc [U+F065]. Vậy r0ij có thể viết dưới dạng a1 + a2 +... + ap (hoặc a1 + a2 +... + ap+ [U+F065] nếu i = j). Trong đó {a1, a2,..., ap} là tập hợp tất cả các ký hiệu a sao cho [U+F064](qi, a) = qj. Nếu không có ký hiệu a nào như thế thì [U+F0C6] (hoặc [U+F065] khi i = j) ký hiệu cho r0ij.. Công thức (1) cho Rkij chỉ liên quan đến các phép toán trên biểu thức chính quy: hợp, nối kết, và bao đóng. Hơn nữa theo giả thiết quy nạp, với mỗi l, k và m tồn tại biểu thức chính quy rk-1lm sao cho L(rk-1lm) = Rk-1lm. Vậy đối với rkij ta có thể chọn biểu thức chính quy : (rk-1ik) (rk-1kk)* (rk-1kj) + rk-1ij Cuối cùng ta có nhận xét rằng L(M) = Èqj [U+F0CE] F Rn1j vì Rn1j ký hiệu cho tất cả các nhãn của tất cả các đường đi từ q1 tới qj. Vậy L(M) được ký hiệu bởi biểu thức chính quy r = rn1j1 + rn1j2+... + rn1jp, trong đó tập F = {qj1, qj2,..., qjp} Thí dụ 3.15 : Viết biểu thức chính quy ký hiệu cho ngôn ngữ được chấp nhận bởi DFA sau :

OpenStax-CNX module: m30085 24 Figure 18 Hình 3.10 DFA cho ví dụ 3.13 Gọi DFA được chỉ ra trong hình 3.10 là M ({q1, q2, q3}, {0, 1}, [U+F064], q1, {q2, q3}). Ta thấy, tập hợp tất cả các chuỗi được chấp nhận bởi DFA trên là các chuỗi làm cho ôtômát chuyển từ trạng thái bắt đầu q1 đến một trong hai trạng thái kết thúc q2 và q3 và không chuyển qua số tối đa là 3 (k = 3) trạng thái của ôtômát. Vậy ta cần viết biểu thức chính quy ký hiệu cho tập hợp này như sau : r = r312 + r313 Theo công thức đã được chứng minh trong Định lý, ta có thể tính được các giá trị rkij với i, j là chỉ số các trạng thái từ 1 đến 3 và với k = 0, 1 và 2, như chỉ ra trong bảng sau: k = 0 k = 1 k = 2 rk11 [U+F065] [U+F065] (00)* rk12 0 0 0(00)* rk13 1 1 0*1 rk21 0 0 0(00)* rk22 [U+F065] [U+F065] + 00 (00)* rk23 1 1 + 01 0*1 rk31 [U+F0C6] [U+F0C6] (0 + 1)(00)*0 rk32 0 + 1 0 + 1 (0 + 1)(00)* rk33 [U+F065] [U+F065] [U+F065] + (0 + 1)0*1 Table 6 Bằng cách dùng các công thức tương đương như (r + s) t = rt + st và ([U+F065] + r)* = r* để đơn giản các biểu thức, chẳng hạn khi tính biểu thức : r122 = r021 (r011 )* r012 + r022 = 0([U+F065])*0 + [U+F065] = 00 + [U+F065] Tương tự, khi đơn giản biểu thức r213 = r112 (r122 )* r123 + r113 = 0(00 + [U+F065])*(1 + 01) + 1 ta nhận thấy (00 + [U+F065])* tương đương với (00)* và (1 + 01) thì tương đương với ([U+F065] + 0)1 nên ta rút gọn : r213 = 0(00)*([U+F065] + 0)1 + 1 Mặt khác, chú ý rằng (00)*([U+F065] + 0) thì tương đương với 0*, vì thế 0(00)*([U+F065] + 0)1 + 1 cũng bằng 00*1 + 1 hay cuối cùng là 0*1.

OpenStax-CNX module: m30085 25 Để hoàn thành việc xây dựng biểu thức chính quy cho M, ta cần tính r312 và r313. Ta viết: r312 = r213 (r233 )* r232 + r212 = 0*1([U+F065] + (0 + 1)0*1)*(0 + 1)(00)* + 0(00)* = 0*1((0 + 1)0*1)*(0 + 1)(00)* + 0(00)* và r313 = r213 (r233 )* r233 + r213 = 0*1([U+F065] + (0 + 1)0*1)*([U+F065] + (0 + 1))0*1) + 0*1 = 0*1((0 + 1)0*1)* Vậy biểu thức chính quy có dạng : r = r312 + r313 = 0*1((0 + 1)0*1)*([U+F065] + (0 + 1)(00)*) + 0(00)* 4 MỘT VÀI ỨNG DỤNG CỦA ÔTÔMÁT HỮU HẠN Có nhiều kiểu phần mềm thiết kế nhằm đặc tả sự chuyển đổi tự động từ dạng biểu thức chính quy sang việc cài đặt máy tính một cách hiệu quả tương ứng với ôtômát hữu hạn. Trong phần này, ta sẽ đề cập đến hai ứng dụng trong số chúng. 4.1 Bộ phân tích từ vựng Các ký hiệu từ vựng (token) trong một ngôn ngữ lập trình thì hầu hết không có sự ngọai lệ, được biểu diễn như các tập hợp chính quy. Chẳng hạn, các định danh của ALGOL: các chữ cái viết hoa hoặc thường, theo sau bởi một dãy bất kỳ của chữ cái (letter) hoặc chữ số (digit) với độ dài không giới hạn có thể được biểu diễn như sau : (letter) (letter + digit)* trong đó "letter" thay thế cho A + B +...+ Z + a + b +...+ z và "digit" là 0 + 1 +...+ 9. Một ví dụ khác, các định danh của FORTRAN có độ dài giới hạn là 6 và các chữ cái chỉ cho phép dùng chữ viết hoa hoặc ký hiệu $ được biểu diễn như sau : (letter) ([U+F065] + letter + digit)5 với "letter" là $ + A + B +... + Z. Trong SNOBOL, các hằng số số học có thể được biểu diễn như sau : ([U+F065] + [U+F02D]) (digit + ([U+F0B7] digit * + [U+F065]) + [U+F0B7] digit+ ) Một số công cụ phát sinh bộ phân tích từ vựng nhận input như một dãy các biểu thức chính quy mô tả các ký hiệu từ vựng và phát sinh một ôtômát hữu hạn đơn giản nhận dạng mọi ký hiệu từ vựng. Thông thường, chúng chuyển đổi biểu thức chính quy thành một NFA với [U+F065]-dịch chuyển và sau đó xây dựng tập hợp con các trạng thái để có thể phát sinh DFA một cách trực tiếp hơn là tìm cách loại bỏ các phép chuyển nhãn [U+F065]. Mỗi trạng thái kết thúc xác định ký hiệu từ vựng cụ thể đã tìm thấy. Hàm chuyển của FA sẽ được mã hóa bằng một trong vài cách nhằm chiếm ít không gian hơn so với bảng hàm chuyển tổ chức dưới dạng mảng hai chiều. Bộ phân tích từ vựng được thiết lập bằng cách phát sinh một chương trình cố định thông dịch các bảng mã, cùng với các bảng minh họa cụ thể sự nhận dạng của FA trên các ký hiệu từ vựng (viết dưới dạng các biểu thức chính quy). Bộ phân tích từ vựng dạng này có thể được dùng như một chương trình con độc lập (module) trong một trình biên dịch ngôn ngữ. 4.2 Trình soạn thảo văn bản Hiển nhiên, các trình soạn thảo văn bản hoặc các chương trình tương tự cho phép thay thế một chuỗi bởi mọi chuỗi kết hợp với một biểu thức chính quy cho trước. Chẳng hạn, trình soạn thảo văn bản ed trong UNIX cho phép một câu lệnh như sau : /aba*c/ để tìm sự xuất hiện đầu tiên của chuỗi có dạng như trên. Hay câu lệnh : s/bbb*/b/ cho phép thay thế các chuỗi có dạng bbb* thành chuỗi có một ký tự b.