Nghiên cứu lập trình tập trả lời và ứng dụng cho bài toán ricochet robot

BỘ GIÁO DỤC VÀ ĐÀO TẠO
TRƯỜNG ĐẠI HỌC VINH

NGUYỄN THỊ THU PHƯƠNG

LUẬN VĂN THẠC SỸ
Chuyên ngành: CÔNG NGHỆ THÔNG TIN
Mã ngành:60.48.02.01

ĐỀ TÀI
NGHIÊN CỨU LẬP TRÌNH TẬP TRẢ LỜI
VÀ ỨNG DỤNG CHO BÀI TOÁN RICOCHET ROBOT

Người hướng dẫn: TS. NGUYỄN NGỌC HIẾU

Vinh, tháng 7 /2018


MỤC LỤC
DANH MỤC CÁC TỪ VIẾT TẮT ................................................................. 2
MỞ ĐẦU ........................................................................................................... 3
1. Sự cần thiết của vấn đề nghiên cứu................................................................ 3
2. Mục tiêu nghiên cứu....................................................................................... 4
3. Đối tượng và phạm vi nghiên cứu.................................................................. 4
4. Nội dung nghiên cứu ...................................................................................... 4
5. Kết cấu của luận văn ...................................................................................... 5
CHƯƠNG 1....................................................................................................... 6
CHƯƠNG TRÌNH LOGIC TỔNG QUÁT.................................................... 6
1.1. Một số định nghĩa........................................................................................ 7
1.2. Phủ định trong chương trình logic .............................................................. 9
1.3. Biểu diễn tri thức trong chương trình logic tổng quát .............................. 11

CHƯƠNG 2..................................................................................................... 14
LẬP TRÌNH TẬP TRẢ LỜI ASP ................................................................ 14
2.1. Các định nghĩa........................................................................................... 15
2.2. Phủ định cổ điển (phủ định mạnh) ............................................................ 18
2.3. Cú pháp của chương trình logic mở rộng ................................................. 20
2.4. Ngữ nghĩa tập trả lời ASP ......................................................................... 20
2.5. Biểu diễn tri thức bằng chương trình logic mở rộng ASP ........................ 24
CHƯƠNG 3..................................................................................................... 27
TÍCH HỢP LẬP TRÌNH TẬP TRẢ LỜI CLINGO VỚI PYTHON ........ 27
3.1. Ngơn ngữ lập trình Python ........................................................................ 27
3.2. Chương trình Clingo ................................................................................. 28
3.3. Tích hợp lập trình tập trả lời Clingo với Python ....................................... 29
CHƯƠNG 4..................................................................................................... 37
CÀI ĐẶT MƠ PHỎNG ỨNG DỤNG LẬP TRÌNH TẬP TRẢ LỜI ........ 37
CHO BÀI TOÁN RICOCHET ROBOTS ................................................... 37
4.1 Bài toán Ricochet Robots ........................................................................... 37
4.2 Cài đặt và chạy demo ứng dụng ................................................................. 38
KẾT LUẬN ..................................................................................................... 56
HƯỚNG PHÁT TRIỂN CỦA ĐỀ TÀI ........................................................ 57
TÀI LIỆU THAM KHẢO ............................................................................. 57
1


DANH MỤC CÁC TỪ VIẾT TẮT
ASP

Lập trình tập trả lời (Answer Set Programming)

CNTT

Công nghệ thông tin

CSDL

Cơ sở dữ liệu

2


MỞ ĐẦU
1. Sự cần thiết của vấn đề nghiên cứu
Lập trình logic là một trong những phương pháp biểu diễn tri thức cung
cấp khả năng để khai báo tri thức. Lĩnh vực nghiên cứu về lập trình logic đã
phát triển mạnh mẽ trong những thập niên vừa qua. Lập trình logic đã chứng
tỏ thế mạnh về khả năng biểu diễn tri thức và được ứng dụng chủ yếu trong
lĩnh vực trí tuệ nhân tạo như cơng nghệ xử lý tri thức, máy học, hệ chuyên
gia, xử lý ngôn ngữ tự nhiên,… Hiện nay, một hướng mở rộng của lập trình
logic được gọi là lập trình tập trả lời (ASP) đã và đang được nhiều nhà khoa
học quan tâm. ASP có thể dùng để biểu diễn các dạng tri thức khác nhau của
thế giới thực. ASP được xem như một ngôn ngữ có ngữ nghĩa dạng khai báo
và cũng dựa trên ngữ nghĩa mơ hình bền vững của chương trình logic thông
thường, đã được chứng minh là rất phù hợp cho nhiều lĩnh vực ứng dụng.
ASP là một cách tiếp cận của lập trình khai báo. ASP đã được áp dụng trong
một số lĩnh vực quan trọng, chẳng hạn như việc chẩn đốn và lập kế hoạch
cho tàu khơng gian con thoi, lập luận đa tác tử, xử lý ngôn ngữ tự nhiên, …
Nhiều cơng trình nghiên cứu có giá trị về lập trình tập trả lời đã được
cơng bố. Hệ thống Clingo thường được sử dụng cho việc cài đặt và thực thi
đối với lớp chương trình logic với ngữ nghĩa tập trả lời. Tuy nhiên, các bộ
dịch chương trình ASP truyền thống thường không xử lý các vấn đề về thay
đổi và cập nhật thông tin đầu vào, chẳng hạn như bộ dịch chỉ lấy chương trình

đầu vào và cho ra kết quả là tập trả lời. Trong thực tế, có nhiều bài tốn mà
thơng tin thay đổi trong q trình xử lý bài tốn như các trị chơi, lập trình
robot … lúc đó nếu thơng tin thay đổi thì bộ dịch ASP sẽ cần dịch lại từ đầu.
Vấn đề này được Clingo 4 giải quyết bằng cách cho phép một thủ tục
kích hoạt lại khi có các u cầu thay đổi các thông tin ban đầu của bài toán.
Cụ thể là bổ sung cách tiếp cận khai báo của ASP bằng các phương thức thủ
3


tục, như Python hay Lua, để có thể xử lý thông tin cần thay đổi.
Python là một ngôn ngữ lập trình bậc cao, thơng dịch, hướng đối tượng,
đa mục đích, cú pháp của Python khá dễ học và ngôn ngữ này cũng mạnh mẽ
và linh hoạt không kém các ngôn ngữ khác trong việc phát triển các ứng
dụng. Trong luận văn này, chúng tơi nghiên cứu lập trình tập trả lời và sự tích
hợp của lập trình tập trả lời - lập trình thủ tục Python - ASP và ứng dụng giải
bài toán phổ biến Ricochet Robot.
Cấu trúc nội dung luận văn gồm phần mở đầu, bốn chương nội dung,
mô tả cài đặt, chạy chương trình, phần kết luận, hướng phát triển của đề tài và
phần tài liệu tham khảo.
2. Mục tiêu nghiên cứu
Nhằm nghiên cứu lập trình tập trả lời, sự tích hợp của lập trình tập trả
lời - lập trình thủ tục và ứng dụng giải bài tốn phổ biến Ricochet Robot.
3. Đối tượng và phạm vi nghiên cứu
3.1. Đối tượng nghiên cứu
Lập trình tập trả lời ASP và tích hợp với lập trình trình thủ tục.
3.2. Phạm vi nghiên cứu
Lập trình tập trả lời ASP với Clingo 4 tích hợp với lập trình trình thủ
tục Python để giải bài toán Ricochet Robot.
4. Nội dung nghiên cứu
- Các khái niệm cơ bản của lập trình logic;

- Lập trình tập trả lời: các khái niệm và ngữ nghĩa;
- Tích hợp lập trình tập trả lời Clingo với Python.
- Ứng dụng lập trình tập trả lời cho bài tốn Ricochet Robot.

4


5. Kết cấu của luận văn
• Phần mở đầu
• Chương 1. Chương trình logic tổng quát.
1.1 Một số định nghĩa
1.2 Phủ định trong chương trình logic
1.3 Biểu diễn tri thức trong logic tổng qt
• Chương 2. Lập trình tập trả lời ASP.
2.1 Các định nghĩa
2.2 Phủ định cổ điển
2.3 Cú pháp của chương trình logic mở rộng
2.4 Ngữ nghĩa tập trả lời ASP
2.5 Biểu diễn tri thức bằng chương trình logic mở rộng ASP
• Chương 3. Tích hợp lập trình tập trả lời Clingo với Python.
3.1 Ngơn ngữ lập trình Python
3.2 Phần mềm Clingo
3.3 Tích hợp lập trình tập trả lời Clingo với Python
• Chương 4. Cài đặt mơ phỏng ứng dụng lập trình tập trả lời cho bài
tốn Ricochet Robot.
4.1 Bài toán Ricochet Robot
4.2 Cài đặt và chạy demo ứng dụng
• Kết luận.
• Hướng phát triển của đề tài.
• Tài liệu tham khảo.

5


CHƯƠNG 1
CHƯƠNG TRÌNH LOGIC TỔNG QT
Logic tính tốn được các nhà logic học đưa ra vào những năm 1950, dựa
trên các kỹthuật tự động hóa q trình suy diễn logic. Logic tính tốn được
phát triển thành lập trình logic vào những năm 1970. Từ đó hình thành một
khái niệm quan trọng là lập trình khai báo (declarative programming) đối lập
với lập trình cấu trúc (procedural programming). Về ý tưởng, các lập trình
viên chỉ cần đưa ra khai báo của chương trình cịn việc thực hiện cụ thể do
máy tính tự xác lập, trong khi đó việc thực hiện các chương trình hướng thủ
tục lại được xác lập cụ thể bởi lập trình viên. Ngơn ngữ Prolog là một cơng
cụthực hiện rõ ý tưởng này. Nhờ khả năng khai báo tự nhiên của lập trình
logic, Prolog nhanh chóng trở thành một ứng cử viên cho việc biểu diễn tri
thức. Tính đầy đủ của nó trở nên rõ ràng hơn khi mối liên hệ giữa các chương
trình logic với cơ sở dữ liệu suy diễn được đưa ra vào giữa thập kỷ 80. Việc
sử dụng lập trình logic và cơ sở dữ liệu suy diễn để biểu diễn tri thức được gọi
là “cách tiếp cận logic cho việc biểu diễn tri thức”. Cách tiếp cận này dựa trên
ý tưởng là chương trình máy tính được cung cấp các đặc thù 4 logic của tri
thức trong đó, do đó nó độc lập với bất kỳ cách thực hiện riêng biệt nào, với
ngữ cảnh tự do, dễ dàng thao tác và suy diễn. Chính vì vậy, cú pháp của ngơn
ngữ lập trình phải kết hợp được bất kỳ chương trình nào với đặc thù khai báo
của nó. Khi đó, việc thực hiện các phương pháp tính tốn sẽ thơng qua so
sánh các thuộc tính cụ thể với cú pháp khai báo. Việc đưa ra một cú pháp
thích hợp cho các chương trình logic được coi nhưmột trong những lĩnh vực
nghiên cứu quan trọng nhất và khó nhất trong lập trình logic.
Đây là những kiến thức làm tiền đề cho các nghiên cứu về ngữ nghĩa của
chương trình logic với tập trả lời trong các chương tiếp theo.

6


1.1. Một số định nghĩa
Quan hệ và ánh xạ trong lập trình logic:

Quan hệ

Input

Ánh xạ

Output

Input

n:n

Output
n:1

Định nghĩa 1.1 (Bộ ký tự) Bảng chữ cái Α bao gồm các loại ký hiệu sau:
- Các biến
- Các hằng số đối tượng (có thể gọi là hằng số)
- Các ký hiệu hàm (function symbol) - Các ký hiệu vị từ (predicate
symbol)
- Các liên kết logic: “not”, “←” và “,”
- Các ký hiệu phân cách “(“ và “)”
Trong đó, not là liên kết logic được gọi là phủ định ngầm (negation as
failure); biến là xâu bất kỳ bao gồm các ký tự của bảng chữ cái và các chữ số,

được bắt đầu bằng chữ cái viết hoa; hằng số, ký hiệu hàm và ký hiệu vị từ là
các xâu bắt đầu bởi chữ cái viết thường. Thông thường, sử dụng các chữ cái p,
q,... cho các ký hiệu vị từ ; X, Y, Z,... cho các biến ; f, g, h,... cho các ký hiệu
hàm và a, b, c,... cho các hằng số.
Định nghĩa 1.2 (Hạng thức) Gọi A là bộ ký tự. Hạng thức được định
nghĩa đệ qui như sau:
(i)

Mỗi hằng trong A là một hạng thức,

7


(ii)

Mỗi biến trong A là một hạng thức,

(iii)

Nếu f là ký hiệu hàm n-ngôi trong A và t1,..,tn là các hạng thức

thì f(t1,...,tn) là một hạng thức,
(i)

Hạng thức chỉ được sinh ra bởi các quy tắc trên.

Một hằng được xem là ký hiệu hàm 0-ngôi. Hằng và biến là các hạng
thức nguyên tố, hạng thức nền là hạng thức không chứa biến.
Định nghĩa 1.3 (Nguyên tố) Một nguyên tố có dạng p(t1,…,tn), trong
đó p là ký hiệu vị từ n-ngơi và các đối t1,...,tn là các hạng thức. Nguyên tố

nền là nguyên tố không chứa biến.
Ta sẽ dùng A để ký hiệu một nguyên tố tùy ý khi ta không quan tâm đến
các đối của nó. Ta cũng định nghĩa một ngun tố đặc biệt, ký hiệu
nghĩa ln ln có giá trị đúng, và

với ý

để ký hiệu nguyên tố luôn ln có giá trị

sai.
Định nghĩa 1.4 (Cơng thức) Cơng thức được định nghĩa đệ qui như sau:
(i) Mỗi nguyên tố là một công thức,
(ii) Các hằng vị từ true và false là các công thức,
(iii) Nếu E và F là các cơng thức thì:

( E  F ) , (E ), ( E  F ) , ( E → F ) , ( E  F ) là các công thức,
(iv) Nếu E là công thức và X là một biến thì X ( E ), X ( E ) là các công
thức,
(iv)

Công thức chỉ được sinh ra bởi một số hữu hạn các quy tắc trên.

Định nghĩa 1.5 (Chương trình logic xác định) Chương trình logic xác định là
một tập hữu hạn khác rỗng các mệnh đề xác định có dạng:
A  B1,…, Bm

(m  0)

Ví dụ 1.1 Cho chương trình logic xác định P gồm các mệnh đề:
r1 : sochan(s(0))



8


r2 : sochan(s(s(X)))  sochan(X)
Trong chương trình này thì s là một hàm 1-ngôi, được xác định bởi
s(X) = X +1 với X  , nguyên tố sochan(X) để chỉ X là một số chẵn. Mệnh đề
đơn vị r1 có ý nghĩa là 0 một số chẵn và r2 là mệnh đề với ý nghĩa là nếu X là
số chẵn thì s(s(X)) cũng là số chẵn.
Định nghĩa 1.6 (Herbrand) Khơng gian xác định Herbrand biểu diễn
trên ngôn ngữ Λ của chương trình Π, ký hiệu là ( )HU Π, là tập tất cả các toán
hạng nền được biểu diễn với các hàm và hằng số trong Λ. Tập tất cả các
ngun tố nền trong ngơn ngữ của một chương trình Π được định nghĩa là (
)HB Π (cơ sở Herbrand của Π). Với một vị từ p, atoms(p) được định nghĩa là
tập con của HB Π được biểu diễn dưới dạng vị từ p và với một tập các vị từ
A, atoms(A) là một tập con các phần tử của ( )HB Π được biểu diễn dưới
dạng các vị từ thuộc A.
Ví dụ 1.2 Xét chương trình logic xác định P ở ví dụ 1.3:
Vũ trụ Herbrand của P là: UP = {0, s(0), s(s(0)), s(s(s(0))),...}
Cơ sở Herbrand của P là:
BP = {sochan(0), sochan(s(0)), sochan(s(s(0))),...}
Một số thể hiện Herbrand của P là:
I1 = {sochan(0)}
I2 = {sochan(0), sochan(s(0))}
I3 = {sochan(sn(0)) | n  {0, 2, 4,…}}
I4 = BP
Định nghĩa 1.7 (Hiện hành nền) Một tốn hạng được gọi là có tính chất
nền (ground) nếu khơng có biến nào xuất hiện trong nó.

1.2. Phủ định trong chương trình logic
Định nghĩa 1.8 (Chương trình logic thơng thường) Chương trình logic
thơng thường là một tập hữu hạn khác rỗng các mệnh đề có dạng:
9


a  b1,…,bm, not c1,…,not cn
trong đó n, m  0, a và bi, cj là các nguyên tố.
Chú ý rằng thân quy tắc chứa các lietral phủ định not c1,…,not cn. Giá trị
chân lý của literal phủ định là ngược với giá trị chân lý của litaral dương của
nó. Literal not a sẽ được xem là sai nếu giá trị chân lý của literal dương a
không được chứng minh một cách hữu hạn thông qua phép hợp giải SLD. Vì
vậy phủ định not cịn được gọi là phủ định do thất bại (negation as fairlure)
hoặc phủ định mặc định (default negation). Để ý rằng phép phủ định trong
logic cổ điển, còn gọi là phủ định mạnh (strong negation), ký hiệu , là khác
với phép phủ định not trong lập trình logic.
Định nghĩa 1.9 (Phép biến đổi Gelfond - Lifschitz) Cho P là chương
trình logic. Gọi ground(P) là hiện hành của P. Đối với mọi thể hiện M của P,
ký hiệu PM là chương trình nhận được từ ground(P) bằng cách loại bỏ:
1. Các quy tắc có literal phủ định not A trong thân của nó, với A  M.
2. Tất cả literal not A trong thân của các quy tắc còn lại.
Điều kiện 1 và 2 ở trên ấn định giá trị chân lý cho các literal phủ định.
Nếu A  M thì thân quy tắc có chứa literal not A không thể trở thành đúng.
Mặt khác, nếu A  M thì not A có thể giả sử là đúng và được loại bỏ khỏi
thân quy tắc chứa nó.
Rõ ràng PM là chương trình khơng có phủ định, nó là chương trình logic
dương, vì vậy PM có mơ hình nhỏ nhất LM(PM)
Ví dụ 1.3 Cho P là chương trình logic:
x  not b
y  not x

z  x, not y
Xét thể hiện M1 = {x, z} và M2 = {y}. Thu gọn P M1 gồm các quy tắc:

10


x
zx
và mơ hình nhỏ nhất của P M1 chính là {x,z}.
Xét thể hiện M1 = {x, z} và M2 = {y}. Thu gọn P M 2 gồm 1 quy tắc:
y
và mơ hình nhỏ nhất của P M 2 chính là {y}
1.3. Biểu diễn tri thức trong chương trình logic tổng quát
Trong phần này sẽ đưa ra một số ví dụ về cách sử dụng chương trình
logic tổng quát cho việc biểu diễn tri thức và suy diễn thông thường. Việc
chứng minh gắn với phương thức sử dụng chương trình logic tổng qt để
hình thức hóa các câu nói chuẩn, tức là các câu sử dụng cách nói “A thơng
thường là B”. Các câu nói dạng này thường được sử dụng trong các kiểu khác
nhau của suy diễn thông thường. Giả thiết một đại lý có một số thơng tin sau
về loài chim: Đặc trưng của loài chim là biết bay và cánh cụt là lồi chim
khơng biết bay. Ta cũng được biết rằng Tweety là một con chim và được th
đóng một cái chuồng chim cho nó nhưng sẽ khơng xây mái vì khơng biết
được rằng Tweety có biết bay hay khơng biết bay. Đó sẽ là lý do để nói rằng
sản phẩm của đại lý có giá trị hay khơng. Trong trường hợp Tweety khơng thể
bay vì một số lý do nào đó (mà đại lý khơng được biết) và đại lý vẫn quyết
định làm cái mái cho chuồng chim thì ta có quyền từ chối trả tiền vì sự khơng
cần thiết đó. Ví dụ sau sẽ đưa ra cách biểu diễn thơng tin trên bằng chương
trình logic tổng qt.
Ví dụ 1.4 Xem xét một chương trình Β bao gồm các luật sau:
1. flies (X) ← bird (X), not ab(r1, X).

2. bird (X) ← penguin (X).
3. ab(r1, X) ← penguin (X).

11


4. make_top (X) ← flies (X).

cùng với các thực tế về loài chim:
f1. bird(tweety).
f2.penguin(sam).
Hầu hết các tên của vị từ trong ví dụ này đều có ý nghĩa riêng. r1 là hằng số
trong ngơn ngữ của chương trình, dùng để gán tên cho luật 1 và phần tử
ab(r1,X) được sử dụng cho lồi chim khơng chắc chắn về khả năng biết bay
(tức là không thể sử dụng luật 1). Luật đầu tiên mơ tả một câu nói thơng
thường lồi chim là biết bay (những câu nói loại này được gọi là giả thiết
ngầm định – default assumptions,hoặc chỉ là ngầm định – default). Nó cho
phép ta kết luận con chim X biết bay trừ khi ta có thể chỉ ra được trường hợp
đặc biệt. Luật 3 được sử dụng để đưa ra trường hợp đặc biệt là chim cánh cụt,
được gọi là luật khử (cancellation rule). Tổng quát, câu nói thơng thường có
dạng “a thơng thường là b” được biểu diễn theo luật sau:
b (X) a (X), not ab (r, X)
trong đó r là hằng số của ngơn ngữ là tên của một luật trong chương trình.
Tương tự, trường hợp đặc biệt của câu nói thơng thường có dạng “c là trường
hợp ngoại lệ của a, c không là b”, được biểu diễn như sau:
ab (r, X) ← c (X)
Trường hợp đặc biệt của loại này được gọi là ngoại lệ mạnh (strong
exception). Dễ dàng nhận thấy rằng một chương trình tổng quát Β bao gồm
các luật từ 1 đến 4 và các sự kiện f1 và f2 có tính chất phân tầng, khi đó
chương trình sẽ có duy nhất một mơ hình ổn định. Sử dụng bổ đề 1.4 để tìm

câu trả lời cho một số truy vấn về khả năng biết bay của các loài chim khác

12


nhau. Ta sẽ bắt đầu với truy vấn flies(tweety). Đặt S là mơ hình ổn định của
B. Do đó, flies(tweety) S∈ khi và chỉ khi:
(i) bird(tweety) ∈ S và
(ii) ab (r, tweety) ∉ S.
Ta có được điều kiện (i) dựa trên sự kiện f1 và bổ đề. Để chứng minh (ii), ta
cần có penguin(tweety) ∉ S được suy ra từ bổ đề. Khi đó, sử dụng (i) và (ii),
cùng với luật 1, và phần đầu của bổ để, ta có flies(tweety)∈ S. Vậy câu trả lời
cho truy vấn flies(tweety) là đúng. Tương tự như vậy, ta có câu trả lời cho
truy vấn flies(sam) là sai.
Phép ánh xạ thời gian (temporal projection), trong đó có mơ tả trạng
thái khởi tạo ban đầu và mô tả hiệu quả của các hành động. Ta sẽ phải quyết
định trạng thái cuối cùng sẽ như thế nào sau khi thực hiện một chuỗi các hành
động đó. Một ví dụ thường được đưa ra nhất cho dạng suy diễn này là bài
tốn Bắn chính xác (Yale Shooting Problem - YSP). Cú pháp của ngôn ngữ
bao gồm ba loại biến: biến trạng thái S, S’, ..., biến chính xác F, F’, ..., và biến
hành động A, A’, ... Chỉ có một biến trạng thái hằng số là s0, và res(A, S)
định nghĩa một trạng thái mới thu nhận được sau khi thực hiện hành động A ở
trạng thái S, hold(F, S) có nghĩa là sự chính xác F là đúng ở trạng thái S.
Ngồi ra cịn có một số ký hiệu vị từ và chức năng khác.

13


CHƯƠNG 2
LẬP TRÌNH TẬP TRẢ LỜI ASP

Chương 2 trình bày cú pháp và ngữ nghĩa của lớp chương trình logic
mở rộng (ASP). Ngữ nghĩa của lớp chương trình này được thực hiện theo tiếp
cận của lý thuyết mơ hình và được xác định bởi các tập trả lời của nó. Các ví
dụ được minh họa và biểu diễn tri thức bằng chương trình logic mở rộng.
Những ví dụ này được giải thích chi tiết nhằm thể hiện bước đầu về tính ứng
dụng của lớp chương trình này. Ngữ nghĩa đối với lớp chương trình này được
thực hiện theo kiểu tiếp cận của lý thuyết mơ hình và là sự mở rộng của ngữ
nghĩa mơ hình bền vững đã đề cập trong chương 1.
Lập trình tập trả lời được thực hiện theo mơ tả sau:

Hình 2.1.1
Lập trình tập trả lời ASP là một hình thức lập trình khai báo hướng tới
các vấn đề, là sự phát triển của nghiên cứu trong biểu diễn tri thức, được phát
triển dựa trên mơ hình ổn định của chương trình logic nhưng Prolog lại khơng
phù hợp với ASP. Các chương trình ASP bao gồm các quy tắc giống như quy
tắc Prolog, các cơ chế tính tốn được sử dụng trong ASP là khác nhau, nó đưa
ra giải pháp thỏa mãn cho mệnh đề logic. Hệ thống ASP gồm Clingo, Smodel,
DLV … Trong ASP, các vấn đề tìm kiếm được giảm xuống để tính tốn mơ
hình ổn định mơ hình và trả lời bộ giải mã - chương trình để tạo mơ hình ổn
định được sử dụng để thực hiện tìm kiếm.

14


Hệ thống LPARSE ban đầu được tạo dưới dạng giao diện người dùng
cho tập trả lời bộ giải mã SMODELS. Một số quy tắc được tìm thấy trong các
chương trình LPARSE truyền thống như:
p: - q.
hoặc
q: - not r.

Dữ liệu đầu vào của LPARSE có thể bao gồm cả quy tắc như {s, t}: - p. Quy
tắc này có nghĩa là: nếu p được bao gồm trong ổn định trên, hãy chọn tùy ý
các nguyên tử s, t để thõa mãn quy tắc. Nếu hướng dẫn SMODELS tìm tất cả
các mơ hình ổn định của chương trình P bao gồm cả ba quy tắc được hiển thị
ở trên, sẽ tạo ra kết quả sau:
Answer: 1
Stable Model:
Answer: 2
Stable Model:
Answer: 3
Stable Model:
Answer: 4
Stable Model:

p q
t p q
s p q
s t p q

Ràng buộc là một quy tắc với đầu rỗng, ví dụ như : - s, not t. Việc thêm một
ràng buộc vào một chương trình là loại bỏ một số mơ hình ổn định của nó. Ví
dụ: ràng buộc ở trên không tạo ra s nếu t không được tạo ra. Thêm mục này
ràng buộc với P ở trên sẽ loại trừ câu trả lời số 3.
2.1. Các định nghĩa
Mỗi chương trình logic được xây dựng từ các thuật ngữ. Tổng quan về
các thuật ngữ gringo được mơ tả trong hình 2.1.2

15

Hình 2.1.2
Các thuật ngữ cơ bản nhất là số nguyên, hằng số và các biến. Ngồi ra cịn có
một số hằng số và biến đặc biệt.
Định nghĩa 2.1 Một chương trình logic là một tập luật có dạng:
A ← B1,...,Bm, not C1,...,not Cn (m  0, n  0)

Với A,B,C là các phần tử, là biểu diễn cho p hoặc p¬, với p là một ngun tố.
Ví dụ 2.1 Tìm tập trả lời cho các mệnh đề logic sau:
p :- not q.
16


r :- p.
s :- r, not p.
Tập trả lời của các mệnh đề trên là {p, r}
Ví dụ 2.2 Tìm tập trả lời cho các mệnh đề logic sau:
p :- q.
p :- r.
q :- not r.
r :- not q.
Tập trả lời của các mệnh đề trên là {p, q} và {p, r}.
Định nghĩa 2.2 (Mơ hình ổn định) Một mơ hình của một cơng thức
mệnh đề F được coi là "ổn định" khi nó cung cấp một ngữ nghĩa cho các
chương trình ASP căn cứ theo hai quy ước sau:
- Xử lý các quy tắc và chương trình khơng có biến số, các mệnh đề
được viết bằng ký hiệu của lập trình logic.
- Xác định bất kỳ X nguyên tử nào được thiết lập với sự phân công sự
thật làm cho tất cả các yếu tố của X đúng và làm cho tất cả các nguyên tử
khác sai.
Việc rút gọn FX của mệnh đề công thức F liên quan đến một tập X của

nguyên tử là công thức thu được từ F bằng cách thay thế mỗi công thức phụ
tối đa khơng hài lịng bởi X với ⊥. X là một mơ hình ổn định của F nếu X là
tối thiểu trong số các bộ thỏa mãn FX. Mức độ tối thiểu của X được hiểu ở đây
trong ý nghĩa của việc đưa vào bộ: khơng có tập hợp con X phù hợp nào thỏa
mãn FX. Mỗi bộ là một mơ hình ổn định của F theo để định nghĩa này là một
mơ hình của F. Thật vậy, nếu X khơng thỏa mãn F rồi FX là ⊥.
Ví dụ 2.3 Cho mơ hình: (q → p) ∧ (¬r → q) ∧ (p → ((s ∨ ¬s) ∧ (t ∨ ¬t)))

17


để kiểm tra {p, q, s} là một mơ hình ổn định của mơ hình trên chúng ta lấy
phần rút gọn của mơ hình so với tập hợp đó như: (q → p) ∧ (¬⊥ → q) ∧ (p
→ ((s ∨ ⊥) ∧ (⊥ ∨ ¬⊥))) hoặc (q → p) ∧ q ∧ (p → s), và chứng minh
rằng {p, q, s} là tối thiểu trong số các mơ hình của nó.
Các ràng buộc dùng để kiểm tra tính chấp nhận được của các mơ hình,
ta có định nghĩa sau:
Định nghĩa 2.3 (Ràng buộc) Một ràng buộc toàn vẹn là mệnh đề có
dạng sau:
false  B1,…,Bm
trong đó Bi là các literal, hằng vị từ false có thể bỏ qua.
Ví dụ 2.4 Ràng buộc  yes(X), no(X) để chỉ X chỉ câu trả lời của X chỉ có thể
là có hoặc khơng.
2.2. Phủ định cổ điển (phủ định mạnh)
Chương trình logic cho phép phủ định mặc định (not) xuất hiện trong
các thân quy tắc. Ngữ nghĩa tự nhiên của not a là “nếu a không thể được
chứng minh là đúng bằng cách dùng các quy tắc thì mặc định not a được
xem là đúng”. Nhưng điều này là khác với “biết chắc rằng a sai” và được biểu
diễn bởi a. Ta xem ví dụ sau để phân biệt giữa phủ định mạnh và phủ định
mặc định:

Ví dụ 2.5 Ví dụ có quy định: “Tại vị trí đường sắt giao nhau, có thể đi bộ qua
đường sắt nếu khơng có chuyến tàu nào đến” và có đối tượng X đang đứng ở
vị trí đường sắt giao nhau Y nào đó, X muốn đi bộ băng qua đường sắt. Có thể
mã hóa điều này bằng hai quy tắc sau:
dibo  vitri(X,Y), duongsat(Y), not tauhoa(Y)

(a)

dibo  vitri(X,Y), duongsat(Y),  tauhoa(Y)

(b)

18


Nếu sử dụng quy tắc (a) thì X khơng nghĩ rằng tauhoa(Y) là đúng, lúc
đó A sẽ quyết định đi bộ băng qua đường sắt mặc dù X không biết chắc là
khơng có chuyến tàu nào đến. Tri thức của X có thể cập nhật lại, nếu ta thêm
vào sự kiện tauhoa(Y) đúng thì X sẽ từ chối đi bộ qua đường sắt.
Cịn nếu dùng quy tắc (b) thì X chỉ có thể đi bộ băng qua đường sắt nếu
X biết chắc chắn là khơng có chuyến tàu nào đến. Rõ ràng việc quyết định của
X sẽ “an toàn” khi dùng quy tắc (b). Tuy nhiên quy tắc (a) lại phản ánh rõ
ràng về tri thức của X là không thể biểu diễn trạng thái của thế giới một cách
đầy đủ.
Ví dụ 2.6 Xét một chương trình logic gồm các sự kiện sau:
1 bird(tux). penguin(tux).
2 bird(tweety). chicken(tweety).
3 flies(X) :- bird(X), not -flies(X).
4 -flies(X) :- bird(X), not flies(X).
5 -flies(X) :- penguin(X).

6 :- flies(tux), -flies(tux).
7 :- flies(tweety), -flies(tweety).
Chương trình logic trên chứa ràng buộc vẹn tồn ở dịng 6 và 7.
Phủ định cổ điển có thể được xử lý bởi các chương trình bình thường bằng
cách:
- Xem ¬A như một ngun tử mới (renaiming)
- Thêm ràng buộc ← A, ¬A
Ví dụ 2.7 Xét một chương trình logic
p :- not q'
q' :- not p
:- p, p'
:- q, q'
19


Ta có câu trả lời (q’)

2.3. Cú pháp của chương trình logic mở rộng
Chương trình ASP mở rộng có hai nhiệm vụ chính là xử lí dữ liệu phức
tạp và tìm kiếm. Chính vì vậy cấu trúc của nó cũng gồm 2 phần:
- Lớp xử lý dữ liệu: gồm các mệnh đề để giải quyết các mơ hình.
- Lớp tìm kiếm: sử dụng các thủ tục tìm kiếm chuyên dụng.
Các điều kiện cho phép tạo biến, biến thành tập hợp các thuật ngữ trong
một quy tắc duy nhất. Ký hiệu : được sử dụng để xây dựng các điều kiện. Một
literal điều kiện  có dạng:

L: A

trong đó L là literal, gọi là literal chính và A là nguyên tố, gọi là điều kiện.
Ý nghĩa của literal điều kiện là nếu A đúng thì L nhận được và nếu ngược

lại thì L được bỏ qua. Một literal điều kiện nền về cơ bản tương đương với
một hội L  A.
Ví dụ 2.8 Chương trình sử dụng các điều kiện
1 person(jane). person(john).
2 day(mon). day(tue). day(wed). day(thu). day(fri).
3 available(jane) :- not on(fri).
4 available(john) :- not on(mon), not on(wed).
5 meet :- available(X) : person(X).
6 on(X) : day(X) :- meet.
2.4 Ngữ nghĩa tập trả lời ASP
Dạng ngữ nghĩa mơ hình hồn hảo của chương trình logic tổng qt có
thể được mở rộng để định nghĩa cho ngữ nghĩa mơ hình hồn hảo của chương
trình logic mở rộng. Đặt

. Với mọi chương trình logic mở

20


rộng Π bất kỳ, các điểm cố định của

định nghĩa cho ngữ nghĩa tập trả lời

định nghĩa cho ngữ nghĩa mơ hình hồn hảo. Một

và

phần tử l là đúng (hoặc sai) trong ngữ nghĩa mơ hình hồn hảo của một
chương trình logic mở rộng Π nếu

. Ngược

lại, l là khơng xác định.
Ví dụ 2.9 Xét chương trình Π0:
a ←not b
b ←not a
¬a
Ngữ nghĩa mơ hình hồn hảo sẽ suy ra a¬ là đúng và a và b là khơng xác định.
Về mặt cảm tính, phải được kết luận b là đúng và a là sai.
Ví dụ 2.10 Xét chương trình Π1: .
b ← not ¬b
và chương trình Π2:
a ← not ¬a
¬a ← not a
Ngữ nghĩa mơ hình hồn hảo kết luận b là đúng trong Π1 và b là không xác
định trong Π1 ∪Π2 cho dù Π2 không chứa b trong ngơn ngữ của nó.
Định nghĩa 2.4 Cho P là chương trình logic mở rộng, khơng chứa ký hiệu
phủ định not và X là một tập các litral nền của P. X được gọi là tập trả lời của
P nếu X là tập cực tiểu trong tập các tập đóng của P.
Rõ ràng mọi chương trình logic mở rộng mà khơng chứa phủ định mặc
định sẽ có nhiều nhất một tập trả lời. Các định nghĩa sau để mở rộng định
nghĩa trên đối với chương trình logic tùy ý.

21


Định nghĩa 2.5 Cho P là chương trình logic mở rộng, X là một tập các litral
nền. Lúc đó l  lit(P) là đúng trong X nếu l  X; l là sai trong X nếu

;

ngược lại l là chưa biết. False là sai trong X.
Ngữ nghĩa tập trả lời của chương trình logic mở rộng P là một tập các
tập trả lời, đó là một tập nhất quán các literal nền của P. Định nghĩa chính xác
các tập trả lời sẽ được thực hiện trước hết đối với chương trình logic mở rộng
khơng chứa phủ định mặc định not. Ta nói rằng một tập các literal nền X của
P là đóng trong P nếu với mọi quy tắc head  body của P thì head đúng
trong X khi body đúng trong X.
Định nghĩa 2.6 Một chương trình logic mở rộng (ELP) là một tập hữu hạn
các quy tắc có dạng:
l0  l1,...,lm, not lm+1,...,not ln
trong đó n  1, l0 là literal hoặc false và tất cả các li là các literal, not là ký
hiệu của phủ định mặc định. Literal mở rộng là một biểu diễn có dạng l hoặc
not l. Trong quy tắc trên nếu l0 là false thì nó được gọi là một ràng buộc và
false có thể bỏ qua.
Trừ khi có quy định khác, ta giả sử các literal trong quy tắc l0 
l1,...,lm, not lm+1,...,not ln đều là literal nền.
Trong chương 2 sử dụng một số ký hiệu sau đây:
là ngược của literal l.
Tập{not li,...,not li+k} được ký hiệu not {li,...,li+k}. Nếu r là quy tắc có
dạng l0  l1,...,lm, not lm+1,...,not ln thì:
head(r) = {l0},
pos(r) = {l1,...,lm},
neg(r) = {lm+1,...,ln},
body(r) = pos(r), not neg(r).
22


Với P là chương trình logic mở rộng thì:
head(P) =∪rP head(r),

pos(P) =∪rP pos(r),
neg(P) =∪rP neg(r).
lit(P) là tập tất cả các literal nền được xây dựng từ các vị từ trong P
Định nghĩa 2.7 Cho P là chương trình logic mở rộng bất kỳ, X là tập các
literal nền của P. Thu gọn của P theo X, ký hiệu PX là tập các quy tắc:
l0  l1,...,lm
đối với mọi quy tắc có dạng (1) của P sao cho lm+1,...,ln  X.
Như vậy PX là chương trình khơng chứa phủ định mặc định.
Định nghĩa 2.8 Cho P là chương trình logic mở rộng và X là một tập các
litral nền của P. X được gọi là tập trả lời của P nếu X là tập trả lời của chương
trình thu gọn PX.
Định nghĩa 2.9 Chương trình logic P suy dẫn literal nền l, ký hiệu P

l, nếu

l thuộc mọi tập trả lời của P. Câu trả lời của P đối với truy vấn l là Yes nếu P
l, no nếu P

, ngoài ra là unknown.

Định nghĩa này còn được xem là giả thiết thế giới đóng (CWA) đối với
chương trình logic mở rộng.
Ví dụ 2.11 Xem chương trình logic P như sau:
p(a)  not q(a)
p(b)  not q(b)
q(a)
Dùng định nghĩa của tập trả lời, dễ thấy P chỉ có một tập trả lời là S =
{q(a), p(b)}. Như vậy đối với truy vấn q(a) thì câu trả lời là yes và truy vấn
q(b) là unknown.

23


Nếu ta thêm vào chương trình P quy tắc sau:
q(X)  not q(X)
thì đối với chương trình mới này sẽ có tập trả lời là S = {q(a), q(b),
p(b)}, như vậy câu trả lời đối với truy vấn q(b) là trở thành no.
Một chương trình có thể có nhiều hơn một tập trả lời hoặc khơng có tập
trả lời nào cả.
Ví dụ 2.12 Các chương trình sau khơng có tập trả lời:
P1 = { p  not p}, P2 = {p, p}
Ví dụ 2.13 Xem chương trình sau:
p(a)

 not  p(a)

 p(a)  not p(a)
Chương trình này có hai tập trả lời là {p(a)} và {p(a)}. Như vậy P
không thể suy dẫn literal p(a).
2.5. Biểu diễn tri thức bằng chương trình logic mở rộng ASP
Ví dụ 2.14 Xét lại ví dụ 1.4 trong chương 1, ta đã biết loài chim thông thường
biết bay, nhưng cánh cụt là ngoại lệ của luật này, chim cánh cụt không biết
bay. Ta hãy xem làm thế nào để biểu diễn các thông tin này bởi ngơn ngữ của
chương trình logic mở rộng. Chú ý rằng, Β trong ví dụ 1.6 khi được coi là
chương trình logic mở rộng thì khơng thể trả lời là sai đối với các truy vấn
penguin (tweety) và flies (sam) được nữa. Để biểu diễn các thơng tin được
chính xác, ta cần mô tả giả thiết thế giới thực theo ngơn ngữ của chương trình
logic mở rộng, bằng cách thêm vào Β các luật sau:
c1. ¬ bird (X) ← not bird (X)
c2. ¬ penguin (X) ← not penguin (X)

c3. ¬ flies (X) ← not flies (X)

24