prolog - 使用收回和断言的 Prolog 规划

Question

我想知道，是否可以在运行时使用由retract 和assert 修改的知识库在Prolog 中进行规划？

我的想法如下：假设我需要更换一辆汽车的爆胎。我可以把东西放在地上，也可以把东西从地上移到某个空闲的地方。

所以我想出了这样一个代码：

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，为了移除它，我移除了指定它在哪里的事实，并添加了一个事实，即它在地面上。类似地，如果 X 在某个地方并且 Y 是空闲的，我可以将一个东西 X 放到位置 Y，为此，我将 X 从它所在的位置移除并添加 X 在 Y 处的事实。

现在我被困住了：我现在不知道如何使用这段代码，因为at(spare, axle)只是说不，即使有跟踪。

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

我希望这是有道理的。

score 2 · Accepted Answer

使用 George F Luger ( WorldCat )的“Artificial Intelligence - Structures and Strategies for Complex Problem Solving”中的示例代码

%%%
%%% 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).

规划师

%%%%%%%%% 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显示出来，其余的需要显示（单击Reveal spoiler），以便您可以在需要时查看它们，但您应该尝试自己做。

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，spare和empty。谓词move/3还使用变量，因此它们不固定在它们可以做什么。

move/3谓词有 3 个参数。

名称：答案中出现的内容，例如take_from_trunk(spare)。
前提条件：state应用移动必须存在的条件。
操作：如果应用了移动，则对状态所做的更改。这些代替了你的assertand 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/3谓词。尝试自己做这件事。

移动（起飞轴（X），[手（空），轴（X）]，
[del（手（空）），del（轴（X）），
添加（手（X）），添加（轴（空） )])。

移动（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(empty)), del(ground(X)),
add(hand(X)), add(ground(empty) )])。

移动（place_on_axle（X），[手（X），车轴（空）]，
[del（手（X）），del（车轴（空）），
添加（手（空）），添加（车轴（X） )])。

move(place_in_trunk(X), [hand(X), trunk(empty)],
[del(hand(X)), del(trunk(empty)),
添加（手（空）），添加（树干（X））]）。

在编写这些谓词时，有些谓词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这里，因此只move/3考虑一个，但如果您愿意，可以修改它们。想想看守声明或约束。

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

?- test_01.
moves are
take_from_trunk(spare)
true.

?- test_02.
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)
take_from_trunk(flat)
place_on_ground(flat)
take_off_axle(spare)
place_in_trunk(spare)
pickup_from_ground(flat)
true.

?- test_03.
moves are
place_on_ground(flat)
true.

?- test_04.
moves are
take_from_trunk(spare)
place_on_axle(spare)
pickup_from_ground(flat)
place_in_trunk(flat)
take_off_axle(spare)
place_on_ground(spare)
take_from_trunk(flat)
place_on_axle(flat)
pickup_from_ground(spare)
place_in_trunk(spare)
take_off_axle(flat)
true.

?- test_05.
moves are
place_on_axle(spare)
true.

?- test_06.
moves are
place_on_ground(flat)
take_off_axle(spare)
place_in_trunk(spare)
pickup_from_ground(flat)
place_on_axle(flat)
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.

prolog - 使用收回和断言的 Prolog 规划

1 回答 1

Related

Reference