**Prolog** là một ngôn ngữ lập trình. Tên gọi Prolog được xuất phát từ cụm từ tiếng Pháp *Programmation en logique*, nghĩa là "lập trình theo lô gíc". Xuất hiện từ năm 1972 (do Alain Colmerauer và Robert Kowalski thiết kế), mục tiêu của Prolog là giúp người dùng mô tả lại bài toán trên ngôn ngữ của logic, dựa trên đó, máy tính sẽ tiến hành suy diễn tự động dựa vào những cơ chế suy diễn có sẵn (hợp nhất, quay lui và tìm kiếm theo chiều sâu) để tìm câu trả lời cho người dùng.

Prolog được sử dụng nhiều trong các ứng dụng của trí tuệ nhân tạo và ngôn ngữ học trong khoa học máy tính (đặc biệt là trong ngành xử lý ngôn ngữ tự nhiên vì đây là mục tiêu thiết kế ban đầu của nó). Cú pháp và ngữ nghĩa của Prolog đơn giản và sáng sủa, nó được người Nhật coi là một trong những nền tảng để xây dựng máy tính thế hệ thứ năm mà ở đó, thay vì phải mô tả cách giải quyết một bài toán trên máy tính, con người chỉ cần mô tả bài toán và máy tính sẽ hỗ trợ họ nốt phần còn lại.

Cú pháp
-------

Một chương trình Prolog bao gồm các luật được biểu diễn dưới dạng mệnh đề Horn. Một mệnh đề Horn có dạng

```
Head:-Body.
```

Head là một vị từ logic, còn Body có thể là rỗng hoặc là một tập các vị từ logic. Ví dụ như sau:

```
chẵn(X):- X chia_dư 2 = 0.
```

Phần lớn các bộ dịch của các chương trình Prolog đều yêu cầu vị từ logic ở phần đầu của một mệnh đề Horn là một vị từ dương (không có dấu phủ định đi kèm), còn các vị từ trong phần Body có thể có dấu phủ định đi kèm. Chương trình logic mà không có sự xuất hiện của dấu phủ định đi kèm gọi là chương trình logic xác định, còn không thì được gọi là chương trình logic thường.

### Dữ kiện

Dữ kiện là những mệnh đề Horn mà phần Body là rỗng. Kiểu mệnh đề này thường được sử dụng để mô tả các dự kiện của bài toán, ví dụ như việc khai báo "tôm" là một con mèo:

```
mèo(tôm).
```

Khoảng cách từ Hà Nội vào thành phố Hồ Chí Minh là khoảng 2000Km:

```
khoảng_cách(Hà_Nội,TP_Hồ_Chí_Minh,2000).
```

### Luật

Phần còn lại của các mệnh đề trong một chương trình Prolog được gọi là luật. Nó thường thể hiện những phát biểu logic trong bài toán, ví dụ như nếu công tắc đèn bật thì đèn sáng:

```
đèn_sáng(X):- công_tắc_bật(X).
```

Toán tử ":-" được dịch thô là "nếu", trong logic thì nó đại diện cho toán tử suy ra "<-". Phát biểu trên được phát biểu dưới dạng văn xuôi là "Nếu công tắc của đèn X bật thì đèn X sẽ sáng". Tất nhiên, bạn có thể chưa thoả mãn với phát biểu này và bổ sung vào nó để có một phát biểu chặt chẽ hơn:

```
đèn_sáng(X):- công_tắc_bật(X), có_điện.
```

Dấu phẩy "," trong mệnh đề trên được dịch là toán tử "và"; biến trong Prolog được quy ước bắt đầu là một chữ cái hoa.

Ngữ nghĩa
---------

Một chương trình logic có ngữ nghĩa của riêng nó. Ngữ nghĩa quyết định những kết luận "đúng" nào có thể rút ra được từ một chương trình Prolog. Ví dụ một chương trình Prolog gồm một dữ kiện:

```
mèo(tôm).
```

Khi đó, ta có thể rút ra duy nhất một dữ kiện đúng là "tôm là một con mèo". Trong một ứng dụng Prolog, bạn có thể hỏi một trong hai câu hỏi sau để có được trả lời đúng:

```
?- mèo(tôm).
yes.
```

Và

```
?- mèo(X).
X = tôm;
no.
```

Trong ví dụ trên, "no" có nghĩa là không còn câu trả lời nào nữa. Mọi câu hỏi khác đều cho trả lời là sai. Điều này có nghĩa là trong một chương trình Prolog, người ta sử dụng giả thiết thế giới đóng, mọi thứ bạn khai báo là đúng, nếu không thì nó là sai. Vì vậy trong ví dụ trên, khi bạn hỏi "mitu có phải là một con mèo hay không", bạn sẽ nhận được câu trả lời "no".

Với một chương trình Prolog xác định, ngữ nghĩa của nó được định nghĩa là một mô hình tối thiểu của nó.

Với một chương trình Prolog bình thường, có nhiều loại ngữ nghĩa được sử dụng như ngữ nghĩa đầy đủ, ngữ nghĩa tối thiểu, ngữ nghĩa hoàn chỉnh,...

Đa số các chương trình biên dịch Prolog phổ thông (SWI-Prolog, GNU-Prolog) sử dụng ngữ nghĩa đầy đủ mà đi kèm là thủ tục suy diễn SLDNF.

Ví dụ
-----

Phần này trình bày một số chương trình ví dụ, nó có thể chạy tốt trong SWI-PROLOG.

### QuickSort

```
split(H, [A|X], [A|Y], Z):-
 order(A, H), split(H, X, Y, Z).
split(H, [A|X], Y, [A|Z]):-
 not(order(A, H)), split(H, X, Y, Z).
split(_, [], [], []).
quicksort([], X, X).
quicksort([H|T], S, X):-
 split(H, T, A, B),
 quicksort(A, S, [H|Y]),
 quicksort(B, Y, X).
```

### Tháp Hà Nội

```
hanoi(N):- move(N, left, centre, right).
move(0, _, _, _):-!.
move(N, A, B, C):-
 M is N-1,
 move(M, A, C, B), inform(A, B), move(M, C, B, A).
inform(X, Y):-
 write([move, a, disc, from, the, X, pole, to, the, Y, pole]),
 nl.
```

### Đại số

```
/* Tính đạo hàm */
d(X,X,1):-!.  /* d x dx = 1  */
d(C,X,0):- atomic(C).   /* d c dx = 0  */
d(-U,X,-A):- d(U,X,A).   /* d -u  dx = - d u dx   */  
d(U+V,X,A+B):- d(U,X,A), d(V,X,B). /* d u+v  dx = d u dx + d v dx  */
d(U-V,X,A-B):- d(U,X,A), d(V,X,B). /* d u-v  dx = d u dx - d v dx  */
d(C*U,X,C*A):- atomic(C), C \= X, d(U,X,A),!.  /* d c*u  dx = c*d u dx   */
d(U*V,X,B*U+A*V):- d(U,X,A), d(V,X,B). /* d u*v  dx = u*d v dx + v*d u dx  */ 
d(U/V,X,A):- d(U*V^(-1),X,A). /* d u/v  dx = d (u*v)^-1 dx   */
d(U^C,X,C*U^(C-1)*W):- atomic(C), C \= X, d(U,X,W). /* d u^c  dx = c*u^(c-1)*d u dx */
d(log(U),X,A*U^(-1)):- d(U,X,A).  /* d ln(u) dx = u^-1 * d u dx   */
```

```
/* Tính tích phân */
i(0,X,0):-!.  /* Int 0  dx = 0  */
i(X,X,(X*X)/2):-!.    /* Int X  dx = (X^2)/2 */
i(C,X,C*X):- atomic(C).  /* Int c  dx = c*x */
i(-U,X,-A):- i(U,X,A).   /* Int -U dx = - Int U dx  */
i(U+V,X,A+B):- i(U,X,A), i(V,X,B). /* Int U+V dx = Int U dx + Int V dx  */ 
i(U-V,X,A-B):- i(U,X,A), i(V,X,B). /* Int U-V dx = Int U dx - Int V dx  */
i(C*U,X,C*A):- atomic(C), C \= X, i(U,X,A),!.  /* Int cU dx = c (Int U dx)   */
i(X^C,X,(X^(C+1))/(C+1)):- atomic(C),!.   /* Int x^c dx = x^(c+1)/(c+1)   */
i(U,V,U*V-A):- d(V,U,A),!.  /* Int u  dv = u*v - Int v du  */
```

```
/* Một số luật đơn giản */
s(+,X,0,X).  /* x + 0 = x  */
s(+,0,X,X).  /* 0 + x = x  */
s(+,X,Y,X+Y).    /* x + y = x + y  */
s(+,X,Y,Z):- integer(X), integer(Y), Z is X+Y.  /* x + y = z   <- Calculate */
s(*,_,0,0).  /* anything * 0 = 0 */
s(*,0,_,0).  /* 0 * anything = 0 */
s(*,1,X,X).  /* 1 * x = x  */
s(*,X,1,X).  /* x * 1 = x  */
s(*,X,Y,X*Y).    /* x * y = x * y  */
s(*,X*Y,W,X*Z):- integer(Y), integer(W), Z is Y*W.  
s(*,X,Y,Z):- integer(X), integer(Y), Z is X*Y.  /* x * y = z   <- Calculate */
```

```
/* Đơn giản hoá */
simp(E,E):- atomic(E),!.
simp(E,F):- E =.. [Op, La, Ra], simp(La,X), simp(Ra,Y), s(Op,X,Y,F).
```

Bảng so sánh
------------

**Comparision of Prolog Implementations**| Nền tảng | Tính năng | Bộ công cụ | Cơ chế Prolog |
| --- | --- | --- | --- |
| Tên | HĐH | Giấy phép | Đồ hoạ | Unicode | Điều khiển | Chạy một mình | Giao diện với C\* | Giao diện với Java\* | Trình biên dịch tương tác | Gỡ rối | Code Profiler | Cú pháp |
| DOS-PROLOG | MS-DOS | Shareware | TRUE | TRUE | TRUE | TRUE |  |  |  | TRUE |  | Edinburgh Prolog |
| Open Prolog | Mac OS | Freeware |  |  |  |  |  |  |  | TRUE |  |  |
| Ciao Prolog | Unix, Windows | GPL |  |  |  | TRUE | TRUE | TRUE | TRUE | TRUE |  | ISO-Prolog |
| GNU Prolog | Unix, Windows | GPL |  |  | TRUE | TRUE | TRUE |  | TRUE | TRUE |  | ISO-Prolog |
| SWI-Prolog | Unix, Windows, Mac OS X | LGPL | TRUE | TRUE |  | TRUE | TRUE | TRUE | TRUE | TRUE | TRUE | ISO-Prolog, Edinburgh Prolog |

\*Giao diện với C/Java cũng có thể được sử dụng cho đồ hoạ và các điều khiển.

Xem thêm
--------

* HiLog và λProlog mở rộng Prolog với các tính năng bậc cao.
* InterProlog, Bộ thư viện cho phép kết nối giữa Java và Prolog. Hỗ trợ XSB, SWI-Prolog và YAP.
* Prova Prolog có tích hợp Java cho phép người dùng kết hợp cú pháp và thư viện của Java trong Prolog.

Tham khảo
---------

Liên kết ngoài
--------------

**Wikibooks Programming** có thông tin Anh ngữ về:
***Prolog***

### Một số cài đặt

* WIN Prolog Lưu trữ 2005-02-06 tại Wayback Machine của Logic Programming Associates
* Open Prolog, cài đặt cho Apple Mac.
* Ciao Prolog, mã mở tuân theo GPL và LGPL
* GNU Prolog, hoặc gprolog, mã mở tuân theo GPL
* YAP Prolog Lưu trữ 2004-07-06 tại Wayback Machine, mã mở tuân theo Artistic License
* SWI-Prolog, mã mở tuân theo LGPL
* SICStus Prolog, một phiên bản thương mại, có hỗ trợ lập trình ràng buộc
* ECLiPSe Prolog Lưu trữ 2017-08-14 tại Wayback Machine một phiên bản thương mại
* XSB, mã mở tuân theo LGPL

### Hướng dẫn học

* Prolog Tutorial Lưu trữ 2016-03-03 tại Wayback Machine by J.R.Fisher
* Visual Prolog Tutorial Lưu trữ 2005-03-22 tại Wayback Machine
* Runnable examples by Lloyd Allison
* Visual Prolog Examples Lưu trữ 2005-05-29 tại Wayback Machine
* Logic Programming and Prolog (2ed) by Ulf Nilsson and Jan Maluszynski
* Prolog Programming A First Course Lưu trữ 2006-04-06 tại Wayback Machine by Paul Brna
* Adventure in Prolog, online book by Amzi! Inc.
* On-line guide to Prolog Programming by Roman Bartak
* Learn Prolog Now! Lưu trữ 2007-08-19 tại Wayback Machine by Patrick Blackburn, Johan Bos and Kristina Striegnitz

### Lập trình nâng cao

* Richard O'Keefe, *The Craft of Prolog*, ISBN 0-262-15039-5.
* Building Expert Systems in Prolog, online book by Amzi! Inc.

### Hội thảo

* ICLP Lưu trữ 2006-04-13 tại Wayback Machine Hội thảo quốc tế về lập trình lô-gíc
* INAP Hội thảo quốc tế về lập trình khai báo và quản lý tri thức

### Các nguồn khác

* comp.lang.prolog FAQ Lưu trữ 2006-04-04 tại Wayback Machine
* Prolog: The ISO standard
* Prolog Development Center

| * x
* t
* s
Những lĩnh vực chính của khoa học máy tính |
| --- |
| Các nền tảng toán học | Logic toán học **·**  Lý thuyết tập hợp **·**  Lý thuyết số **·**  Lý thuyết đồ thị **·**  Lý thuyết kiểu **·**  Lý thuyết thể loại **·**  Giải tích số **·**  Lý thuyết thông tin **·**  Đại số **·**  Nhận dạng mẫu **·**  Nhận dạng tiếng nói **·**  Toán học tổ hợp **·**  Đại số Boole **·**  Toán rời rạc |
| Lý thuyết phép tính | Độ phức tạp Kolmogorov **·**  Lý thuyết Automat **·**  Lý thuyết tính được **·**  Lý thuyết độ phức tạp tính toán **·**  Lý thuyết điện toán lượng tử |
| Các cấu trúc dữ liệu và các giải thuật | Phân tích giải thuật **·**  Thiết kế giải thuật **·**  Hình học tính toán **·**  Tối ưu hóa tổ hợp |
| Các ngôn ngữ lập trình và Các trình biên dịch | Các bộ phân tích cú pháp **·**  Các trình thông dịch **·**  Lập trình cấu trúc **·**  Lập trình thủ tục **·**  Lập trình hướng đối tượng **·**  Lập trình hướng khía cạnh **·**  Lập trình hàm **·**  Lập trình logic **·**  Lập trình máy tính **·**  Lập trình mệnh lệnh **·**  Lập trình song song **·**  Lập trình tương tranh **·**  Các mô hình lập trình **·**  Prolog **·**  Tối ưu hóa trình biên dịch |
| Tính song hành, Song song, và các hệ thống phân tán | Đa xử lý **·**  Điện toán lưới **·**  Kiểm soát song hành **·**  Hiệu năng hệ thống **·**  Tính toán phân tán |
| Công nghệ phần mềm | Phân tích yêu cầu **·**  Thiết kế phần mềm **·**  Các phương pháp hình thức **·**  Kiểm thử phần mềm **·**  Quy trình phát triển phần mềm **·**  Các phép đo phần mềm **·**  Đặc tả chương trình **·**  LISP **·**  Mẫu thiết kế **·**  Tối ưu hóa phần mềm |
| Kiến trúc hệ thống | Kiến trúc máy tính **·**  Tổ chức máy tính **·**  Các hệ điều hành **·**  Các cấu trúc điều khiển **·**  Cấu trúc bộ nhớ lưu trữ **·**  Vi mạch **·**  Thiết kế ASIC **·**  Vi lập trình **·**  Vào/ra dữ liệu **·**  VLSI design **·**  Xử lý tín hiệu số |
| Viễn thông và Mạng máy tính | Audio máy tính **·**  Chọn tuyến **·**  Cấu trúc liên kết mạng **·**  Mật mã học |
| Các cơ sở dữ liệu và Các hệ thống thông tin | Hệ quản trị cơ sở dữ liệu **·**  Cơ sở dữ liệu quan hệ **·**  SQL **·**  Các giao dịch **·**  Các chỉ số cơ sở dữ liệu **·**  Khai phá dữ liệu **·**  Biểu diễn và giao diện thông tin **·**  Các hệ thống thông tin **·**  Khôi phục dữ liệu **·**  Lưu trữ thông tin **·**  Lý thuyết thông tin **·**  Mã hóa dữ liệu **·**  Nén dữ liệu **·**  Thu thập thông tin |
| Trí tuệ nhân tạo | Lập luận tự động **·**  Ngôn ngữ học tính toán **·**  Thị giác máy tính **·**  Tính toán tiến hóa **·**  Các hệ chuyên gia  **·**  Học máy **·**  Xử lý ngôn ngữ tự nhiên **·**  Robot học |
| Đồ họa máy tính | Trực quan hóa **·**  Hoạt họa máy tính **·**  Xử lý ảnh |
| Giao diện người-máy tính | Khả năng truy cập máy tính **·**  Giao diện người dùng **·**  Điện toán mang được **·**  Điện toán khắp mọi nơi **·**  Thực tế ảo |
| Khoa học tính toán | Cuộc sống nhân tạo **·**  Tin sinh học **·**  Khoa học nhận thức **·**  Hóa học tính toán **·**  Khoa học thần kinh tính toán **·**  Vật Lý học tính toán **·**  Các giải thuật số **·**  Toán học kí hiệu |
| Chú ý: khoa học máy tính còn có thể được chia thành nhiều chủ đề hay nhiều lĩnh vực khác dựa theo Hệ thống xếp loại điện toán ACM. |

| * x
* t
* s
Ngôn ngữ lập trình |
| --- |
| Dùng cho kỹ nghệ | 
* ABAP
* Ada
* ASP
* ASP.NET
* AWK
* Bash
* Assembly
* C
* C++
* C#
* D
* Delphi
* Erlang
* Groovy
* Fortran
* Java
* JavaScript
* Lisp
* Lua
* Lotus Notes
* Objective-C
* OCaml
* Perl
* PHP
* PL/SQL
* Python
* Ruby
* SAS
* sed
* Smalltalk
* Tcl
* sh
* Visual Basic
* VBScript
* Visual Basic for Applications
* VB.NET
* Scheme
* XML

 |
| Dùng trong giảng dạy | 
* Alice
* C
* C++
* Eiffel
* Fortran
* Haskell
* Java
* JavaScript
* Logo
* ML
* Oz
* Pascal
* Prolog
* Scheme
* Visual Basic
* Visual FoxPro

 |
| Có giá trị lịch sử | 
* ABC
* ALGOL
* APL
* BASIC
* Clipper
* COBOL
* Hope
* MUMPS
* Pascal
* PL/I
* PowerBuilder
* Simula

 |