GNU Prolog手册：约束解决与人工智能

需积分: 10 83 浏览量更新于2024-07-21 收藏 1.42MB PDF 举报

"GNU Prolog 手册，1.44版，由Daniel Diaz撰写，是Prolog的一种GNU实现，包含了有限域约束解决功能。" 在深入探讨 GNU Prolog 之前，我们先了解一下 Prolog 这种编程语言。Prolog，全称逻辑程序设计语言（Programming in Logic），是一种基于逻辑推理的函数式编程语言。它主要用于人工智能、自然语言处理、数据库查询等领域。GNU Prolog 是 Prolog 的一种开源实现，由 Daniel Diaz 开发，具有高效执行和内置的有限域约束求解器等特点。 **1. GNU Prolog 许可条件** GNU Prolog 遵循特定的许可条件，允许用户自由地复制、分发原始及修改后的版本。这些许可条件旨在维护开源软件的精神，确保所有用户都可以自由访问和使用该软件。 **2. 使用 GNU Prolog** **2.1 引言** 手册中的这一部分介绍了如何开始使用 GNU Prolog，包括它的交互式解释器和基本的命令行操作。 **2.2 GNU Prolog 交互式解释器** 这是学习和调试 Prolog 程序的核心工具。用户可以通过这个解释器输入 Prolog 代码，并观察它们的运行结果。启动/退出交互式解释器的指令通常是在终端中输入 `gprolog` 命令。 **2.2.1 启动/退出** 在大多数操作系统中，通过在命令行输入 `gprolog` 就可以启动 GNU Prolog 解释器。一旦启动，用户可以在提示符下输入 Prolog 语句，如定义关系（称为“事实”）和规则。退出解释器通常通过输入 `halt.` 或 `CTRL+D` 实现。 **3. Prolog 基础** 这部分手册会详细介绍 Prolog 的基本语法、逻辑运算符、模式匹配、回溯机制等核心概念。Prolog 的编程通常涉及声明事实、编写规则以及使用查询来检验这些规则的有效性。 **4. 有限域约束解决** GNU Prolog 的一个独特特性是其内建的有限域约束求解器。这使得它在解决约束满足问题（CSPs）时特别强大，如在规划、排程或优化问题中。用户可以利用这一特性来编写更复杂的 Prolog 程序。 **5. 进阶主题** 手册的后续章节可能涵盖 Prolog 的高级特性，如动态数据库、模块系统、非确定性编程、错误处理以及与其他编程语言的接口等。这份手册为学习和使用 GNU Prolog 提供了全面的指南，无论你是初学者还是经验丰富的程序员，都能从中获益。如果你对人工智能或逻辑编程感兴趣，阅读并实践这份手册将有助于你掌握 Prolog 和其在 GNU 环境下的实现。

14 4 USING GNU PROLOG

| ?-

The top-level is ready to execute your queries as explained in the next section.

To quit the top-level type the end-of-ﬁle key sequence (Ctl-D) or its term representation: end of file.

It is also possible to use the built-in predicate halt/0 (section 8.18.1, page 125).

However, before entering the top-level itself, the command-line is processed to treat all known options

(those listed above). All unrecognized arguments are collected together to form the argument list which

will be available using argument value/2 (section 8.27.2, page 159) or argument list/1 (section 8.27.3,

page 160). The -- option stops the parsing of the command-line, all remainding options are collected

into the argument list.

Several options are provided to execute a goal before entering the interaction with the user:

• The --init-goal option executes the GOAL as soon as it is encountered (while the command-line

is processed). GOAL is thus executed before entering top level/0.

• The --consult-file option consults the FILE at the entry of top level/0 just after the banner

is displayed. --consult-file options are handled before --consult-file options.

• The --entry-goal option executes the GOAL at the entry of top level/0 just after the banner is

displayed.

• The --query-goal option executes the GOAL as if the user has typed in (under the top-level).

The above order is thus the order in which each kind of goal (init, entry, query) is executed. If there

are several goals of a same kind they are executed in the order of appearance. Thus, all init goals are

executed (in the order of appearance) before all entry goals and all entry goals are executed before all

query goals.

Each GOAL is passed as a shell argument (i.e. one shell string) and should not contain a terminal dot.

Example: --init-goal ’write(hello), nl’ under a sh-like. To be executed, a GOAL is transformed

into a term using read term from atom(Goal, Term, [end of term(eof)]). Respecting both the syn-

tax of shell strings and of Prolog can be heavy. For instance, passing a backslash character \ can be

diﬃcult since it introduces an escape sequence both in sh and inside Prolog quoted atoms. The use of

back quotes can then be useful since, by default, no escape sequence is processed inside back quotes (this

behavior can be controlled using the back quotes Prolog ﬂag (section 8.22.1, page 147)).

Since the Prolog argument list is created when the whole command-line is parsed, if a --init-goal option

uses argument value/2 or argument list/1 it will obtained the original command-line arguments (i.e.

including all recognized arguments).

Here is an example of using execution goal options:

% gprolog --init-goal ’write(before), nl’ --entry-goal ’write(inside), nl’

--query-goal ’append([a,b],[c,d],X)’

will produce the following:

before

GNU Prolog 1.4.0

By Daniel Diaz

inside

| ?- append([a,b],[c,d],X).

16 4 USING GNU PROLOG

| ?- (X=1 ; X=2).

X = 1 ? (here the user presses RETURN to stop the execution)

yes

The top-level tries to display the values of the variables of the query in a readable manner. For instance,

when a variable is bound to a query variable, the name of this variable appears. When a variable is a

singleton an underscore symbol is displayed ( is a generic name for a singleton variable, it is also called

an anonymous variable). Other variables are bound to new brand variable names. When a query variable

name X appears as the value of another query variable Y it is because X is itself not instantiated otherwise

the value of X is displayed. In such a case, nothing is output for X itself (since it is a variable). Example:

| ?- X=f(A,B, ,A), A=k.

A = k (the value of A is displayed also in f/3 for X)

X = f(k,B, ,k) (since B is a variable which is also a part of X, B is not displayed)

| ?- functor(T,f,3), arg(1,T,X), arg(3,T,X).

T = f(X, ,X) (the 1

and 3

args are equal to X, the 2

is an anonymous variable)

| ?- read from atom(’k(X,Y,X).’,T).

T = k(A, ,A) (the 1

and 3

args are uniﬁed, a new variable name A is introduced)

The top-level uses variable binding predicates (section 8.5, page 63). To display the value of a variable,

the top-level calls write term/3 with the following option list: [quoted(true),numbervars(false),

namevars(true)] (section 8.14.6, page 107). A term of the form ’$VARNAME’(Name) where Name is

an atom is displayed as a variable name while a term of the form ’$VAR’(N) where N is an integer is

displayed as a normal compound term (such a term could be output as a variable name by write term/3).

Example:

| ?- X=’$VARNAME’(’Y’), Y=’$VAR’(1).

X = Y (the term ’$VARNAME’(’Y’) is displayed as Y)

Y = ’$VAR’(1) (the term ’$VAR’(1) is displayed as is)

| ?- X=Y, Y=’$VAR’(1).

X = ’$VAR’(1)

Y = ’$VAR’(1)

In the ﬁrst example, X is explicitly bound to ’$VARNAME’(’Y’) by the query so the top-level displays Y

as the value of X. Y is uniﬁed with ’$VAR’(1) so the top-level displays it as a normal compound term.

It should be clear that X is not bound to Y (whereas it is in the second query). This behavior should be

kept in mind when doing variable binding operations.

Finally, the top-level computes the user-time (section 8.24.2, page 154) taken by a query and displays it

when it is signiﬁcant. Example:

4.2 The GNU Prolog interactive interpreter 17

| ?- retractall(p( )), assertz(p(0)),

repeat,

retract(p(X)),

Y is X + 1,

assertz(p(Y)),

X = 1000, !.

X = 1000

Y = 1001

(180 ms) yes (the query took 180ms of user time)

4.2.3 Consulting a Prolog program

The top-level allows the user to consult Prolog source ﬁles. Consulted predicates can be listed, executed

and debugged (while predicates compiled to native-code cannot). For more information about the diﬀer-

ence between a native-code predicate and a consulted predicate refer to the introduction of this section

(section 4.1, page 13) and to the part devoted to the compiler (section 4.4.1, page 21).

To consult a program use the built-in predicate consult/1 (section 8.23.1, page 152). The argument

of this predicate is a Prolog ﬁle name or user to specify the terminal. This allows the user to directly

input the predicates from the terminal. In that case the input shall be terminated by the end-of-ﬁle key

sequence (Ctl-D) or its term representation: end of file. A shorthand for consult(FILE ) is [FILE ].

Example:

| ?- [user].

{compiling user for byte code...}

even(0).

even(s(s(X))):-

even(X).

(here the user presses Ctl-D to end the input)

{user compiled, 3 lines read - 350 bytes written, 1180 ms}

| ?- even(X).

X = 0 ? ; (here the user presses ; to compute another solution)

X = s(s(0)) ? ; (here the user presses ; to compute another solution)

X = s(s(s(s(0)))) ? (here the user presses RETURN to stop the execution)

yes

| ?- listing.

even(0).

even(s(s(A))) :-

even(A).

When consult/1 (section 8.23.1, page 152) is invoked on a Prolog ﬁle it ﬁrst runs the GNU Prolog

compiler (section 4.4, page 21) as a child process to generate a temporary WAM ﬁle for byte-code. If

the compilation fails a message is displayed and nothing is loaded. If the compilation succeeds, the

produced ﬁle is loaded into memory using load/1 (section 8.23.2, page 152). Namely, the byte-code of

each predicate is loaded. When a predicate P is loaded if there is a previous deﬁnition for P it is removed

(i.e. all clauses deﬁning P are erased). We say that P is redeﬁned. Note that only consulted predicates

18 4 USING GNU PROLOG

can be redeﬁned. If P is a native-code predicate, trying to redeﬁne it will produce an error at load-time:

the predicate redeﬁnition will be ignored and the following message displayed:

native code procedure P cannot be redefined

Finally, an existing predicate will not be removed if it is not re-loaded. This means that if a predicate P

is loaded when consulting the ﬁle F , and if later the deﬁnition of P is removed from the ﬁle F , consulting

F again will not remove the previously loaded deﬁnition of P from the memory.

Consulted predicates can be debugged using the Prolog debugger. Use the debugger predicate trace/0

or debug/0 (section 5.3.1, page 31) to activate the debugger.

4.2.4 Scripting Prolog

Since version 1.4.0 it is possible to use a Prolog source ﬁle as a Unix script-ﬁle (shebang support). A

PrologScript ﬁle should begin as follows:

#!/usr/bin/gprolog --consult-file

GNU Prolog will be invoked as

/usr/bin/gprolog --consult-file FILE

Then FILE will be consulted. In order to correctly deal with the #! ﬁrst line, consult/1 treats as a

comment a ﬁrst line of a ﬁle which begins with # (if you want to use a predicate name starting with a #,

simply skip a line before its deﬁnition).

Remark: it is almost never possible to pass additionnal parameters (e.g. query-goal) this way since in

most systems the shebang implementation deliver all arguments (following #!/usr/bin/gprolog) as a

single string (which cannot then correctly be recognized by gprolog).

4.2.5 Interrupting a query

Under the top-level it is possible to interrupt the execution of a query by typing the interruption key

(Ctl-C). This can be used to abort a query, to stop an inﬁnite loop, to activate the debugger,. . . When an

interruption occurs the top-level displays the following message: Prolog interruption (h for help) ?

The user can then type one of the following commands:

Command Name Description

a abort abort the current execution. Same as abort/0 (section 8.18.1, page 125)

e exit quit the current Prolog process. Same as halt/0 (section 8.18.1, page 125)

b break invoke a recursive top-level. Same as break/0 (section 8.18.1, page 125)

c continue resume the execution

t trace start the debugger using trace/0 (section 5.3.1, page 31)

d debug start the debugger using debug/0 (section 5.3.1, page 31)

h or ? help display a summary of available commands

4.2.6 The line editor

The line editor (linedit) allows the user to build/update the current input line using a variety of

commands. This facility is available if the linedit part of GNU Prolog has been installed. linedit is

剩余237页未读，继续阅读

gale320

粉丝: 0
资源: 4

GNU Prolog手册：约束解决与人工智能

WPF 文本阅读器（DocumentViewer控件）

HTML Document HTML Document HTML Document

Document Manager 用户指南(word文档)

var document: Document

if(!document) document=window.document有什么作用

最新资源