Question

我想知道，是否有可能在运行时使用通过撤回和断言修改的知识库在Prolog中进行计划？

我的想法如下：假设我需要更换汽车的flat胎。我既可以将东西放在地面上，也可以将东西从地面上移到某个自由的地方。

所以我想出了这样的代码：

at(flat, axle).
at(spare, trunk).

free(Where) :- at(_, Where), !, fail.
remove(What) :- at(What, _), retract(at(What, _)), assert(at(What, ground)).
put_on(What, Where) :- at(What, _), free(Where), retract(at(What, _)), assert(at(What, Where)).

（我是Prolog的新秀，所以也许这是错误的，如果是这样，请告诉我如何纠正它。）

这个想法是：我的车轴上有一个漏气的轮胎，而后备箱中有一个备用轮胎。如果X在某处，我可以将其删除，然后删除它，删除指定该位置的事实并添加一个在地面上的事实。同样，如果X在某处并且Y是自由的，我可以将事物X放置在位置Y上，为此，我将X从其所在的位置删除，并添加X在Y的事实。

现在我陷入了困境：我不知道现在如何使用此代码，因为at(spare, axle)只是说不，即使是跟踪也是如此。

问题是：可以使用这种方法吗？如果可以，怎么使用？

我希望这是有道理的。

Answer 1

使用George F Luger（WorldCat）的“人工智能-解决复杂问题的结构和策略”中的示例代码

adts

%%%
%%% This is one of the example programs from the textbook:
%%%
%%% Artificial Intelligence: 
%%% Structures and strategies for complex problem solving
%%%
%%% by George F. Luger and William A. Stubblefield
%%% 
%%% Corrections by Christopher E. Davis (chris2d@cs.unm.edu)
%%%
%%% These programs are copyrighted by Benjamin/Cummings Publishers.
%%%
%%% We offer them for use, free of charge, for educational purposes only.
%%%
%%% Disclaimer: These programs are provided with no warranty whatsoever as to
%%% their correctness, reliability, or any other property.  We have written 
%%% them for specific educational purposes, and have made no effort
%%% to produce commercial quality computer programs.  Please do not expect 
%%% more of them then we have intended.
%%%
%%% This code has been tested with SWI-Prolog (Multi-threaded, Version 5.2.13)
%%% and appears to function as intended.

%%%%%%%%%%%%%%%%%%%% stack operations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    % These predicates give a simple, list based implementation of stacks

    % empty stack generates/tests an empty stack

member(X,[X|_]).
member(X,[_|T]):-member(X,T).

empty_stack([]).

    % member_stack tests if an element is a member of a stack

member_stack(E, S) :- member(E, S).

    % stack performs the push, pop and peek operations
    % to push an element onto the stack
        % ?- stack(a, [b,c,d], S).
    %    S = [a,b,c,d]
    % To pop an element from the stack
    % ?- stack(Top, Rest, [a,b,c]).
    %    Top = a, Rest = [b,c]
    % To peek at the top element on the stack
    % ?- stack(Top, _, [a,b,c]).
    %    Top = a 

stack(E, S, [E|S]).

%%%%%%%%%%%%%%%%%%%% queue operations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    % These predicates give a simple, list based implementation of 
    % FIFO queues

    % empty queue generates/tests an empty queue


empty_queue([]).

    % member_queue tests if an element is a member of a queue

member_queue(E, S) :- member(E, S).

    % add_to_queue adds a new element to the back of the queue

add_to_queue(E, [], [E]).
add_to_queue(E, [H|T], [H|Tnew]) :- add_to_queue(E, T, Tnew).

    % remove_from_queue removes the next element from the queue
    % Note that it can also be used to examine that element 
    % without removing it

remove_from_queue(E, [E|T], T).

append_queue(First, Second, Concatenation) :- 
    append(First, Second, Concatenation).

%%%%%%%%%%%%%%%%%%%% set operations %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    % These predicates give a simple, 
    % list based implementation of sets

    % empty_set tests/generates an empty set.

empty_set([]).

member_set(E, S) :- member(E, S).

    % add_to_set adds a new member to a set, allowing each element
    % to appear only once

add_to_set(X, S, S) :- member(X, S), !.
add_to_set(X, S, [X|S]).

remove_from_set(_, [], []).
remove_from_set(E, [E|T], T) :- !.
remove_from_set(E, [H|T], [H|T_new]) :-
    remove_from_set(E, T, T_new), !.

union([], S, S).
union([H|T], S, S_new) :- 
    union(T, S, S2),
    add_to_set(H, S2, S_new).   

intersection([], _, []).
intersection([H|T], S, [H|S_new]) :-
    member_set(H, S),
    intersection(T, S, S_new),!.
intersection([_|T], S, S_new) :-
    intersection(T, S, S_new),!.

set_diff([], _, []).
set_diff([H|T], S, T_new) :- 
    member_set(H, S), 
    set_diff(T, S, T_new),!.
set_diff([H|T], S, [H|T_new]) :- 
    set_diff(T, S, T_new), !.

subset([], _).
subset([H|T], S) :- 
    member_set(H, S), 
    subset(T, S).

equal_set(S1, S2) :- 
    subset(S1, S2), subset(S2, S1).

%%%%%%%%%%%%%%%%%%%%%%% priority queue operations %%%%%%%%%%%%%%%%%%%

    % These predicates provide a simple list based implementation
    % of a priority queue.

    % They assume a definition of precedes for the objects being handled

empty_sort_queue([]).

member_sort_queue(E, S) :- member(E, S).

insert_sort_queue(State, [], [State]).  
insert_sort_queue(State, [H | T], [State, H | T]) :- 
    precedes(State, H).
insert_sort_queue(State, [H|T], [H | T_new]) :- 
    insert_sort_queue(State, T, T_new). 

remove_sort_queue(First, [First|Rest], Rest).

planner

%%%%%%%%% Simple Prolog Planner %%%%%%%%
%%%
%%% This is one of the example programs from the textbook:
%%%
%%% Artificial Intelligence: 
%%% Structures and strategies for complex problem solving
%%%
%%% by George F. Luger and William A. Stubblefield
%%% 
%%% Corrections by Christopher E. Davis (chris2d@cs.unm.edu)
%%%
%%% These programs are copyrighted by Benjamin/Cummings Publishers.
%%%
%%% We offer them for use, free of charge, for educational purposes only.
%%%
%%% Disclaimer: These programs are provided with no warranty whatsoever as to
%%% their correctness, reliability, or any other property.  We have written 
%%% them for specific educational purposes, and have made no effort
%%% to produce commercial quality computer programs.  Please do not expect 
%%% more of them then we have intended.
%%%
%%% This code has been tested with SWI-Prolog (Multi-threaded, Version 5.2.13)
%%% and appears to function as intended.

:- [adts].
plan(State, Goal, _, Moves) :-  equal_set(State, Goal), 
                write('moves are'), nl,
                reverse_print_stack(Moves).
plan(State, Goal, Been_list, Moves) :-  
                move(Name, Preconditions, Actions),
                conditions_met(Preconditions, State),
                change_state(State, Actions, Child_state),
                not(member_state(Child_state, Been_list)),
                stack(Child_state, Been_list, New_been_list),
                stack(Name, Moves, New_moves),
            plan(Child_state, Goal, New_been_list, New_moves),!.

change_state(S, [], S).
change_state(S, [add(P)|T], S_new) :-   change_state(S, T, S2),
                    add_to_set(P, S2, S_new), !.
change_state(S, [del(P)|T], S_new) :-   change_state(S, T, S2),
                    remove_from_set(P, S2, S_new), !.
conditions_met(P, S) :- subset(P, S).


member_state(S, [H|_]) :-   equal_set(S, H).
member_state(S, [_|T]) :-   member_state(S, T).

reverse_print_stack(S) :-   empty_stack(S).
reverse_print_stack(S) :-   stack(E, Rest, S), 
                reverse_print_stack(Rest),
                write(E), nl.


/* sample moves */

move(pickup(X), [handempty, clear(X), on(X, Y)], 
        [del(handempty), del(clear(X)), del(on(X, Y)), 
                 add(clear(Y)), add(holding(X))]).

move(pickup(X), [handempty, clear(X), ontable(X)], 
        [del(handempty), del(clear(X)), del(ontable(X)), 
                 add(holding(X))]).

move(putdown(X), [holding(X)], 
        [del(holding(X)), add(ontable(X)), add(clear(X)), 
                  add(handempty)]).

move(stack(X, Y), [holding(X), clear(Y)], 
        [del(holding(X)), del(clear(Y)), add(handempty), add(on(X, Y)),
                  add(clear(X))]).

go(S, G) :- plan(S, G, [S], []).
test :- go([handempty, ontable(b), ontable(c), on(a, b), clear(c), clear(a)],
              [handempty, ontable(c), on(a,b), on(b, c), clear(a)]).

大多数代码保持不变，唯一需要解决的问题就是谓词move/3和查询test。在添加谓词以解决您的问题之前，请注释掉上面的代码中的谓词move/3和test/0。

下面是所有需要的新谓词move/3和test/0。显示第一个move/3，其余的则需要显示（鼠标悬停在下面的黄色框中），以便您可以根据需要查看它们，但是您应该自己尝试做。

move(take_from_trunk(X), [hand(empty), trunk(X)],
    [del(hand(empty)), del(trunk(X)),
        add(hand(X)), add(trunk(empty))]).

状态跟踪四个位置hand，ground，axle和trunk，以及三个值flat，{{1} }，以及spare作为位置。谓词empty还使用变量，以使变量在执行功能时不会被固定。

move/3谓词有3个参数。
1.名称：答案中出现的内容，例如move/3。
2.前提条件：要进行移动，必须在take_from_trunk(spare)中存在的条件。
3.动作：对状态的更改（如果应用了此动作）。这些代替了您的state和assert。更改非常简单，您可以删除一些状态属性，例如retract并添加一些内容，例如del(hand(empty))。对于给定的问题，此解决方案很简单，因为每次更改，每个add(hand(X))都有一个匹配的del。

查询：

add

示例运行：

test :- go([hand(empty), trunk(spare), axle(flat), ground(empty)],
            [hand(empty), trunk(flat), axle(spare), ground(empty)]).

需要其他?- test. moves are take_from_trunk(spare) place_on_ground(spare) take_off_axle(flat) place_in_trunk(flat) pickup_from_ground(spare) place_on_axle(spare) true.谓词。尝试自己做。

move（take_off_axle（X），[hand（empty），axis（X）]，
       [del（hand（empty）），del（axle（X）），
        add（hand（X）），add（axle（empty））]）。

move（place_on_ground（X），[hand（X），ground（empty）]，
      [del（hand（X）），del（ground（empty）），
             add（hand（empty）），add（ground（X））]）。

move（pickup_from_ground（X），[hand（empty），ground（X）]，
      [del（hand（empt）），del（ground（X）），
             add（hand（X）），add（ground（empty））]）。

move（place_on_axle（X），[hand（X），axle（empty）]，
      [del（hand（X）），del（axle（empty）），
             add（hand（empty）），add（axle（X））]）。

move（place_in_trunk（X），[hand（X），trunk（empty）]，
     [del（hand（X）），del（trunk（empty）），
             add（hand（empty）），add（trunk（X））]）。

在编写这些谓词时，move/3中的某些无法按我预期的那样工作，因此我为每个谓词创建了简单的测试查询以对其进行检查。

使用测试还帮助我更改了move/3中的内容及其表示方式，例如，它代替了state和handempty更改为holding(X)， hand(empty)可以更轻松地理解，跟踪和检查代码的一致性，但很可能会使代码效率更低。

hand(X)

其中的一些测试仅使用一个步骤即可完成预期工作，而其他测试则返回许多步骤。我在这里没有修改test_01 :- go([hand(empty), trunk(spare), axle(flat), ground(empty)], [hand(spare), trunk(empty), axle(flat), ground(empty)]). test_02 :- go([hand(empty), trunk(spare), axle(flat), ground(empty)], [hand(flat), trunk(spare), axle(empty), ground(empty)]). test_03 :- go([hand(flat), trunk(spare), axle(empty), ground(empty)], [hand(empty), trunk(spare), axle(empty), ground(flat)]). test_04 :- go([hand(empty), trunk(spare), axle(empty), ground(flat)], [hand(flat), trunk(spare), axle(empty), ground(empty)]). test_05 :- go([hand(spare), trunk(empty), axle(empty), ground(flat)], [hand(empty), trunk(empty), axle(spare), ground(flat)]). test_06 :- go([hand(flat), trunk(empty), axle(spare), ground(empty)], [hand(empty), trunk(flat), axle(spare), ground(empty)]).，因此只考虑一个move/3，但是如果您愿意，可以对其进行修改。考虑guard语句或约束。

此处列出测试结果的另一个原因是，表明某些举动并未按照您的想法或意图进行，并且并未完全按照您的预期工作，但是对已发布的查询问题按预期工作。因此，如果您编写测试用例并且它们返回了类似的内容，则不要以为您的move/3无效或有错误，它们可能不会。当所有move/3和最终查询都按预期工作时，请返回并尝试了解为什么会发生这些多次移动，然后根据需要进行修改。

move/3

使用撤回和断言进行Prolog计划

1 个答案: