Geschiedenis van de informatica: Het ontstaan van logisch programmeren

Transcriptie

1 Geschiedenis van de informatica: Het ontstaan van logisch programmeren Bram Senders november 2008 Samenvatting Dit artikel geeft een overzicht van het ontstaan van logisch programmeren, van de eerste ideeën op dit gebied tot aan het moment waarop logisch programmeren als volwaardig onderzoeksgebied werd beschouwd. Het werd geschreven als afsluiting voor het vak Geschiedenis van de informatica (2R930), aan de Technische Universiteit Eindhoven.

2

3 Inhoudsopgave 1 Introductie 2 2 De eerste beginselen Newell, Simon en Shaw: Logic Theorist John McCarthy en zijn Advice Taker Cordell Green s QA1, QA2 en QA SIR QA Afleiding door resolutie QA Van vraag-antwoord naar probleemoplossing Robert Kowalski: logica als programmeertaal 8 5 Conclusie 11 1

4 1 Introductie In het boek Logic Programming uit 1982 van Clark en Tärnlund wordt logisch programmeren als volgt gekarakteriseerd: The key premise of logic programming is that computation is controlled inference. [CT82, p. vii] En in hetzelfde boek, in een artikel van Robert Kowalski: Recent developments in automated deduction [... ] have resulted in efficient schemes for processing logic by computer. These developments in turn have lead to the increasing use of logic as a very high level programming language. [CT82, p. 3] Zowel controlled inference als automated deduction wijzen op hetzelfde idee, namelijk gegeven een stel logische feiten of stellingen, het geautomatiseerd afleiden van nieuwe stellingen en feiten. Geautomatiseerd wijst in dit geval op het afleiden met behulp van de computer; het kan dus gezegd worden dat logisch programmeren niets anders is dan om met een computer op een gecontroleerde manier nieuwe feiten af te leiden uit bestaande feiten. In dit artikel zullen we zien hoe het vakgebied van logisch programmeren ontstaan is. Het doel van dit artikel is niet om alle ontwikkelingen op dit gebied in ogenschouw te nemen daar is het veel te breed voor maar om een kijkje te nemen in de ontwikkeling van de theorie erachter. Implementaties van specifieke programmeertalen (zoals Prolog, de bekendste logische programmeertaal) worden niet behandeld; wel de principes waar deze talen op gegrond zijn. Er zijn meerdere paden geweest die tot de ontwikkeling van logisch programmeren hebben geleid; ook dit zijn er helaas te veel om allemaal te volgen, dus zijn enkele specifieke hoogtepunten in de geschiedenis uitgelicht: in sectie 2 worden twee vroege ontwikkelingen, de Logic Theorist en de Advice Taker, aangestipt; in sectie 3 worden de vraag-antwoordsystemen van Cordell Green besproken, en de resolutie-techniek die er gebruikt wordt en zeer belangrijk zou blijken te zijn voor verdere ontwikkeling van logisch programmeren. Tenslotte wordt in sectie 4 het werk van Robert Kowalski waardoor definitief het vakgebied van logisch programmeren werd gevestigd. 2 De eerste beginselen In deze sectie worden twee ontwikkelingen besproken, namelijk de Logic Theorist en het idee van de Advice Taker, die een eerste stap vormden in de richting van logisch programmeren. 2

5 2.1 Newell, Simon en Shaw: Logic Theorist Zoals al gezegd bestaat logisch programmeren voor een belangrijk deel uit het met behulp van de computer automatisch afleiden van stellingen, en het eerste computerprogramma wat automatisch bewijzen kon oplossen verdient dus de nodige aandacht. Dit programma was de Logic Theory Machine, of kortweg Logic Theorist, dat werd ontwikkeld door Alan Newell, Herbert Simon en J.C. Shaw bij RAND Corporation in 1955 en De Logic Theorist (LT) werd ontwikkeld in een speciaal voor dat doel geschreven taal, IPL (Information Processing Language). In het begin was er nog geen implementatie van die taal, dus voor de eerste bewijzen m.b.v. LT werden programma s op indexkaarten geschreven en met de hand gesimuleerd: In January 1956, we assembled my wife and three children together with some graduate students. To each member of the group, we gave one of the cards, so that each one became, in effect, a component of the computer program. [Cre92, p. 45] Later zou het programma alsnog op een computersysteem geïmplementeerd worden. LT was gebaseerd op het logische systeem uit Principia Mathematica ( ) van Whitehead en Russel; niet omdat dat op dat moment nog een actueel werk was, maar omdat Herbert Simon het toevallig in de kast had staan. Het ging hiervoor dan ook niet om het actueel zijn van het onderliggende logische systeem, maar: There was no intention of making a contribution to symbolic logic, and the system of Principia was sufficiently outmoded by that time as to be inappropriate for that purpose. For us, the important consideration was not the precise task, but its suitability for demonstrating that a computer could discover problem solutions in a complex nonnumerical domain by heuristic search that used humanoid heuristics. [Sim98, p. 68] De Logic Theorist kon dan ook stellingen bewijzen uit Principia Mathematica (PM), niet door op elke stap in een bewijs alle mogelijke afleidingsregels te overwegen (want dat zou exponentieel veel mogelijke bewijsstappen opleveren), maar door met behulp van heuristieken te bepalen welke van de afleidingsregels mogelijk toegepast zou moeten worden: The problem will be solved if we can devise a program for constructing chains of theorems, not at random, but in response to cues that make discovery of a proof probable within a reasonable computing time. For example, suppose the rules of inference were such as to permit any given proof chain to be continued, on the average, in ten different ways. Then there would be ten thousand proofs chains four steps in length (10 4 ). The expected number of proof chains that would have to be examined to find any particular proof by random search is five thousand. Suppose, however, that LT responded to 3

6 cues that permitted eight of the ten continuations at each step to be eliminated from consideration. Then the number of proof chains four steps in length that would have to be examined in full would be only sixteen (2 4 ), and the expected number would be only eight. [NS56, p. 68] De Logic Theorist heeft uiteindelijk 38 van de eerste 52 stellingen bewezen uit hoofdstuk 2 van Principia Mathematica; een van die bewijzen was zelfs eleganter dan het bewijs uit PM zelf. 2.2 John McCarthy en zijn Advice Taker De informaticus John McCarthy was een van de eersten die met het idee kwam om met behulp van de computer vraagstukken op te lossen door met predicatenlogica te werken. Hij kwam met dit voorstel in een artikel uit 1959, getiteld Programs with common sense [McC59]. In dat artikel refereert McCarthy naar de Logic Theorist: The main difference between [the Advice Taker] and other programs or proposed programs for manipulating formal languages (the Logic Theory Machine of Newell, Simon and Shaw and the Geometry Program of Gelernter) is that in the previous programs the formal system was the subject matter but the heuristics were all embodied in the program. In this program the procedures will be described as much as possible in the language itself and, in particular, the heuristics are all so described. The main advantages we expect the advice taker to have is that its behavior will be improvable merely by making statements to it, telling it about its symbolic environment and what is wanted from it. To make these statements will require little if any knowledge of the program or the previous knowledge of the advice taker. [McC59, p. 75]. McCarthy was dus de eerste die voorstelde om de procedures en heuristieken in de taal zelf te beschrijven, en niet ingebakken in het programma wat ze uitvoert. Het idee was dat de advice taker gezond verstand (common sense) zou hebben, doordat het uit zichzelf vanuit een verzameling feiten nieuwe gevolgtrekkingen zou kunnen deduceren. Wij herkennen dit nu als zijnde logisch programmeren. McCarthy s advice taker was op dat moment echter slechts een idee zonder implementatie; dergelijke systemen zouden pas later daadwerkelijk geïmplementeerd worden. Qua idee was McCarthy op dat moment zijn tijd wel vooruit. 3 Cordell Green s QA1, QA2 en QA3 Cordell Green ontwikkelde rond 1967 drie vraag-antwoordsystemen (question answering systems) in samenwerking met Bertram Raphael; QA1 (Question 4

7 Answerer 1), QA2 en QA3. Vraag-antwoordsystemen stonden aan de wieg van het ontstaan van het volledige systeem van logisch programmeren, en dus is het relevant om deze drie systemen en hun ontstaansgeschiedenis te bespreken. 3.1 SIR De oorsprong van de QA-systemen ligt bij het SIR (Semantic Information Retrieval) systeem van Bertram Raphael [Rap64], een systeem geschreven in LISP, ontwikkeld om vragen in menselijke taal begrijpen en te beantwoorden. Het probleem van het SIR-systeem was dat het een erg ad-hoc systeem was; voor elk type vraag wat er aan het systeem gesteld kon worden, was aparte logica en datastructuren ingebouwd om deze vraag op te kunnen lossen. Het was dus geen flexibel systeem, en was daarom moeilijk uit te breiden met nieuwe soorten vragen en datastructuren [GR68, p. 170]. 3.2 QA1 Om over dit probleem heen te komen, kwam Green samen met Raphael op het idee om het opslaan van logische feiten (zowel algemeen heersende feiten zoals het feit dat een subset-relatie op verzamelingen transitief is, als feiten die specifiek gaan over de data waarover vragen gesteld kunnen worden, zoals het feit dat een zekere John een jongen is) los te koppelen van het gebruiken van die feiten om nieuwe feiten te deduceren. Het afleiden van nieuwe feiten uit oude, en het beantwoorden van vragen aan het systeem, gebeurde met behulp van de modus ponens-techniek: als je hebt P Q, en je hebt P, dan heb je ook Q. Hierbij is ook substitutie mogelijk: als je hebt P (X) Q(X) voor willekeurige X, en je hebt P (foo), dan kan je foo substitueren voor X in de implicatieregel en dus met modus ponens Q(foo) afleiden. QA1 wordt verder beschreven in hun artikel uit 1968, The use of theorem-proving techniques in question-answering systems [GR68, pp ]. 3.3 Afleiding door resolutie Het principe van computergestuurd bewijzen was nu gevestigd, maar het was nog steeds erg lastig om op het juiste moment de juiste afleidingsregels toe te passen. Voordat dit efficiënter gedaan zou kunnen worden, zou er dus eerst iets moeten veranderen waardoor dit proces versimpeld zou worden. Deze verandering kwam van de hand van J.A. Robinson, die in 1965 een artikel publiceerde getiteld A machine-oriented logic based on the resolution principle [Rob65]. Hierin bracht hij naar voren dat bestaande bewijssystemen voor predicatenlogica ontwikkeld waren voor menselijk gebruik, en dat computergestuurd bewijzen beter zou gaan met een bewijssysteem wat specifiek voor dat doel was ontwikkeld. Hij stelt een systeem voor met slechts één afleidingsregel, die hij de resolutie-regel noemt. Deze regel werkt simpel gezegd als volgt: Je hebt een aantal clausules, en elke clausule is een disjunctie van literals, en elke literal is ofwel een variabele, of de negatie van een variabele. De lege clausule een clausule bestaande uit nul disjuncties is gelijk aan false. Een clausule zou 5

8 bijvoorbeeld zijn: P Q R. Elke logische formule is om te schrijven naar een verzameling clausules, door ten eerste de formule om te schrijven naar een conjunctieve normaalvorm (CNF), en daarna elke disjunctie als aparte clausule te nemen. Resolutie houdt nu het volgende in: Als je twee clausules hebt, de ene (met n literals) van de vorm a 1... a i... a n en een tweede (met m literals) van de vorm b 1... b j... b m waarbij geldt dat b j = a i, dan kan daarvan met behulp van resolutie een nieuwe clausule worden afgeleid die de disjunctie is van de twee oorspronkelijke clausules, zonder a i en b j, waardoor je krijgt: a 1... a i 1 a i+1... a n b 1... b j 1 b j+1... b m Een simpel voorbeeld: Als geldt dat P Q R, en T Q, dan kan daaruit worden afgeleid dat P R T. Net als bij modus ponens kan hierbij ook substitutie gebruikt worden, zodat uit P Q(X) R(X) en T (foo) Q(foo) kan worden afgeleid dat P R(foo) T (foo). 3.4 QA2 Green en Raphael wilden met hun nieuwe systeem QA2 laten zien dat een echte theorem prover die gebruik maakt van de resolutie-techniek gebruikt kon worden om als vraag-antwoord systeem te werken. Ze wijden het tweede deel van hun The use of theorem-proving techniques in question-answering systems - artikel aan het uitweiden over de theorie hierachter [GR68, pp ], en het beschrijven van QA2 zelf [GR68, pp ]. Hoe wordt resolutie gebruikt in QA2? Een vraag aan het systeem is in zijn algemeenheid van de vorm: Geef een X zodat P (X) waar is, waarbij P (X) een predicaat is met X erin. Het vinden van een dergelijke X gaat via een bewijs uit het ongerijmde (reductio ad absurdum): We stellen P (X), en converteren deze stelling naar conjunctieve normaalvorm; de clausules die dit oplevert noemen we de set-of-support. Als het nu mogelijk is met alleen deze set-of-support door middel van resolutie de lege clausule (false) te bereiken, is P (X) onwaar, en geldt dus P (X). Als er op deze manier geen bewijs wordt gevonden, worden er aanvullende clausules geladen met feiten die al bekend zijn bij QA2, waarmee het mogelijk is resolutie toe te passen op de nieuwe clausules en die in de set-ofsupport. Als ook met deze nieuwe clausules nog geen bewijs wordt gevonden, worden er opnieuw nieuwe clausules geladen, net zolang tot het bewijs gevonden wordt; er worden heuristieken gebruikt om te bepalen welke clausules te laden, op welke manier er resolutie wordt toegepast, en hoe langer moet worden doorgegaan om te proberen een bewijs te vinden. [GR68, p. 176] Als er eenmaal een bewijs gevonden is voor P (X) (i.e., beginnend bij P (X) is de lege clausule afgeleid), dan is er ofwel door substitutie een specifieke waarde 6

9 voor X bereikt, in welk geval P (X) geldt voor de gevonden X; als X niet gesubstitueerd is, dan geldt P (X) voor alle X. Deze manier van werken was op dat moment vrij nieuw: The organization of QA2 represents a novel departure from previous comparable systems. In most systems (including SIR and QA1) memory organization and data-retrieval procedures were established first, and then logical deduction procedures were tacked on almost as an afterthought. For QA2 we first decided to use the most powerful logical tools available, and then structured the memory and the retrieval procedures for the convenience of the theorem prover. [GR68, p. 180] 3.5 Van vraag-antwoord naar probleemoplossing In de conclusie van het laatstgenoemde artikel realiseerde Green zich al dat een vraag-antwoordsysteem niet alleen gebruikt kon worden voor het beantwoorden van vragen, maar ook voor vraagstukken van een meer algemene probleemoplossende aard: Finally, a major goal for our current work is to apply QA2 to problem solving, in addition to question answering, tasks. If permissable actions are suitably axiomatized, then the steps in a proof of the assertion that a problem s goal is achievable can be used to indicate the sequence of actions that must be taken to achieve it. We have hand-simulated solutions to such diverse problems as writing a computer program and reaching the bananas, 1 with encouraging preliminary results. [GR68, p. 180] Green kwam dan ook een jaar later, in 1969, met een artikel getiteld Application of theorem proving to problem solving [Gre69], waarin hij aangeeft dat vraag-antwoordsystemen (zoals zijn QA2 en diens opvolger, QA3) niet alleen antwoorden kunnen geven op vragen, maar dat door een bepaalde toestandsruimte op te bouwen terwijl er een antwoord wordt afgeleid, het ook mogelijk is om algemenere problemen op te lossen. Het opbouwen van een toestandsruimte gaat als volgt in zijn werk: Zeg bijvoorbeeld dat object 1 op positie b is in toestand s 1, dan geldt het predicaat AT (object 1, b, s 1 ). Wil men nu weten waar object 1 is in toestand s 1, dan vraagt men het systeem om AT (object 1, X, s 1 ) op te lossen, wat resulteert in X = b. Stel dat de toestand veranderd kan worden door object 1 van plek b naar plek c te duwen, dan kan dat met een volgend axioma: AT (object 1, b, s) AT (object 1, c, push(object 1, b, c, s)). Er wordt dus steeds een toestandsvariabele 1 Dit duidt op het klassieke aap en bananen -probleem, bedacht door John McCarthy, waarbij een aap in een ruimte een kist moet verschuiven en erop klimmen om bij een tros bananen te komen; binnen de kunstmatige intelligentie, logisch programmeren en geautomatiseerde planning software is dit een simpel speelgoedprobleem wat geïmplementeerd kan worden in verschillende logische systemen, om te vergelijken hoe die systemen met dergelijke problemen omgaan. 7

10 s meegesleept die door geneste acties aangeeft hoe het systeem in die toestand terecht is gekomen [Gre69, p. 2]. Het op deze manier genereren van een toestandsruimte maakt het voor Green mogelijk om het eerder genoemde aap-bananen-probleem [Gre69, pp. 6 7] en het torens van Hanoi-probleem [Gre69, pp. 7 10] op te lossen. Ook heeft hij deze techniek gebruikt om een echte robot rond te laten manouvreren en objecten te manipuleren [Gre69, pp ]. Maar voor het logisch programmeren was de belangrijkste stap toch wel degene die Green automatisch programmeren noemt: het oplossen van programmeerproblemen door middel van zijn vraagantwoordsystemen. Hij onderscheidt hierin vier verschillende modi: checking (het controleren of een gegeven antwoord van een programma juist is), simulation (het simuleren van het uitvoeren van een programma, door gegeven een input, de output te bewijzen ), verifying (verifiëren of een programma correct is door te bewijzen dat voor elke input er de juiste output uitkomt) en program writing (gegeven een probleemstelling, het genereren van een programma wat dat probleem oplost) [Gre69, p. 13]. De cruciale modus is het simuleren: wat houdt dit precies in? Gegeven een programma P, met een invoer I, en een uitvoer O, dan kan de relatie tussen invoer en uitvoer omschreven worden met het predicaat P (I, O), en dit predicaat kan omschreven worden in logische termen zoals beschikbaar in QA2 en QA3. Maar dan is het simuleren van zo n programma niets anders dan het bewijzen van P (I, O) voor gegeven I en onbekende O, want het systeem bewijst dan P (I, O) door een O te vinden waardoor het predicaat waargemaakt wordt. En dit is precies wat logisch programmeren inhoudt. Zoals Green het zegt: The theorem prover may be considered an interpreter for a highlevel assertional or declarative language logic. [Gre69, p. 18] Hij zet interpreter nog tussen aanhalingstekens, omdat het systeem dusdanig traag was dat het meer als een simulatie van het uitvoeren van een programma gezien werd dan een daadwerkelijke interpretatie: He was forced to view the computational use as a simulation because the theorem prover was not specialised for this use, nor was it implemented with efficiency in mind. [CT82, p. xiii] Maar niet lang erna zouden er optimalisaties gevonden worden waardoor deze manier van programmeren daadwerkelijk werkbaar werd voor echte programmeerproblemen. 4 Robert Kowalski: logica als programmeertaal Na het werk van Green waren er nog enkele technieken nodig om tot logisch programmeren als volwaardige en efficiënte programmeeromgeving te komen. Deze technieken zijn kort en krachtig omschreven in een artikel van Robert Kowalski, getiteld Predicate logic as programming language [Kow74]. 8

11 Kowalski stelt daarin een manier van logisch programmeren voor die veel meer lijkt op het traditioneel procedureel programmeren zoals men toen gewend was, en hij doet dit door middel van Horn-clausules en SLD-resolutie. Horn-clausules zijn genoemd naar Alfred Horn, en zijn artikel uit 1951, On sentences which are true of direct unions of algebras [Hor51]. Een Horn-clausule is een clausule (een disjunctie van literals dus) met maximaal één positieve literal. SLD-resolutie is een verfijning van SL-resolutie van Kowalski en Kuehner [KK71] (die weer gebaseerd is op de resolutie-techniek van Robinson), voor het eerst beschreven in Predicate logic as programming language [Kow74] 2, en komt er op neer dat clausules worden gezien als procedure-declaraties, en het bewijzen van clausules als het aanroepen van procedures. De semantiek van Horn-clausules voor logisch programmeren wordt door Kowalski als volgt beschreven [Kow74, pp ]: Ongeacht het aantal positieve of negatieve literals, is een clausule B 1... B m A 1... A n met dus m positieve en n negatieve literals, altijd om te schrijven door de negaties buiten haakjes te halen en een implicatie toe te passen naar de vorm B 1... B m A 1... A n ofwel B 1... B m geldt als A 1 t/m A n geldt. We zullen dit schrijven als: B 1,..., B m A 1,..., A n Voor Horn-clausules (met dus m 1) heeft dit de volgende betekenis: Als m = 1 en n > 0, is de clausule van de vorm B A 1,..., A n. Dit kan geïnterpreteerd worden als een procedure-declaratie; B is de naam van de procedure, en de A i -literals zijn de body van de procedure, en bestaan uit aanroepen naar andere procedures. Als m = 1 en n = 0, hebben we een clausule B, en dit staat gelijk aan het stellen van een feit B; ofwel B is een procedure met een leeg body. Als m = 0 en n > 0 hebben we A 1,..., A n ; dit is een doel-statement, en het doel van het statement is om alle procedures A 1 t/m A n succesvol uit te voeren. Voor m = 0 en n = 0 levert het de lege clausule op, een halt-statement, wat wordt geschreven als. Het uitvoeren van SLD-resolutie op clausules van deze vorm gaat nu als volgt: Gegeven een doel-statement A 1,..., A i 1, A i, A i+1,... A n 2 In dit artikel wordt SLD-resolutie nog niet bij die naam genoemd; dit gebeurt pas in een later artikel van Apt en Van Emden [AvE82] 9

12 en gegeven een procedure B B 1,..., B m (dit kan ook een procedure met een leeg body zijn) waarbij de naam B overeenkomt met A i er is een substitutie Θ mogelijk waardoor A i en B gelijkgemaakt kunnen worden dan levert dit een nieuw doel-statement op: (A 1,..., A i 1, B 1,..., B m, A i+1,..., A n )Θ Deze vorm van resolutie is in principe hetzelfde als standaard -resolutie zoals gedefinieerd door Robinson, behalve dat de restricties aan clausules (namelijk Horn-clausules) en de vorm van toepassen (op een doel-statement en een procedure) er voor zorgen dat er veel minder vrijheid is bij het kiezen van clausules om resolutie op toe te passen. Dit gebrek aan vrijheid zorgt ervoor dat SLDresolutie op een veel gestructureerdere manier toegepast kan worden, namelijk als volgt [Kow74, pp ]: 1. Begin met een verzameling procedure-declaraties en één doel-statement. 2. Kies een van de procedure-clausules uit om resolutie op uit te voeren, en pas resolutie op toe op het doel-statement en die clausule. Als er geen procedure-clausules zijn waaruit te kiezen valt (doordat ze niet matchen met het doel-statement), dan is de afleiding onsuccesvol. Als er uit verschillende resolutie-stappen kan worden gekozen, kies er dan een uit (eventueel volgens heuristieken); als later blijkt dat deze keuze eindigt in een onsuccesvolle afleiding, kan er terug worden gegaan naar dit punt (backtracking), en een andere resolutie-stap worden geprobeerd. 3. Als het nieuwe doel-statement nu het halt-statement is, is de afleiding succesvol, en de substituties die zijn uitgevoerd geven aan hoe het oorspronkelijke doel-statement kan worden ingevuld (als er vrije variabelen in voorkwamen). Als het nieuwe doel-statement niet het halt-statement is, ga dan opnieuw door met stap 2. Deze manier van werken wordt backward reasoning genoemd; je begint met het doel wat bereikt moet worden, en vervangt bij iedere stap een deel van dat doel door datgene waardoor het doel bereikt kan worden, totdat alle onderdelen van het doel bereikt zijn; de substituties die ondertussen zijn uitgevoerd geven aan hoe het doel waargemaakt is (zoals ook bij resolutie in QA2, beschreven in sectie 3.4). Dit is ook het principe waarop Prolog 2 jaar eerder gecreëerd door Colmerauer et. al. in Marseille gebaseerd is: When applied to the Horn clause subset of predicate logic, SLresolution behaved very like a conventional program executor. The difference was that it was non-deterministic, and the process of unification did the work of parameter passing, and of data structure access and construction. Finally, by fixing on a backtracking search strategy, Colmerauer s research group at Marseilles produced an extremely efficient implementation of SL-resolution for the Horn clause subset of predicate logic. This was in The theorem prover/program executor was called PROLOG. [CT82, p. xiv] 10

13 5 Conclusie Sinds het artikel Predicate logic as programming language van Kowalski uit 1974 is logisch programmeren op de kaart gezet als zijnde een volwaardig onderzoeksgebied. Dit was met name te danken aan dat artikel: Kowalski s paper [... ] marked the beginning of logic programming as a separate research area. That paper has inspired many people to explore the consequences of viewing computation as inference. [CT82, p. xiv] Sindsdien is er natuurlijk nog veel meer gebeurd, logisch programmeren heeft zich verder voortgezet, er zijn allerlei verdere ontwikkelingen aan en varianten op Prolog gekomen; maar het basis-idee, het oplossen van logische problemen door met behulp van een theorem prover nieuwe stellingen en feiten af te leiden uit oude, is nooit veranderd. In het boek Logic Programming [CT82] wordt een overzicht geboden van toepassingen van logisch programmeren, alsmede andere ontwikkelingen sinds het ontstaan van het vakgebied. Gezien dat het een boek uit 1982 is, is het alweer enigszins gedateerd, maar het biedt toch een mooi begin voor diegenen die meer willen weten over de theorie en praktijk achter logisch programmeren. 11

14 Referenties [AvE82] Krzysztof R. Apt and M. H. van Emden. Contributions to the theory of logic programming. J. ACM, 29: , [Cre92] [CT82] [GR68] [Gre69] [Hor51] [KK71] Daniel Crevier. AI: the tumultuous history of the search for artificial intelligence. Basic Books, New York NY, K. L. Clark and S. A. Tärnlund. Logic Programming. Academic Press, Inc. Orlando, FL, USA, C. Cordell Green and Bertram Raphael. The use of theorem-proving techniques in question-answering systems. In Proceedings of the rd ACM national conference, pages ACM, C. Green. Application of theorem proving to problem solving. Proceedings of the International Joint Conference on Artificial Intelligence, pages , A. Horn. On sentences which are true of direct unions of algebras. The Journal of Symbolic Logic, 16:14 21, R. A. Kowalski and D. Kuehner. Linear resolution with selection function. Artificial Intelligence, 2: , [Kow74] R. A. Kowalski. Predicate logic as programming language. In Information Processing 74, Proc. IFIP Congr. 74, pages , Stockholm, [McC59] J. McCarthy. Programs with common sense. Proceedings of the Teddington Conference on the Mechanization of Thought Processes, pages 75 91, [NS56] A. Newell and H. Simon. The Logic Theory Machine a complex information processing system. Information Theory, IEEE Transactions on, 2:61 79, [Rap64] B. Raphael. SIR: A Computer Program for Semantic Information Retrieval. PhD thesis, Massachusetts Institute of Technology, [Rob65] J. A. Robinson. A machine-oriented logic based on the resolution principle. J. ACM, 12:23 41, [Sim98] Herbert A. Simon. Allen Newell: Annals of the History of Computing, IEEE, 20:63 76,