Wissen, wann Prolog zu verwenden ist

Habe ich nahm einen Kurs, in dem ich lernte einige prolog. Ich konnte nicht herausfinden, wie /Wann schneidet. Obwohl ich die Allgemeine Idee, die Schnitte, die ich kann nicht scheinen, um Sie richtig zu verwenden.
Kann jemand erklären es kurz zu geben oder ein gutes tutorial (das ist nicht learnprolognow.org "Schnitte", die Sie empfehlen können?

InformationsquelleAutor der Frage Shookie | 2013-01-26

prolog prolog-cut

20

TL;DR: nicht.

Die geschnittenen Pflaumen Prolog - Suchbaum. Das ist, da eine Reine Prolog-Programm, das ohne schneiden und das gleiche Programm mit Kürzungen der einzige Unterschied ist, dass das Programm mit cuts vielleicht verbringen weniger Zeit in fruchtlosen Zweigen, und somit ist effizienter ; vielleicht weniger Antworten ; es könnte auch kündigen, in der Erwägung, dass das ursprüngliche Programm nicht.

Klingt ziemlich harmlos ... oder sogar nützlich, nicht wahr?
Gut, die meisten der Zeit, die Dinge sind komplexer.

Rote Schnitte

Schnitte werden oft in einer Weise, dass das Programm ohne cuts hat keine sinnvolle Bedeutung. Solche Schnitte sind aufgerufen, rote Schnitte. In den besseren Fällen ist es verwendet wird, zu implementieren, die eine primitive form der nicht-monotone negation. Und in einigen anderen Fällen ist es die halbe negation, die Hälfte einige verfahrensrechtliche Bedeutung, das ist sehr schwer zu verstehen. Nicht nur für den Leser des Programms, sondern auch für seine Schriftsteller. In der Tat oft so verwendet unabsichtlich Mangel Standhaftigkeit. In jedem Fall: diese Kürzungen sind nicht platziert in ein bestehendes Programm. Sie sollen in diesem Programm von Anfang an.

Mehr für die strukturierte Nutzung des roten Schnitte, eine bessere Nutzung once/1(\+)/1 oder (;)/2 – wenn-dann-sonst wie ( If -> Then ; Else ) statt. Noch besser, versuchen Sie zu bewachen solche Konstrukte gegen unbeabsichtigte Verwendungen durch die Ausstellung instantiation_errors. Oder verwenden Sie when/2 (angeboten in SWI, YAP, SICStus).

Grün schneidet

Schnitte, entfernen Sie nutzlos choicepoints (und auch redundante-Antworten) werden als grüne schneidet. Aber Vorsicht: Sie können nicht legen Sie Sie in Ihr Programm einfach durch drücken von ! und einige #00ff00. Die meisten der Zeit, müssen Sie eine saubere nur-lese-Wache, um sicherzustellen, dass es keine Möglichkeit gibt, dieser Schnitt dreht #ff0000. Es ist auch eine einfache Weise zu entfernen, einige übrig gebliebene choicepoints sicher: call_semidet/1. Hier sind einige ähnliche Fälle:
Schnitt nicht Begehen

Schließlich, lassen Sie mich darauf hinweisen, dass der Schnitt nicht eine commit-Betreiber. Manchmal wirkt ein bisschen wie Sie, aber würde eine Menge von Einschränkungen zu sein. Eine commit-operator nicht (ab)Umsetzung verwendet werden (\+)/1. Eine Begehung erfordert, dass jede Klausel wird versucht, unabhängig von einander. Jede Klausel muss daher eine vollständige Wache ; es kann sich nicht darauf berufen versucht, nur nach einige andere Klauseln wurden als erste ausprobiert. Auch ein commit stattfinden müsste in jeder Klausel ein Prädikat. Der Schnitt kann überall auftreten.

InformationsquelleAutor der Antwort false
13

Einen Schnitt verpflichtet das Prolog-Ziel beweisen zu den Wahlen gemacht.

Müssen Sie es dann, wenn der Programmierer weißdass eine alternative zur Verfügung muss nicht versucht werden.

Der prominentesten Stelle, es ist die Umsetzung von negation durch scheitern.
```
fact(a).
fact(b).

/* 1 */neg(X) :- call(X), !, fail.
/* 2 */neg(_).
```
Habe ich hier (re)definiert die standard-negation-operator, normalerweise ist es (\+)/1
```
?- neg(fact(c)).
true.
```
call(fact(c)) von Regel 1 kann nicht bewiesen werden, und die alternative Regel 2 dann gelingt es.
```
?- neg(fact(a)).
false.
```
weil fact(a) kann nachgewiesen werden, der Schnitt verwerfen die alternative, vor Versagen.
```
?- neg(fact(X)).
false.
```
gibt es mindestens eine unbekannte X, so dass fact(X) erfolgreich ist.
```
?- neg(neg(fact(X))).
true.
```
die doppelte negation hat den Effekt, dass die Variablen nicht bekommen gebunden. Dies kann nützlich sein, wenn dabei die meta-Programmierung, um die fetch-Klausel, ohne dass Ihre 'Struktur'. Von der operativen Sicht, es ist klar (?) was Los ist, aber das Programm tut, verliert seine deklarative Eigenschaft.

Andere Verwendung, nützlich nur in rudimentären Dolmetscher, wurde angewiesen, das system durchführen, um last-call-Optimierungindem der rekursive Aufruf mit einem Schnitt. Dann kann das system vermeiden, reservieren Platz auf dem stack, die normalerweise benötigt, um zu verfolgen Sie alternative zeigen. Ein dummy-Beispiel:
```
print_list([E|Es]) :- print_element(E), !, print_list(Es).
print_list([]).
```
Bearbeiten über ein tutorial: ich fand, dass '- Klausel und Wirkung "von William Clocksin enthält eine detaillierte Befragung im Zusammenhang zu schneiden: Kapitel 4" Auswahl und Engagement " es ist uneingeschränkt zu schneiden, vor-und Nachteile. An der unteren Linie, hauptsächlich Nachteile...

InformationsquelleAutor der Antwort CapelliC
11

Bevor Sie mit einem Schnitt, den ich verlangen, dass meine Prädikate treffen diese beiden Kriterien:
- es gibt richtige Antworten, ohne einen Schnitt
- es gibt richtige Antworten, wenn die Klauseln werden neu geordnet
Einmal mein Prädikat verhält sich so, dass ich manchmal fügen Sie einen Schnitt, trimmen Sie unerwünschte nondeterminism.

Zum Beispiel, ein Prädikat, um zu testen, ob eine Zahl positiv, negativ oder null ist.
```
sign(N, positive) :-
    N > 0.
sign(N, negative) :-
    N < 0.
sign(N, zero) :-
    N =:= 0.
```
Jede Klausel steht völlig unabhängig von den anderen. Ich kann neu anordnen, diese Klauseln oder entfernen einer Klausel und die übrigen Bestimmungen, noch geben die erwartete Antwort. In diesem Fall kann ich setzen Sie einen Schnitt am Ende des positive und negative Klauseln nur zu sagen, dass das Prolog-system, dass es nicht mehr findet Lösungen durch die Untersuchung der anderen Klauseln nicht.

Könnte man schreiben, ein ähnliches Prädikat, ohne schneiden durch die Verwendung -> ;aber einige nicht mögen, wie es aussieht:
```
sign(N, Sign) :-
    (   N > 0 -> Sign=positive
    ;   N < 0 -> Sign=negative
    ;            Sign=zero
    ).
```
InformationsquelleAutor der Antwort mndrix
0

Schnitte aber alle verschwunden aus meinem code, wenn ich fand die once Prädikat. Intern funktioniert es wie
```
once(X) :- X, !.
```
und ich fand es sehr nützlich für die Herstellung einer festen Entscheidung, wie etwas zu tun, bevor ich wusste, dass etwas.

Zum Beispiel, hier ist mein standard-meta-interpreter. Die maybe1/1 Klausel hat einzigartige funktoren in seinen Argumenten, so dass, sobald Sie bekannt ist, dann das Recht maybe1/1 ausgewählt werden können, perfekt.

Den job zu finden, die einzigartige Funktion ist gegeben, um die maybe0/2 pre-Prozessor setzt Y zu einem "was zu tun" Erklärung über X.

Ohne once könnte dies sein müsste, übersäht mit Schnitten. E. g. in maybe1 gibt es drei/zwei verschiedenen Interpretationen von X/Y,und or dass wir überprüfen müssen, die in einer top-down Weise. Aber probiert es aus - keine Schnitte.
```
maybe(X) :- 
    once(maybe0(X,Y)), maybe1(Y).

maybe0(true,       true).
maybe0((X,Y),      (X,Y)).
maybe0((X;Y),      or(L))          :- o2l((X;Y),L).
maybe0(X,          calls(X))       :- calls(X).
maybe0(X/Y,        fact(X/Y))      :- clause(X/_, true).
maybe0(X/Y,        rule(X/Y))      :- clause(X/_,_).
maybe0(X/Y,        abducible(X/Y)).
maybe0(or([H|T]),  or([H|T])).
maybe0(or([]),     true).

maybe1(true).
maybe1((X,Y))        :- maybe(X),maybe(Y).
maybe1((X;Y))        :- maybe(X);maybe(Y).
maybe1(abducible(X)) :- assume(X,0).
maybe1(fact(X))      :- assume(X,1), one(X).
maybe1(rule(X))      :- assume(X,2), one(clause(X,Y)), maybe(Y).
maybe1(calls(X))     :- one(clause(X,Y)), maybe(Y).
maybe1(or([H|T]))    :- any(One,Rest,[H|T]), ignore(maybe(One)), maybe(or(Rest)).
```
InformationsquelleAutor der Antwort Tim Menzies
0

Cut-Prädikat verhindert backtracking.Cut-Prädikat angegeben ist, wie ein Ausrufezeichen (!). Schneiden Sie die Pflaumen Suchbaum und verkürzt den Weg verfolgen, durch den prolog-interpreter.Semantisch ist es immer erfolgreich.
```
read(a).
read(b).
color(p, red) :- red(p).
color(p,black) :- black(p),!.
color(p,unknown).

?-color(X,Y).
  X = a,
  Y = red;
  X = b,
  Y = black;
```
Ohne schneiden der Ziele zeigt, Y=unbekannte nach Y=schwarz.

Es gibt zwei Arten von cut-Prädikat :

Grün Schnitt : Green cut ist eine Art von Schnitt, der hatte keinen Effekt auf die deklarative Bedeutung. Es ist nur die Verwendung zur Verbesserung der Effizienz sowie Vermeidung unnötiger Berechnung. Die Entfernung von green-Schnitt aus dem Programm nicht ändert die Bedeutung des Programms.

Red Schnitt : Red cut ist eine, die hatte Einfluss auf die deklarative Bedeutung. Die Entfernung von red cut aus dem Programm ändert die Bedeutung des Programms.

InformationsquelleAutor der Antwort rashedcs

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Rote Schnitte

Grün schneidet

Schnitt nicht Begehen