Verschachtelte Listen, Differenzlisten, Graphen Prolog Grundkurs WS 99/00 Christof Rumpf [email protected]

Verschachtelte Listen, Differenzlisten, Graphen

Prolog Grundkurs WS 99/00

Christof Rumpf

[email protected]

29.11.99 GK Prolog - Verschachtelte Listen, Differenzlisten, Graphen

2

Listenverarbeitung bisher

member/2 append/3 delete/3 reverse/2 reverse/3 permute/2 sort/2 qs/2 partition/4

Listenelemente finden

Listen konkatenieren

Listenelemente löschen/einfügen

Liste umkehren (naiv)

Liste umkehren (mit Akkumulator)

Liste permutieren (n!)

Liste permutationssortieren (n!)

Liste mit Quicksort sortieren (n log n)

Liste in Teillisten partitionieren


3

deleteall/3

% deleteall(Term,Liste1,Liste2) deleteall(_,[],[]). deleteall(X,[X|T1],L):- deleteall(X,T1,L). deleteall(X,[H|T1],[H|T2]):- X \= H, deleteall(X,T1,T2).

Termination

Lösche X aus Kopf

Lösche X aus Rest T1

Behalte Kopf H,

falls H X

Lösche X aus Rest T1

deleteall/3 löscht alle Vorkommen eines Terms aus einer Liste, während delete/3 genau ein Vorkommen eines Terms löscht und scheitert, wenn der Term nicht vorkommt.


4

makeset/3

% makeset(Liste1,Liste2) makeset([],[]).

makeset([H|T1],[H|T2]):- deleteall(H,T1,L), makeset(L,T2).

Termination. Behalte Kopf H. Löschen aller H aus T1 liefert L. Entferne alle Duplikate aus L.

makeset/2 entfernt mit Hilfe von deleteall/3 alle Duplikate aus Liste1 und liefert Liste2 als Ergebnis.


5

Verschachtelte Listen

Als Listenelemente können beliebige Terme auftreten, also auch Listen.

[1,2,3,[a,b,[x,y],c],4,5,[],6]

Die Verarbeitung von Listen von Listen erfordert häufig doppelte Rekursion, sodaß bei einer Zerlegung nicht nur der Rest, sondern auch der Kopf rekursiv weiterverarbeitet wird.


6

Verflachen von Listen

Das Prädikat flatten/2 wandelt eine verschachtelte Liste in flache Liste um.

?- flatten([1,2,3,[a,b,[x,y],c],4,5,[],6],L). L = [1,2,3,a,b,x,y,c,4,5,6] yes


7

flatten/2

%flatten(VerschachtelteListe, FlacheListe) flatten([],[]).

flatten([H|T],FL):- flatten(H,FH), flatten(T,FT), append(FH,FT,FL).

flatten(X,[X]):- X \= [], X \= [_|_].

Leere Liste ist schon flach.

Zerlege verschachtelte Liste.

Verflache Kopf.Verflache Rest.Konkateniere verflachten Kopf und Rest zu Ergebnis.

Term in flache Liste packen,falls Term keine Liste ist.


8

Effizienz von flatten/2

flatten/2 hat nach dem zweiten rekursiven Aufruf einen Aufruf von append/3. Dies drückt die Performance ähnlich nach unten, wie wir es schon beim naiven reverse/2 gesehen haben.

Verbesserung: flatten/3 mit Akkumulator!


9

flatten/3

flatten(VL,FL):- flatten(VL,[],FL). flatten([],[],[]). flatten([],[H|Acc],FL):- flatten(H,Acc,FL). flatten([H|T],Acc,FL):- is_list(H), flatten(H,[T|Acc],FL). flatten([H|T1],Acc,[H|T2]):- not is_list(H), flatten(T1,Acc,T2).

flatten/2 ruft flatten/3 auf.

Initialisierung des Akkumulators.

Termination.

Falls verschachtelte Liste leer,

verflache Kopf des Akkumulators.

Falls Kopf von VL nichtleere Liste,

nimm Rest von VL in Akkumulator

und verflache H.

Falls Kopf von VL keine Liste ist,

übernimm den Kopf in flache Liste

und verflache Rest von VL.


10

is_list/1

Das Prädikat is_list/1 ist beweisbar, wenn das Argument eine leere oder nichtleere Liste ist.

is_list([]). is_list([_|_]). Aus Effizienzgründen verzichten wir auf

Korrektheit für is_list/1 , indem wir auf den rekursiven is_list/1 -Beweis für Restlisten nichtleerer Listen verzichten.


11

(2) CALL: flatten([1,2,3,[a,b,[x,y,z],c],4,[],5,6], [], _0098) ? > (5) CALL: flatten( [2,3,[a,b,[x,y,z],c],4,[],5,6], [], _0AB8) ? > (8) CALL: flatten( [3,[a,b,[x,y,z],c],4,[],5,6], [], _0C14) ? > (11) CALL: flatten( [[a,b,[x,y,z],c],4,[],5,6], [], _0D70) ? > (13) CALL: flatten( [a,b,[x,y,z],c], [[4,[],5,6]], _0D70) ? > (16) CALL: flatten( [b,[x,y,z],c], [[4,[],5,6]], _11E4) ? > (19) CALL: flatten( [[x,y,z],c], [[4,[],5,6]], _1340) ? > (21) CALL: flatten( [x,y,z], [[c],[4,[],5,6]], _1340) ? > (24) CALL: flatten( [y,z], [[c],[4,[],5,6]], _17B4) ? > (27) CALL: flatten( [z], [[c],[4,[],5,6]], _1910) ? > (30) CALL: flatten( [], [[c],[4,[],5,6]], _1A6C) ? > (34) CALL: flatten( [], [[4,[],5,6]], _1D00) ? > (35) CALL: flatten( [4,[],5,6], [], _1D00) ? > (38) CALL: flatten( [[],5,6], [], _1F94) ? > (40) CALL: flatten( [], [[5,6]], _1F94) ? > (41) CALL: flatten( [5,6], [], _1F94) ? > (44) CALL: flatten( [6], [], _2540) ? > (47) CALL: flatten( [], [], _269C) ? > (47) EXIT(N): flatten( [], [], []) (44) EXIT(N): flatten( [6], [], [6]) (41) EXIT(N): flatten( [5,6], [], [5,6]) (40) EXIT(N): flatten( [], [[5,6]], [5,6]) (38) EXIT(N): flatten( [[],5,6], [], [5,6]) (35) EXIT(N): flatten( [4,[],5,6], [], [4,5,6]) (34) EXIT(N): flatten( [], [[4,[],5,6]], [4,5,6]) (31) EXIT(N): flatten( [c], [[4,[],5,6]], [c,4,5,6]) (30) EXIT(N): flatten( [], [[c],[4,[],5,6]], [c,4,5,6]) (27) EXIT(N): flatten( [z], [[c],[4,[],5,6]], [z,c,4,5,6]) (24) EXIT(N): flatten( [y,z], [[c],[4,[],5,6]], [y,z,c,4,5,6]) (21) EXIT(N): flatten( [x,y,z], [[c],[4,[],5,6]], [x,y,z,c,4,5,6]) (19) EXIT(N): flatten( [[x,y,z],c], [[4,[],5,6]], [x,y,z,c,4,5,6]) (16) EXIT(N): flatten( [b,[x,y,z],c], [[4,[],5,6]], [b,x,y,z,c,4,5,6]) (13) EXIT(N): flatten( [a,b,[x,y,z],c], [[4,[],5,6]], [a,b,x,y,z,c,4,5,6]) (11) EXIT(N): flatten( [[a,b,[x,y,z],c],4,[],5,6], [], [a,b,x,y,z,c,4,5,6]) (8) EXIT(N): flatten( [3,[a,b,[x,y,z],c],4,[],5,6], [], [3,a,b,x,y,z,c,4,5,6]) (5) EXIT(N): flatten( [2,3,[a,b,[x,y,z],c],4,[],5,6], [], [2,3,a,b,x,y,z,c,4,5,6]) (2) EXIT(N): flatten([1,2,3,[a,b,[x,y,z],c],4,[],5,6], [],[1,2,3,a,b,x,y,z,c,4,5,6])


12

Graphen

Viele Probleme lassen sich graphentheoretisch modellieren. Ein Graph ist ein mathematisches Objekt mit klar definierten Eigenschaften und Methoden.

Bäume sind Graphen mit speziellen Eigenschaften. Wir nähern uns jetzt Bäumen an, indem wir von gerichteten Graphen über DAGs zu geordneten Bäumen kommen.


13

Gerichteter Graph

Ein gerichteter Graph G ist ein Tupel <N, E>, wobei N(odes) eine Menge von Knoten und E(dges) eine Menge E N × N von Kanten ist.

G1 = <{a,b,c,d,e}, {<a,b>,<a,c>,

<b,d>,<d,c>, <d,e>,<d,a>}>

a

b c

d

e


14

Prolog-Repräsentation: Graph

als Fakten:

node(a). ... node(e). edge(a,b). ... edge(d,a).

als Struktur:

([a,b,c,d,e], [(a,b),(a,c), (b,d),(d,c), (d,e),(d,a)])


15

Transitive Hülle

Die transitive Hülle eines Graphen G= <N, E> ist die Menge H(G) N × N, sodaß gilt:

1. E H(G) 2. <x, y> H(G) <y, z> H(G)

<x, z> H(G)

Die transitive Hülle liefert uns alle Verbindungen, die zwischen Knoten bestehen.


16

Berechnung in Prolog

Transitive Hülle für Faktenrepräsentation: closure(X,Y):- edge(X,Y). closure(X,Y):- edge(X,Z), closure(Z,Y)

Transitive Hülle für Listenrepräsentation: closure(X,Y,E):- member((X,Y),E). closure(X,Y,E):- member((X,Z),E),

closure(Z,Y,E). % E = [(N1,N2),...,(Ni,Nk)]


17

DAG

Ein gerichteter azyklischer Graph (DirectedAcyclicGraph) G = <N, E> ist ein Graph, für den gilt:

<x, y> H(G): x y

Kein Knoten ist in H(G) mit sich selbst verbunden.


18

Bäume

Ein DAG G = <N, E> ist ein Baum, wenn gilt:

x,y,z N: <x, z> E <y, z> E x = y

Jeder Knoten in einem Baum hat maximal einen Vorgänger.


19

Geordnete Bäume

Ein geordneter Baum G = <N, E, O> ist ein Baum mit einer totalen Ordnungsrelation O N × N, sodaß gilt:

x,y,z N: <x, y> E <x, z> E y z <y, z> O <z, y> O

Die unmittelbaren Nachfolger eines Knotens stehen in einer linearen Ordnung.


20

Beispiel Syntaxbaum

S

NP VP

Det N V NP

Jeder Mann liebt Det N

eine Frau

Zwei Relationen:

unmittelbare Dominanz zwischen Mutter- und Tochterknoten

lineare Präzedenz zwischen Tocherknoten


21

Lineare Repräsentation in Prolog

als Struktur: s(np(det(jeder),n(mann)), vp(v(liebt),np(det(eine),n(frau))))

als Liste: [s, [np, [det, [jeder]], [n, [mann]]],

[vp, [v, [liebt]], [np, [det, [eine]], [n, [frau]]]]]


22

Univ

Strukturen und Listen können ineinander überführt werden. Prolog stellt dazu das eingebaute Prädikat =.. (Univ) zur Verfügung.

?- det(ein) =.. L. ?- np(det(ein),n(mann)) =.. L.

L = [det,ein], yes L = [np,det(ein),n(mann)] ?- S =.. [det,ein]. S = det(ein), yes Allgemein:

p(A1,...An) =.. [p,A1,...An]


23

Listen vs. Strukturen

Strukturen sind zwar für das menschliche Auge leichter zu überblicken, dafür sind Listenreprä-sentationen allerdings flexibler zu verarbeiten.– Strukturen: Zugriff auf Argumente nur bei

bekanntem Funktor und bekannter Stelligkeit möglich.

– Listen: Zerlegung in Kopf und Rest für jede nichtleere Liste in gleicher Weise.


24

Pretty Printing ?- pp(s(np(det(jeder),n(mann)),

vp(v(liebt),np(det(eine),n(frau))))) s

np det jeder n mann vp v liebt np det eine n frau

Ein Pretty-Printer für Bäume ist ein Programm, das die lineare Repräsentation eines Baumes als eingerückten Baum auf den Bildschirm ausgeben kann.


25

Handwerkszeug zum Drucken

Wir benötigen ein paar eingebaute Prädikate, um einen Pretty-Printer implementieren zu können:

write(Term) Schreibt Term auf den Bildschirm.

nl Bewirkt einen Zeilenvorschub. tab(Integer) Schreibt 0-n Leerzeichen. Number is Expr Führt Berechnungen durch.


26

pprint/1

pprint(Term):- pprint(Term,0). Initialisierung des Tab-Zählers.

pprint(Term,N):- Baum drucken. tab(N), write(F), nl, Ausgabe des Mutterknotens. N1 is N+3, Tabulator erhöhen. pprintl(Args,N1). Unterbäume drucken.

pprintl([H|T],N):- Unterbäume drucken. pprint(H,N), Drucke eine Schwester. pprintl(T,N). Drucke die anderen Schwestern. pprintl([],_). Termination.


27

Differenzlisten

Eine Differenzliste ist ein Paar von Listen (L1,L2), wobei L2 ein Suffix von L1 repräsentiert. Die Elemente einer Differenzliste sind die nach Abzug von Suffix L2 verbleibenden Elemente in L1.

Differenzliste gewöhnliche Liste ([E1,...,En|T],T)[E1,...,En] (L,[]) L (L,L) []


28

[1,2,3] als Differenzliste

Für jede gewöhnliche Liste gibt es unendlich viele Darstellungen als Differenzliste, weil es beliebige Suffixe geben kann.

[1,2,3] ([1,2,3],[]) ([1,2,3,4,5],[4,5]) ([1,2,3,a,b|T],[a,b|T])

([1,2,3|T],T)


29

Konkatenation von Diff-Listen

Differenzlisten haben einen entscheidenden Vorteil gegenüber gewöhnlichen Listen: Man kann sie in konstanter Zeit konkatenieren. Genauer: in einem Schritt.

?- D1 = ([1,2,3|T1],T1), D2 =([4,5,6|T2],T2), append_dl(D1,D2,D3). D3 = ([1,2,3,4,5,6|T2],T2), yes


30

append_dl/3

append_dl((A,B),(B,C),(A,C)).

Documents

Verschachtelte Listen, Differenzlisten, Graphen Prolog Grundkurs WS 99/00 Christof Rumpf [email protected]