Here is a recursive action specific

Here is a recursive action specification for moving blocks:

r_put_on(A,B) :-
on(A,B).
r_put_on(A,B) :-
not(on(A,B)),
A == table,
A == B,
clear_off(A), /* N.B. "action" used as precondition */
clear_off(B),
on(A,X),
retract(on(A,X)),
assert(on(A,B)),
assert(move(A,X,B)).

clear_off(table). /* Means there is room on table */
clear_off(A) :- /* Means already clear */
not(on(_X,A)).
clear_off(A) :-
A == table,
on(X,A),
clear_off(X), /* N.B. recursion */
retract(on(X,A)),
assert(on(X,table)),
assert(move(X,A,table)).
A recursive action specification can have the form


action :- preconditions or actions,
retract(affected_old_properties),
assert(new_properties).
Assume again that the original situation holds (and that the previous 'move' clauses have been retracted):


on(a,b).
on(b,c).
on(c,table).
Now,


?- r_put_on(c,a).
yes

?- listing(on), listing(move).

on(a,table).
on(b,table).
on(c,a).

move(a,b,table).
move(b,c,table).
move(c,table,a).

yes
The 'put_on' action has recursively called the 'clear_off' action so that 'c' could be placed on top of 'a'.
Let us now add to the program some clauses so that a list of 'on' properties could be established jointly.


do(Glist) :-
valid(Glist),
do_all(Glist,Glist).

valid(_). /* Temporary. See Exercise 2.19.1 */

do_all([G|R],Allgoals) :- /* already true now */
call(G),
do_all(R,Allgoals),!. /* continue with rest of goals */

do_all([G|_],Allgoals) :- /* must do work to achieve */
achieve(G),
do_all(Allgoals,Allgoals). /* go back and check previous goals */
do_all([],_Allgoals). /* finished */

achieve(on(A,B)) :-
r_put_on(A,B).
The program can now be used by giving a main goal of the form ?- do([...]), where the list contains various on(-,-) subgoal statements (with no variables). Assume that the original starting situation holds again; that is,


on(a,b).
on(b,c),
on(c,table).
Consider the Prolog goal


?- do([on(a,table),on(b,a),on(c,b)]).
yes

?- listing(on), listing(move).
on(a,table).
on(b,a).
on(c,b).

move(a,b,table).
move(b,c,a).
move(c,table,b).

yes
The reader should try the goal and list the resulting program to partially verify that this works the way that we have claimed. This program does nothing special with the plan, other than incorporate it at the end of the program. To generate another plan for the same initial setup, but different goal conditions, one could reload plans.pro first. This inconvenience could be eliminated in several ways, depending on how one intended to use the program (see the exercises for more on this).
Pay particular attention to how the program attempts to satisfy a list of individual goals. The definition of the predicate 'do-all' in the program should be studied carefully. In satisfying a list of individual goals, each goal is worked on from left to right. If an individual goal is already satisfied, then proceed to the next goal. Otherwise satisfy the current goal, but then go back to the beginning of the list to check that the previous goals are still satisfied. Work on them again if they are not still satisfied. Repeatedly do this until all individual goals in the list are satisfied (if possible).
The STRIPS planning system, described in Nilsson (1980), used operators consisting of three components:


Precondition formula, which must be true in order for the
operator to be applicable;

Delete-list, which consists of predicates made false by
the action;

Add-list, which consists of predicates made true by the
action.
The last 'clear_off' clause could be characterized in the STRIPS manner, as follows:


clear_off(A) :
Precondition: A == table, on(X,A), clear_off(X)

Delete-list: on(X,A)

Add-list: on(X,table), move(X,A,table)
Actually this would correspond to the recursive version of STRIPS (RSTRIPS) for the same reason that our program used recursive action specifications. The program presented here uses Prolog as the inference control engine, whereas STRIPS had its own inference and control strategies. A good project would be to read more about STRIPS, and re implement it in Prolog.
The Prolog planning program illustrates several other planning issues. An important thing to notice is that individual goals may not be independent of one another. For example, using the original starting configuration, suppose that we pose the goal


?- do([on(c,b),on(b,a),on(a,table)]).
which is the reverse of the previous goal. This time, the following plan is generated.


move(a,b,table).
move(b,c,table).
move(c,table,b).
move(c,b,table).
move(b,table,a).
move(c,table,b).
Compare this plan with the one previously generated. This plan has redundant moves (like the middle two), and does not otherwise achieve the final conjunction of goals in as efficient

Hasil (Bahasa Indonesia) 1:

Berikut adalah spesifikasi tindakan rekursif untuk memindahkan blok: r_put_on(A,B):- on(A,B).r_put_on(A,B):- not(on(A,B)), A == tabel, A == B, clear_off(A), / * NB "aksi" digunakan sebagai prasyarat * / clear_off(B), on(A,X), retract(on(A,X)), assert(on(A,B)), assert(Move(A,X,B)).clear_off(Table). / * Berarti ada ruang di meja * /clear_off(A):-/ * berarti sudah jelas * / not(on(_X,A)).clear_off(A):- A == tabel, on(X,A), clear_off(X), / * NB rekursi * / retract(on(X,A)), assert(on(X,Table)), assert(Move(X,A,Table)).Rekursif tindakan Spesifikasi dapat memiliki bentuk Aksi:-prasyarat atau tindakan, retract(affected_old_properties), assert(new_properties).Berasumsi lagi bahwa asli situasi memegang (dan yang sebelumnya 'bergerak' persyaratan telah ditarik kembali): on(a,b).on(b,c).on(c,Table).Sekarang, ?-r_put_on(c,a).Ya?-listing(on), listing(move).on(a,Table).on(b,Table).on(c,a).Move(a,b,Table).Move(b,c,Table).Move(c,Table,a).Ya'Put_on' tindakan telah secara rekursif yang disebut 'clear_off' tindakan sehingga 'c' dapat ditempatkan di atas ''.Mari kita sekarang menambahkan program beberapa klausa sehingga daftar 'pada' properti dapat dibentuk bersama-sama. do(GList):- valid(GList), do_all(GList,GList). valid(_). / * Sementara. Lihat latihan 2.19.1 * / do_all ([G | R], Allgoals):-/ * sudah benar sekarang * / Call(G), do_all(R,Allgoals),!. / * melanjutkan sisa tujuan * /do_all([G|_],Allgoals):-/ * harus melakukan pekerjaan untuk mencapai * / achieve(G), do_all(Allgoals,Allgoals). / * kembali dan memeriksa tujuan sebelumnya * /do_all([],_Allgoals). / * selesai * /achieve(on(A,B)):- r_put_on(A,B).Program sekarang dapat digunakan dengan memberikan tujuan utama dari bentuk?-do([...]), mana daftar berisi berbagai pernyataan subgoal on(-,-) (dengan variabel tidak). Menganggap bahwa situasi awal asli memegang lagi; Yaitu on(a,b).on(b,c),on(c,Table).Mempertimbangkan tujuan Prolog ?-do([on(a,table),on(b,a),on(c,b)]).Ya?-listing(on), listing(move).on(a,Table).on(b,a).on(c,b).Move(a,b,Table).Move(b,c,a).Move(c,Table,b).YaPembaca harus mencoba tujuan dan daftar program dihasilkan sebagian memverifikasi bahwa ini bekerja dengan cara yang kita telah diklaim. Program ini tidak ada yang istimewa dengan rencana, lain daripada memasukkan pada akhir program. Untuk menghasilkan rencana lain untuk setup awal yang sama, tapi kondisi tujuan yang berbeda, satu dapat reload plans.pro pertama. Ketidaknyamanan ini bisa dihilangkan dengan beberapa cara, tergantung pada bagaimana yang dimaksudkan untuk menggunakan program (Lihat latihan untuk lebih lanjut tentang ini).Memberi perhatian khusus terhadap bagaimana program ini berusaha untuk memuaskan daftar tujuan individu. Definisi predikat 'do-semua' dalam program harus dipelajari dengan seksama. Dalam memuaskan daftar tujuan individu, setiap tujuan bekerja pada dari kiri ke kanan. Jika tujuan individu yang sudah puas, kemudian lanjutkan ke tujuan berikutnya. Jika tidak memenuhi tujuan saat ini, tetapi kemudian kembali ke awal daftar untuk memeriksa bahwa tujuan sebelumnya masih puas. Bekerja pada mereka lagi jika mereka tidak masih puas. Berulang kali melakukan ini sampai semua tujuan-tujuan individu pada daftar puas (jika mungkin).STRIP perencanaan sistem, dijelaskan dalam Nilsson (1980), digunakan operator yang terdiri dari tiga komponen: Prasyarat formula, yang pasti benar agar operator yang akan berlaku;Hapus-daftar, yang terdiri dari predikat dibuat palsu oleh tindakan;Tambahkan daftar, yang terdiri dari predikat yang dibuat benar oleh tindakan.Klausa 'clear_off' yang terakhir bisa ditandai secara STRIP, sebagai berikut: clear_off(A): Prasyarat: A == Biliar, on(X,A), clear_off(X) Hapus-daftar: on(X,A) Tambahkan-daftar: on(X,table), move(X,A,table)Sebenarnya ini akan sesuai dengan versi rekursif dari STRIP (RSTRIPS) untuk alasan yang sama bahwa program kami digunakan rekursif tindakan spesifikasi. Program yang disajikan di sini menggunakan Prolog sebagai kesimpulan kontrol mesin, sedangkan STRIP memiliki strategi sendiri kesimpulan dan kontrol. Proyek yang baik akan membaca lebih tentang STRIP, dan kembali melaksanakan dalam Prolog.Prolog perencanaan program menggambarkan beberapa isu perencanaan. Penting untuk memperhatikan adalah bahwa tujuan individu tidak mungkin independen satu sama lain. Menggunakan konfigurasi awal asli, misalnya, bahwa kita menimbulkan tujuan ?-do([on(c,b),on(b,a),on(a,table)]).yang merupakan kebalikan dari tujuan sebelumnya. Saat ini, rencana berikut yang dihasilkan. Move(a,b,Table).Move(b,c,Table).Move(c,Table,b).Move(c,b,Table).Move(b,Table,a).Move(c,Table,b).Membandingkan rencana ini dengan yang sebelumnya dihasilkan. Rencana ini telah bergerak berlebihan (seperti tengah dua), dan sebaliknya tidak mencapai konjungsi akhir tujuan sebagai efisien

Hasil (Bahasa Indonesia) 2:

Berikut adalah spesifikasi rekursif aksi untuk blok bergerak:

r_put_on (A, B): -
pada (A, B).
r_put_on (A, B): -
tidak (pada (A, B)),
A == meja,
A == B,
clear_off (A), / * NB "action" yang digunakan sebagai prasyarat * /
clear_off (B) ,
pada (A, X),
menarik kembali (pada (A, X)),
menegaskan (pada (A, B)),
menegaskan (bergerak (A, X, B)).

clear_off (tabel). / * Berarti ada ruang di atas meja * /
clear_off (A): - / * Berarti sudah jelas * /
tidak (pada (_X, A)).
clear_off (A): -
A == meja,
pada (X, A),
clear_off (X), / * NB rekursi * /
menarik kembali (pada (X, A)),
menegaskan (pada (X, tabel)),
menegaskan (bergerak (X, A, tabel)).
Spesifikasi tindakan rekursif dapat memiliki bentuk


tindakan: - prasyarat atau tindakan,
menarik kembali (affected_old_properties),
menegaskan (new_properties).
Asumsikan lagi bahwa situasi aslinya memegang (dan yang sebelumnya 'bergerak' klausul telah ditarik):


pada (a, b).
pada (b, c).
pada (c, tabel).
Sekarang,


-? R_put_on (c, a).
ya

-? listing (di), daftar (bergerak).

(a, tabel).
pada (b, tabel).
pada (c, a).

bergerak (a, b, meja).
Langkah (b, c, tabel).
bergerak (c, meja, a).

ya
The 'put_on' tindakan telah rekursif menyebut aksi 'clear_off' sehingga 'c' bisa ditempatkan di atas 'a'.
Mari kita menambah program beberapa klausul sehingga daftar 'on' sifat dapat dibentuk bersama-sama.


melakukan (Glist): -
berlaku (Glist),
do_all (Glist, Glist).

sah(_). / * Sementara. Lihat Latihan 2.19.1 * /

do_all ([G | R], Allgoals): - / * sudah benar sekarang * /
panggilan (G),
do_all (R, Allgoals),!. / * Teruskan dengan tujuan * /

do_all ([G | _], Allgoals): - / * harus melakukan pekerjaan untuk mencapai * /
mencapai (G),
do_all (Allgoals, Allgoals). / * Kembali dan memeriksa sebelumnya tujuan * /
do_all ([], _ Allgoals). / * Selesai * /

mencapai (pada (A, B)): -
r_put_on (A, B).
Program ini sekarang dapat digunakan dengan memberikan tujuan utama dari bentuk -? Do ([...]), di mana daftar berisi berbagai pada (-, -) pernyataan subgoal (tanpa variabel). Asumsikan bahwa situasi awal mula memegang lagi; yaitu,


pada (a, b).
pada (b, c),
pada (c, tabel).
Pertimbangkan tujuan Prolog


-? Do ([di (a, meja), pada (b, a), pada (c, b)]).
ya

-? listing (di), daftar (bergerak).
(a, tabel).
pada (b, a).
pada (c, b).

bergerak (a, b, meja).
Langkah (b, c, a).
bergerak (c, meja, b).

ya
Pembaca harus mencoba tujuan dan daftar program yang dihasilkan untuk sebagian memverifikasi bahwa ini bekerja dengan cara yang kita telah diklaim. Program ini tidak ada yang istimewa dengan rencana, selain memasukkan pada akhir program. Untuk menghasilkan rencana lain untuk pengaturan awal yang sama, namun kondisi tujuan yang berbeda, satu bisa muat ulang plans.pro pertama. Ketidaknyamanan ini bisa dihilangkan dengan beberapa cara, tergantung pada bagaimana seseorang dimaksudkan untuk menggunakan program (lihat latihan untuk lebih lanjut tentang ini).
Memberikan perhatian khusus bagaimana program mencoba untuk memenuhi daftar tujuan individu. Definisi predikat 'do-semua' dalam program ini harus dipelajari dengan hati-hati. Dalam memuaskan daftar tujuan individu, setiap tujuan yang bekerja pada dari kiri ke kanan. Jika tujuan individu sudah puas, kemudian dilanjutkan ke tujuan berikutnya. Jika tidak memenuhi tujuan saat ini, tetapi kemudian kembali ke awal daftar untuk memeriksa bahwa tujuan sebelumnya masih puas. Bekerja pada mereka lagi jika mereka tidak masih puas. Berulang kali melakukan hal ini sampai semua tujuan individu dalam daftar puas (jika mungkin).
The strip sistem perencanaan, dijelaskan dalam Nilsson (1980), operator yang digunakan terdiri dari tiga komponen:


rumus Prekondisi, yang harus benar agar para
operator untuk berlaku;

Hapus-list, yang terdiri dari predikat dibuat palsu oleh
tindakan;

Add-daftar, yang terdiri dari predikat dibuat benar oleh
tindakan.
Yang terakhir 'clear_off' klausa dapat ditandai dengan cara strip, sebagai berikut:


clear_off (A):
Prasyarat: A == meja, pada (X, A), clear_off (X)

Hapus-list: on (X, A )

Add-daftar: pada (X, meja), bergerak (X, A, table)
Sebenarnya ini akan sesuai dengan versi rekursif dari strip (RSTRIPS) untuk alasan yang sama bahwa program kami digunakan spesifikasi tindakan rekursif. Program yang disajikan di sini menggunakan Prolog sebagai mesin kontrol inferensi, sedangkan strip memiliki inferensi dan kontrol sendiri strateginya. Sebuah proyek yang baik akan membaca lebih lanjut tentang strip, dan kembali menerapkannya dalam Prolog.
The Prolog perencanaan program menggambarkan beberapa masalah perencanaan lainnya. Suatu hal yang penting untuk diperhatikan adalah bahwa tujuan individu mungkin tidak independen satu sama lain. Misalnya, menggunakan konfigurasi awal asli, misalkan kita berpose tujuan


-? Do ([di (c, b), pada (b, a), (a, tabel)]).
yang merupakan kebalikan dari tujuan sebelumnya. Kali ini, rencana berikut dihasilkan.


bergerak (a, b, meja).
Langkah (b, c, tabel).
bergerak (c, meja, b).
Langkah (c, b, meja).
Langkah (b, meja, a).
bergerak (c, meja, b).
Bandingkan rencana ini dengan satu sebelumnya dihasilkan. Rencana ini memiliki bergerak berlebihan (seperti tengah dua), dan tidak sebaliknya mencapai hubungannya akhir gol dalam efisien