Chapter 6: Curt

Was wir erreicht haben:

Wir können First-Order-Repräsentationen kompositionell für einfache natürlichsprachliche Ausdrücke aufbauen. Außerdem können wir dabei Scope-Ambiguitäten berücksichtigen.
Wir wissen, wie wir Inferenzen mit First-Order-Repräsentationen automatisiert durchführen können.
Als nächstes verbinden wir diese beiden Elemente in einem Dialogsystem namens CURT, das unsere natürlichsprachlichen Aussagen einliest und auf Konsistenz und Informativität überprüft.

Baby Curt

Baby Curt bildet das Rückgrat des CURT-Systems.
Baby Curt enthält das Minimum an Inferenzwerkzeugen (nämlich keins, dies wird später ausgebaut), ist aber in der Lage natürlichsprachliche Sätze in logische Repräsentationen zu überführen.
Die Dialogkontrollstruktur wird implementiert durch curtTalk/2
Das Prädikat curtUpdate/4 aktualisiert die bisherige Wissensbasis, wenn weitere englische Sätze eingegeben wird und kümmert sich um metasprachliche Anweisungen.

Aufgabe: Konsultiere babyCurt.pl und starte den Curt-Dialog mit curt.. Folgende reservierte Befehle stehen während des Dialogs zur Verfügung:

readings: prints current readings
select N: select a reading (N should be a number)
new: starts a new discourse
history: shows history of discourse
models: prints current models
summary: eliminate equivalent readings
knowledge: calculate and show background knowledge
infix: display formulas in infix notation
prefix: display formulas in prefix notation
bye: no more talking
help: zeigt die Liste der reservierten Befehle

Teste ein paar Dialoge (zur Erinnerung das Lexikon findest du in englischLexicon.pl).

Studiere die Implementierung in babyCurt.pl und curtPredicates.pl

Zentrale Klausel:

curtUpdate(Input,[accept],run):-
   kellerStorage(Input,Readings), !,
   updateHistory(Input),
   combine(Readings,NewReadings),
   updateReadings(NewReadings).

Neue Äußerung wird mit bisherigen Äußerungen verknüpft:

% combine(Readins,Updated)
% Readings: Lesarten der neuen Äußerung
% Updated: Lesarten der neuen Äußerung verknüpft mit den bisherigen Äußerungen

combine(New,New):-
   readings([]).

combine(Readings,Updated):-
   readings([Old|_]),   
   findall(and(Old,New),memberList(New,Readings),Updated).

Aufgabe: Die Zeile readings([Old|_]), sorgt dafür, dass nur die erste der bisherigen Lesarten im weiteren Verlauf beachtet wird, alle anderen werden vergessen. Ändere den Code so, dass keine Lesart mehr vergessen wird.

Rugrat Curt

Rugrat Curt erweitert Baby Curt um ein Inferenzwerkzeug, das die Eingabe auf Konsistenz überprüft.
rugrat=Hosenscheißer/Kleinkind

rugratCurt.pl

Rugrat Curt zeigt erstes Textverständnis:

> mia does smoke.

Curt: OK.

> mia does not smoke.

Message (consistency checking): proof found.
Curt: No! I do not believe that!

Zentrale Klauseln:

curtUpdate(Input,Moves,run):-
   kellerStorage(Input,Readings), !,
   updateHistory(Input),
   consistentReadings(Readings,[]-ConsReadings),
   (
      ConsReadings=[],
      Moves=[contradiction]
   ;  
      \+ ConsReadings=[],
      Moves=[accept],
      combine(ConsReadings,CombinedReadings), 
      updateReadings(CombinedReadings)
   ).


/*========================================================================
   Select Consistent Readings
========================================================================*/

consistentReadings([],C-C).

consistentReadings([New|Readings],C1-C2):-
   readings(Old),
   (
      consistent(Old,New), !,
      consistentReadings(Readings,[New|C1]-C2) 
   ;
      consistentReadings(Readings,C1-C2) 
   ).


/*========================================================================
   Consistency Checking calling Theorem Prover 
========================================================================*/

consistent([Old|_],New):-
   rprove(not(and(Old,New))), !,
   nl, write('Message (consistency checking): proof found.'),
   fail.

consistent([],New):-
   rprove(not(New)), !,
   nl, write('Message (consistency checking): proof found.'),
   fail.

consistent(_,_).

Aufgabe: Erkläre, wie Rugrat Curt auf Inkonsistenzen prüft.

Aufgabe: Ändere Rugrat Curt so, dass nicht nur die erste Lesart, sondern alle Lesarten weiter beachtet werden.

Aufgabe: Teste einige Beispielsätze und schaue ob du Beispiele findest, die entweder nicht korrekt bearbeitet werden oder die sehr lange brauchen.

Aufgabe: Ändere Rugrat Curt, so dass statt der Storage-Methode Hole-Semantik genutzt wird.

Aufgabe: Ändere Rugrat Curt, so dass für die Inferenzen die Resolutionsmethode genutzt wird.

Kahoot: Schaut euch vor dem kommenden Kahoot die Datei curtPredicates.pl an und habt sie griffbereit.

Rugrat Curt kann noch nicht alle Inkonstistenzen aufdecken. Probleme für Rugrat Curt:

> every woman smokes.

Curt: OK.

> mia is a woman.

Curt: OK.

> mia does not smoke.

Curt: OK.

Aufgabe: Wieso erkennt Rugrat Curt diesen Widerspruch nicht? Wie könnte man dieses Problem lösen?

Clever Curt

Clever CURT akzeptiert nur konsistente englische Sätze.
Der Nutzer kann sich auch die Modelle ansehen, die für die an CURT übergebenen englischen Sätze erzeugt wurden.
Ambige Eingaben könnten einige der inkonsistenten Interpretationen beseitigen.
Clever CURT verwendet den Model Builder MAZE zur Konsistenzprüfung und den Theorem Prover VAMPIRE oder OTTER zur Überprüfung der Inkonsistenz von Interpretationen.

zentrale Klauseln:

curtUpdate(Input,Moves,run):-
   kellerStorage(Input,Readings), !,
   updateHistory(Input),
   consistentReadings(Readings,[]-ConsReadings,[]-Models),
   (
      ConsReadings=[],
      Moves=[contradiction]
   ;  
      \+ ConsReadings=[],
      Moves=[accept],
      combine(ConsReadings,CombinedReadings), 
      updateReadings(CombinedReadings),
      updateModels(Models)
   ).

/*========================================================================
   Select Consistent Readings
========================================================================*/

consistentReadings([],C-C,M-M).

consistentReadings([New|Readings],C1-C2,M1-M2):-
   readings(Old),
   (
      consistent(Old,New,Model), !,
      consistentReadings(Readings,[New|C1]-C2,[Model|M1]-M2) 
   ;
      consistentReadings(Readings,C1-C2,M1-M2) 
   ).


/*========================================================================
   Consistency Checking calling Theorem Prover and Model Builder
========================================================================*/

consistent([Old|_],New,Model):-
   DomainSize=15,
   callTPandMB(not(and(Old,New)),and(Old,New),DomainSize,Proof,Model,Engine),
   format('~nMessage (consistency checking): ~p found a result.',[Engine]),
   \+ Proof=proof, Model=model([_|_],_).

consistent([],New,Model):-
   DomainSize=15,
   callTPandMB(not(New),New,DomainSize,Proof,Model,Engine),
   format('~nMessage (consistency checking): ~p found a result.',[Engine]),
   \+ Proof=proof, Model=model([_|_],_).

Aufgabe: Erklären sie, wie Clever Curt auf Inkonsistenzen prüft.

Sensitive Curt

Sentitive Curt ist clever! (Er weiß, was Konsistenz bedeutet.)
Sensitive Curt bemerkt auch uninformative Beiträge des Benutzers.
Dazu prüft er mit MACE und VAMPIRE oder OTTER, ob neue Beiträge informativ in Bezug auf die Readings sind, die CURT in seinem Speicher hat.

curtUpdate(Input,Moves,run):-
   kellerStorage(Input,Readings), !,
   updateHistory(Input),
   consistentReadings(Readings,[]-ConsReadings,[]-Models),
   (
      ConsReadings=[],
      Moves=[contradiction]
   ;
      \+ ConsReadings=[],
      informativeReadings(ConsReadings,[]-InfReadings),   
      (
         InfReadings=[],
         Moves=[obvious]
      ;  
         \+ InfReadings=[],
         Moves=[accept]
      ),
      combine(ConsReadings,CombinedReadings), 
      updateReadings(CombinedReadings),
      updateModels(Models)
   ).


/*========================================================================
   Select Informative Readings
========================================================================*/

informativeReadings([],I-I).

informativeReadings([New|L],I1-I2):-
   readings(Old),
   (
      informative(Old,New), !,
      informativeReadings(L,[New|I1]-I2) 
   ;
      informativeReadings(L,I1-I2) 
   ).


/*========================================================================
   Informativity Checking calling Theorem Prover
========================================================================*/

informative([Old|_],New):-
   DomainSize=15,
   callTPandMB(not(and(Old,not(New))),and(Old,not(New)),DomainSize,Proof,Model,Engine),
   format('~nMessage (informativity checking): ~p found a result.',[Engine]),
   \+ Proof=proof, Model=model([_|_],_).

informative([],New):-
   DomainSize=15,
   callTPandMB(New,not(New),DomainSize,Proof,Model,Engine),
   format('~nMessage (informativity checking): ~p found a result.',[Engine]),
   \+ Proof=proof, Model=model([_|_],_).

Aufgabe: Erklären sie, wie Sensitive Curt auf Informativität prüft.

Betrachte den folgenden Textverlauf. Folgt der letzte Satz logisch aus den ersten beiden? Ist er also uninformativ? Was sagt Curt und warum?

Aufgabe: Was passiert, wenn man a woman durch mia ersetzt?

Aufgabe: Überprüfe für beide Fälle nach jeder neuen Eingabe die Lesarten.

Aufgabe: Ändere den Code so dass keine früheren Lesarten vergessen werden, außer sie sind inkonsistent.

Sensitive Curt ist nicht in der Lage äquivalente Lesarten zu erkennen und zu elminieren:

Scrupuolous Curt

Scrupuolous Curt eliminiert äquivalente Readings mit Hilfe des Theorem Provers OTTER.
Gegeben R1 und R2 aus einer Menge von Readings, werden R1 und R2 durch R1 ersetzt, wenn OTTER einen Beweis findet für:
- ((R1 → R2) & (R2 → R1))
Beachte, dass dies nicht notwendigerweise effizient ist.

Aufgabe: Wo in scrupulousCurt.pl werden äquivalente Lesarten eliminiert?

Knowledgeable Curt

Schaue dir folgende Dateien an:

lexicalKnowledge.pl
worldKnowledge.pl
situationalKnowledge.pl
backgroundKnowledge.pl
knowledgeableCurt.pl

Was wird in den ersten 3 Dateien beschrieben?