Curt:

What we have reached:

We can build first-order representations in a compositional way for simple natural language expressions. Moreover, we can do so in a way that takes scope ambiguities into account.

We know how to automate the process of performing inference with first-order representations.

Baby Curt

Aufgabe: Konsultiere babyCurt.pl und starte den Curt-Dialog mit curt.. Folgende reservierte Befehle stehen während dem Dialog 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.

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

Rugrat Curt (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ären sie, wie Rugrat Curt auf Inkonsistenzen prüft.

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

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

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 (auch Laconic Curt)

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?

Helpful Curt (auch Super Curt)

Blackburn and Bos: Representation and Inference of Natural Language

Chapter 6: Curt

Wiebke Petersen