Hvorfor er han fantastisk? Jeg kan et par dusin språk og det er ikke noe problem for meg å lære et nytt nytt, jeg ser bare ikke behovet lenger.

Prologen er unik. Det er det eneste språket som representerer det deklarative programmeringsparadigmet; det er et språk som har hundrevis av forskjellige implementeringer, men de kalles fortsatt Prolog, og legger kun til prefikser og suffikser til navnet; det er et levende språk der ingen vesentlige endringer har skjedd på mer enn 20 år; Dette er sannsynligvis det eneste programmeringsspråket som er så populært som ikke har noen applikasjon i ekte programmering. Hvorfor Prolog?

Prologen er unik i naturen, den dukket opp på grunn av en lykkelig tilfeldighet (verdens mystiske struktur). Det var en gang på 60-tallet, teorien om automatisk teorembevis utviklet seg veldig raskt, og Robinson foreslo en oppløsningsalgoritme som gjorde det mulig å bevise ethvert sant teorem (avlede det fra aksiomer) i en begrenset tid (som det ikke er for kjent). Som det viste seg senere, er dette den beste løsningen på et generelt problem; det er umulig å bevise teoremet i et begrenset antall operasjoner. Med enkle ord er algoritmen en bredde-først-gjennomgang av en (vanligvis uendelig) graf. Naturligvis er forutsigbarheten til algoritmens operasjon praktisk talt lik 0; følgelig er dette absolutt ikke egnet for et programmeringsspråk. Og i det øyeblikket fant Kalmarow en strålende innsnevring av problemet, takket være at beviset på noen teoremer så ut som en prosedyremessig utførelse av programmet. Det er verdt å merke seg at klassen av bevisbare teoremer er ganske bred og veldig godt anvendelig for klassen av programmerbare problemer. Det var slik Prolog ble til i 1972.

I denne artikkelen vil jeg prøve å snakke om Prolog som et verktøy for å løse generelle logiske problemer. Dette emnet vil være av interesse for de som allerede kjenner Prolog-syntaksen og ønsker å forstå den fra innsiden, så vel som for de som absolutt ikke kan syntaksen til språket, men som ønsker å forstå dets "glede" uten å bruke ekstra tid lære syntaktiske strukturer.

Hovedtrekket til Prolog er at det kan være lett å lese, men veldig vanskelig å skrive, noe som er fundamentalt forskjellig fra alle vanlige språk, som sier at skriving har blitt enda enklere, ett trinn til og du kan skrive på et nettbrett, dra arbeider moduler som venner på Google+, vi vet alle at kvaliteten på selve koden lider sterkt under dette. Det ser ut til at hver linje er klar, men hvordan systemet fungerer er hinsides forståelse selv for utviklere, som de sier i Hindustan. Det virker for meg som om de i alle bøker om undervisning i Prolog gjør den samme feilen, og starter en historie om fakta, relasjoner, spørsmål, og en person utvikler en holdning til språket som et ekspertsystem eller en database. Det er mye viktigere å lære å lese programmer riktig og lese dusinvis av dem på den måten :)

Hvordan lese prologprogrammer riktig

Å lese programmer er veldig enkelt, siden språket har svært få spesielle symboler og nøkkelord, og de kan lett oversettes til naturlig språk. Hovedfeilen til en programmerer er at han umiddelbart vil forestille seg hvordan programmet fungerer, og ikke lese hva programmet beskriver, så det virker for meg som det er mye lettere å trene den uskyede hjernen til en vanlig person enn en programmerer.

Begreper

Det er 2 begreper i språket predikater(betingelser) og gjenstander(de er også variabler og termer). Predikater uttrykke en bestemt tilstand, for eksempel et grønt objekt eller et primtall; det er naturlig at betingelsene har inngangsparametere. For eksempel green_object(Objekt), primtall(tall). Antall parametere i et predikat bestemmer ariteten til predikatet. Objekter- er termer, konstanter og variabler. Konstanter- dette er tall og strenger, variabler- uttrykke en ukjent gjenstand, eventuelt den som søkes, og er utpekt som linjer med stor bokstaver. La oss forlate vilkårene for nå og vurdere det enkleste programmet.

Program

Et program er et sett med regler for skjemaet Hvis betingelse1 og betingelse2 og... så er betingelsen sann. Formelt sett er disse reglene kombinert gjennom OG, men det er umulig å oppnå en motsigelse, siden det ikke er noen logisk negasjon i Prolog, og bare ett predikat (betingelse) kan være tilstede i bindeleddet That.

A:- B_1, B_2. %-regelen lyder som: Hvis B_1 og B_2, så A
odd_prime(tall) :- prime(tall), odd(tall).
% Hvis "Number" er primtall og oddetall, så er "Number" odd_prime

Som du kan se, har variabelnavnet et omfang - dette er regelen. Matematisk korrekt lyder regelen: for enhver variabel - "Tall", hvis den er primtall og oddetall, så er den prime_odd. På samme måte kan det omformuleres som følger: Hvis det er et "Tall" som er oddetall og primtall, så er det odd_primtall. Derfor er variabelnavnet veldig viktig! Hvis vi på venstre side (før:-) erstatter Tall med Tall2, så vil regelen endre sin betydning: For alle Tall2 og Tall, hvis Tall er primtall og oddetall, så er Tall2 enkelt oddetall. Det viser seg at alle tall er prime_odd! Dette er den vanligste feilen i Prolog.

A:- B_1, B_2. %-regelen lyder som: Hvis B_1 og B_2, så A odd_prime(Number) :- prime(Number), odd(Number). % Hvis "Number" er primtall og oddetall, så er "Number" odd_prime

Eksempel - perfekte tall

perfekt_tall(N) :- tall(N), sum_av_delere_uten_tall(N, SumofDivisors), lik(Sum_ofDivisors, H). perfekt_tall(1). lik (Objekt, Objekt). sum_of_delers_uten_tall(1, 1). sum_of_divisors_without_number(Tall, Sum) :- tall_forrige(Tall, Forrige), sum_of_divisors_of_number_to_number(Tall, Sum, Previous). sum_of_number_divisors_to_number(tall, 1, 1). sum_of_tall_divisors_to_number(Tall, Sum, Divisor) :- dividert_på(Tall, Divisor), number_previous(Divisor, Previous), sum_of_number_divisors_to_number(Tall, SumPrev, Previous), add(SumForrige, Divisor, Sum). sum_of_number_divisors_to_number(Tall, Sum, Divisor) :- ikke_delelig_ved(Tall, Divisor), number_previous(Divisor, Previous), sum_of_number_divisors_to_number(Tall, Sum, Previous).

Først, la oss formelt lese hva reglene betyr:

1. Hvis "H" er et tall og for "H" og "SumDivisors" er betingelsen sum_divisors_without_number oppfylt, med andre ord, SumDivisors er summen av divisorene til tallet "H", og "H" er lik "SumDivisors" , så er "H" et perfekt tall.
2. 1 er et perfekt tall. Regler har kanskje ikke betingelser, i så fall kalles de fakta.
3. Hvert objekt "O" er lik "O". I prinsippet er det et standard predikat "=", men du kan erstatte det fullstendig med ditt eget.
4. Det faktum at summen_av_delere_uten_tallet 1 er lik 1.
5. Hvis summen av divisorene "Tall" opp til det forrige tallet "Tall" er lik "Sum", så er dette summen_av_delere_uten_tall. På denne måten uttrykkes det at summen av divisorene til X er mindre enn eller lik Y, siden X er delelig med X, så vi tar Y = X - 1.
6. Deretter bestemmer 3 predikater summen av divisorer som er mindre enn eller lik Y (Divisor), 1. tilfelle Y er lik 1, 2. tilfelle Tall er delelig med Y, deretter sum_of_divisors(X, Y) = sum_of_divisors(X, Y- 1) + Y , og 3. tilfelle Tallet er ikke delelig med Y, da sum_of_divisors(X, Y) = sum_of_divisors(X, Y-1).

Et program er som et sett med definisjoner

Det er en annen måte å lese disse reglene på, mindre matematisk og mer naturlig, basert på "definisjoner". Du kan legge merke til at i Prolog inneholder alle reglene til venstre (i den daværende delen) bare én betingelse, som egentlig er en "definisjon" av denne tilstanden.
For eksempel er den første regelen definisjonen av perfekte tall. "H" er et perfekt tall når "H" er et tall og summen av divisorene til "H" er lik "H". Identiske predikater er gruppert etter navn ved å bruke "eller"-betingelsen. Det vil si at du kan legge til definisjonen: "H" er et perfekt tall når.., eller når "H" er 1.

Denne lesemetoden er mye brukt, siden den lar predikater kombineres til homogene grupper og hjelper til med å forstå i hvilken rekkefølge tolken vikler ut predikater for å
sjekk sannheten til et utsagn. For eksempel er det åpenbart at hvis et predikat ikke har en enkelt definisjon, så er det umulig å bevise sannheten til et utsagn med det. I eksempel nr. 1 har predikatet «delt med» ingen definisjon.

Et interessant faktum er at i Prolog er det ingen løkker, ingen variabeltilordninger, ingen typedeklarasjoner, og hvis vi også husker på termer og klipping, blir språket algoritmisk komplett.

Termiske bad

Termiske bad har en rekursiv definisjon som en navngitt samling av objekter. Term = "navn"(objekt, objekt, ...), eksempel person("Navn", "Etternavn"), "+"(1, 2), person(adresse("Noen adresse"), etternavn("Etternavn"), telefon("Telefon")). Hvis vi betrakter et begrep som et matematisk konsept, så er begrepet en funksjon, eller mer presist en funksjon, det vil si at “+”(1, 2) betyr at det er et objekt som er lik 1+2. Dette betyr overhodet ikke at 1+2 = 3; i Prolog er ikke dette uttrykket sant, akkurat som i gruppen av rester modulo 2, eksisterer ikke 3 i det hele tatt. Igjen, fra et matematisk synspunkt, er variabler forbundet med ordet For All, og hvis ordet eksisterer i en uttalelse, brukes et begrep (functor) for dette formålet. For et hvilket som helst tall er det et faktortall: factorial(X, fact(X)).

Fra et programmeringssynspunkt kan begreper forklares mye enklere: et begrep er et objekt med et sett med attributter, attributtene kan være andre begreper eller konstanter eller variabler (det vil si udefinerte). Hovedforskjellen er at alle objekter i Prolog er uforanderlige, det vil si at du ikke kan endre attributtene i dem, men det er en spesiell tilstand - en variabel.

Eksempel - Heltallsaritmetikk

nat(0). nat(tall(tall)) :- nat(tall). pluss(0, tall, tall). pluss(tall(N1), N2, tall(Res)) :- pluss(N1, N2, Res). multiplisere(0, Tall, 0). multipliser(tall(Ch1), Ch2, Res2) :- multipliser(Ch1, Ch2, Res), pluss(Res, Ch2, Res2).

1. Definisjon av egenskapen nat (naturlig nummer). 0 er et naturlig tall, hvis Tallet er naturlig, så er det et objektnummer(Tall), som også er et naturlig tall. Matematisk uttrykker begrepet "tall" funksjonen +1; fra et programmeringssynspunkt er "tall" en rekursiv datastruktur, her er elementene: tall(0), tall(tall(0)), tall(tall) (nummer(0))).
2. Plussforholdet er 0 + Tall = Tall. Hvis Ch1 + Ch2 = Res, så (Ch1+1) + Ch2 = (Res+1).
3. Forholdet for å multiplisere er 0 * Tall = 0. Hvis Ch1 * Ch2 = Res og Res + Ch2 = Res2, så (Ch1+1) * Ch2 = Res2.

Disse utsagnene er åpenbart sanne for vanlig aritmetikk, men hvorfor inkluderte vi ikke de samme åpenbare som Tall + 0 = Tall. Svaret er enkelt: redundans er veldig dårlig i enhver definisjon. Ja, dette kan hjelpe beregninger, en slags for tidlig optimalisering, men bivirkningene kan være motsetninger i definisjoner, tvetydig utgang av en uttalelse og looping av tolken.

Hvordan Prolog forstår predikater og hvordan det beviser utsagn

Leseprogrammer bidrar selvsagt til å få en følelse av Prolog-stilen, men det gjør det ikke klart hvorfor og hvordan disse definisjonene kan brukes. Eksemplene gitt ovenfor kan ikke kalles et fullverdig program fordi det ikke er nok inngangspunkt. Inngangspunktet til Prolog er en spørring, analog med en spørring mot en SQL-database eller analog med å kalle en hovedfunksjon i funksjonell programmering. Eksempler på spørringer: nat(Number) - finn et naturlig tall, pluss(0, 0, Result) - finn resultatet av å legge til 0 og 0 i resultatvariabelen, nat(0) - sjekk om 0 er et naturlig tall, osv. .

Selvfølgelig er resultatene av spørringer ikke vanskelige å forutsi fra logiske betraktninger, men det er ekstremt viktig å forstå hvordan programmet oppnådde dem. Prolog er tross alt ikke en svart boks, men et programmeringsspråk, og i motsetning til en database, hvor en SQL-plan bygges og spørringen kan utføres forskjellig på forskjellige databaser, har Prolog en veldig spesifikk utførelsesrekkefølge. Faktum er at i databasen vet vi helt hvilket svar vi ønsker å få basert på dataene i tabellen, dessverre, ser på prologen til programmet er det ganske vanskelig å si hvilke utsagn som er logisk deduserbare, så det er mye enklere for å forstå hvordan Prolog-tolken fungerer.

La oss se på et eksempel på en forespørsel pluss(0, 0, resultat) :
1. Vi finner en match (en slags mønstertilpasning, oppløsning) av denne forespørselen med venstre del av en av reglene. For dette søket, pluss(0, tall, tall). La oss korrelere alle spørringsargumentene med regelen en etter en og få: 0 = 0, 0 = Tall, Resultat = Tall. Disse ligningene involverer 2 variabler (tall og resultat), ved å løse dem får vi at Tall = Resultat = 0. Siden denne regelen ikke har noen betingelser, fikk vi svaret på spørsmålet. Svar: ja og resultat = 0.

Be om nat(tall) :
1. Vi finner 1. samsvar med regelen, nat(0)-regelen, ved å løse likningene ved samsvar, med andre ord, ved å finne oppløsningen får vi Tall = 0. Svar: ja og Tall = 0.

Be om pluss(Resultat, 0, tall(0)) :
1. Finn en oppløsning med regelen pluss(0, Tall, Tall): Resultat = 0, 0 = Tall, tall(0) = Tall, men (!) Tall = 0 = tall(0) - ikke mulig siden 0 er samme tall (0). Derfor ser vi etter en løsning med følgende regel.
2. Finn oppløsningen med regelen pluss(tall(N1), Ch2, tall(Res)), vi får tall(N1) = Resultat, Ch2 = 0, tall(Res) = tall(0), derav Res = 0 Dette reglene, det er forhold som vi må sjekke, tar hensyn til resultatene av oppløsningen (variable verdier), pluss(Ch1, Ch2, Res) -> pluss(Ch1, 0, 0). Vi husker verdien av variablene på stabelen og lager en ny forespørsel pluss(H1, 0, 0)
3*. Ved å løse spørringen pluss(Х1, 0, 0) finner vi en oppløsning med pluss(0, Tall, Tall) og får Х1 = 0 og Tall = 0.
4. Vi går tilbake langs stabelen til de forrige variablene Resultat = tall(N1) = tall(0). Svaret ble funnet nummer(0). Følgelig har prologmaskinen nå løst likningen X + 0 = 1.

Kompetent kompilering av regler på Prolog-språket er en veldig vanskelig ting, men hvis du komponerer dem kompakt, kan du ikke bare få direkte svar og løsninger, men også omvendte.

Eksempelforespørsel pluss(tall, tall, tall) : svaret er ja, tall = 0.

Eksempelforespørsel pluss(0, 0, 0) : svaret er nei, ved første forsøk er ikke alle resolusjoner oppfylt.

Eksempelforespørsel pluss(tall, tall, tall(tall)) : Svaret er ja, Tall = 1. Løse ligningen X + X = X + 1.

Prøv å skrive ut for multiplikasjon (tall, tall(0), tall(0)), dette vil kreve å skyve variabler på stabelen 2 ganger og beregne en ny spørring. Essensen av Prolog-maskinen er at du kan forkaste det første resultatet, så vil Prolog gå tilbake til forrige tilstand og fortsette beregningen. For eksempel forespørsel nat(tall) , vil først bruke den 1. regelen og gi ut 0, og deretter bruke 2. regelen + 1. regelen og skrive ut tallet (0), kan du gjenta og få en uendelig rekkefølge av alle naturlige tall. Et annet eksempel, forespørsel pluss(Tall, tall(0), Tall2) , vil produsere en sekvens av alle par av løsninger til ligningen X + 1 = Y.

Konklusjon

Dessverre tillot den rimelige størrelsen på emnet meg ikke å komme i nærheten av hovedtemaet, nemlig å løse komplekse logiske problemer i Prolog, uten å ha en strategi for å løse dem. Store biter av Prolog-kode kan skremme ikke bare nybegynnere, men til og med erfarne programmerere. Hensikten med denne artikkelen er å vise at Prolog-programmer kan enkelt lese på naturlig språk, og utført av en enkel tolk.
Hovedtrekket til Prolog er at det ikke er en svart boks eller et bibliotek som løser komplekse logiske problemer; du kan legge inn en algebraisk ligning i Mathematica og den vil produsere en løsning, men sekvensen av trinnene som utføres er ukjent. Prolog kan ikke løse generelle logiske problemer (den mangler logisk "eller" og "negasjon"), ellers ville utgangen være ikke-deterministisk som en lineær oppløsning. Prolog er den gyldne middelvei mellom en enkel tolk og en teorembevismaskin; et skifte i hvilken som helst retning fører til tap av en av egenskapene.

I neste artikkel vil jeg snakke om hvordan sorteringsproblemer løses, om rekkefølgen av transfusjoner, Miss Manners og andre velkjente logiske problemer. For de som føler seg misfornøyde, vil jeg tilby neste oppgave (den første personen til å løse premien):
Skriv et predikat, som vil generere en uendelig sekvens av naturlige tall, som starter med 3. Disse bør være standardtall i Prolog, operasjoner som utføres ved å bruke predikatet er: X er 3 + 1 => X=4.

I mange årtusener har menneskeheten akkumulert, bearbeidet og overført kunnskap. For disse formålene blir stadig nye midler oppfunnet og gamle forbedres: tale, skrift, post, telegraf, telefon osv. Fremkomsten av datamaskiner spilte en stor rolle i kunnskapsbehandlingsteknologi.

I oktober 1981 kunngjorde det japanske departementet for internasjonal handel og industri opprettelsen av en forskningsorganisasjon - Institute for New Generation Computer Technology Research Center. Målet med dette prosjektet var å lage kunnskapsbaserte informasjonsbehandlingssystemer. Det ble antatt at disse systemene ville gi enkel administrasjon på grunn av muligheten til å kommunisere med brukere ved hjelp av naturlig språk. Disse systemene skulle være selvlærende, bruke kunnskapen akkumulert i minnet til å løse ulike typer problemer, gi brukerne ekspertråd, og brukeren var ikke pålagt å være spesialist i informatikk. Det ble antatt at en person ville kunne bruke en femte generasjons datamaskin like enkelt som ethvert elektrisk husholdningsapparat som TV, båndopptaker og støvsuger. Rett etter den japanske startet amerikanske og europeiske prosjekter.

Fremveksten av slike systemer kan endre teknologi gjennom bruk av kunnskapsbaser og ekspertsystemer. Hovedessensen i den kvalitative overgangen til femte generasjon datamaskiner var overgangen fra databehandling til kunnskapsbehandling. Japanerne håpet at de ikke ville være i stand til å tilpasse menneskelig tenkning til prinsippene for datamaskindrift, men å bringe datamaskindrift nærmere måten en person tenker på, samtidig som de beveger seg bort fra datamaskinens von Neumann-arkitektur. I 1991 var det planlagt å lage den første prototypen av femte generasjons datamaskiner.

Det er nå klart at de fastsatte målene aldri ble oppnådd fullt ut, men dette prosjektet fungerte som en drivkraft for utviklingen av en ny runde med forskning innen kunstig intelligens og forårsaket en eksplosjon av interesse for logisk programmering. Siden den tradisjonelle von Neumann-arkitekturen ikke var egnet for effektiv implementering, ble spesialiserte logiske programmeringsdatamaskiner PSI og PIM laget.

Følgende ble valgt som hovedmetodikk for utvikling av programvare for femte generasjons dataprosjekt: logisk programmering, en fremtredende representant for dette er Prolog-språket. Det ser ut til at Prolog for tiden fortsatt er det mest populære kunstig intelligens-språket i Japan og Europa (i USA er tradisjonelt et annet kunstig intelligens-språk mer utbredt - det funksjonelle programmeringsspråket Lisp).

Navnet på språket "Prolog" kommer fra ordene LOGISK PROGRAMMERING(PROgrammation en LOGique på fransk og PROgrammering i LOGic på engelsk).

Prolog er basert på en slik gren av matematisk logikk som predikatregning. Mer presist er grunnlaget prosedyren for å bevise teoremer oppløsningsmetode Til Hornklausuler. Neste forelesning vil bli viet til dette temaet.

I historien om fremveksten og utviklingen av Prolog-språket kan de følgende stadiene skilles.

I 1965, i papiret "A machine oriented logic based on the resolution principle", publisert i 12. utgave av Journal of the ACM, presenterte J. Robinson en metode for automatisk å finne bevis for teoremer i førsteordens predikatkalkulus, kalt " prinsippet om oppløsning". Dette verket kan leses i oversettelse: Robinson J. Maskinorientert logikk basert på prinsippet i resolusjonen// Kybernetisk samling. - Vol. 7 (1970). Faktisk ble ideen til denne metoden foreslått av Herbrand i 1931, da det ikke fantes noen datamaskiner ennå (Herbrand, "Une methode de demonstration", These, Paris, 1931). Robinson modifiserte denne metoden slik at den ble egnet for automatisk, databruk, og utviklet i tillegg en effektiv foreningsalgoritme som danner grunnlaget for metoden hans.

I 1973 opprettet "kunstig intelligens-gruppen" ledet av Alain Colmeroe et program ved universitetet i Marseille designet for å bevise teoremer. Dette programmet har blitt brukt til å bygge naturlige tekstbehandlingssystemer. Teorembevisprogrammet ble kalt Prolog (fra Programmation en Logique). Den fungerte som prototypen for Prologue. Legenden sier at forfatteren av dette navnet var Alan Colmeroes kone. Programmet ble skrevet i Fortran og gikk ganske sakte.

Arbeidet til Robert Kowalski var av stor betydning for utviklingen av logisk programmering. Predikatlogikk Hvordan programmeringsspråk"(Kowalski R. Predicate Logic as Programming Language. IFIP Congress, 1974), der han viste at for å oppnå effektivitet må man begrense seg til bruken av et sett Hornklausuler. Det er forresten kjent at Kowalski og Colmeroe jobbet sammen i løpet av en sommer.

I 1976 foreslo Kowalski, sammen med sin kollega Maarten van Emden, to tilnærminger til å lese logikkprogramtekster: prosedyremessig og deklarativ. Disse tilnærmingene vil bli diskutert i den tredje forelesningen.

I 1977 i Edinburgh skapte Warren og Pereira en veldig effektiv Prolog-kompilator for DEC-10-datamaskinen, som fungerte som prototypen for mange påfølgende implementeringer av Prolog. Interessant nok,

Forelesningen er viet problemløsning ved hjelp av en tilstandsromgraf. Tilstandsrommet er beskrevet i form av et sett med tilstander - graftoppunkter, et sett med overganger fra tilstand til tilstand - grafbuer, et sett med initialtilstander og et sett med slutttilstander. Løsningen på problemet er representert som en bane på tilstandsromgrafen som kobler den opprinnelige tilstanden til den endelige tilstanden. Hvis tilstandsområdet for problemet er lite, vil alle optimale løsninger bli funnet ved å bruke dybde-først-søk. Ved problemer med stor delstatsplass vil kun én optimal løsning beregnes gjennom bredde-først-søk. Universelle løsere brukes på problemer. Stater i ulike oppgaver kan tilhøre ulike domener. For å huske de beste løsningene som er funnet, brukes en "variabel variabel" varM. Kompilatoren finner selv de nødvendige typene. Visual Prolog versjon 7.5, ennå ikke publisert. Publiseringen er planlagt i 2014, men den eksakte datoen er ennå ikke kjent. Visual Prolog 7.4 er nå tilgjengelig for alle.

Utseendet til Prologue skyldtes utviklingen av logikk, matematikk og programmering. Sistnevnte spilte den viktigste rollen. Spesialister i logikk og matematikk gjorde et forsøk på å sette programmering på "riktig vei", men utviklingen av informasjonsteknologi viste et helt annet resultat.

Pragmatisk imperativ programmering viste seg å være mer lovende. "Prolog" lyktes som programmeringsspråk, men ble ikke grunnlaget for kunstig intelligens.

Klassisk programmering vs logikk

En person tar vanskelige beslutninger logisk og rimelig. Nesten uten å tenke, handler en person klokt. Hvis vi ikke tar hensyn til beslutninger som krever innsamling av informasjon, analysering og komplekse beregninger, så er ethvert resultat raskt, nøyaktig og rimelig.

Dette faktum har alltid gitt en illusorisk grunn til å betrakte opprettelsen av et beslutningsverktøy som en enkel sak. Med fremkomsten av Prologue så det ut til at spørsmålet om kunstig intelligens var et spørsmål om teknologi, og Homo sapiens kom opp med tre lover innen robotikk. Imidlertid forble kunstig intelligens et spøkelse, og de tre lovene for robotikk viste seg å være fra et eventyr - "gjør dette, jeg vet ikke hva."

Programmering i klassisk betydning av ordet (betegnelsene "prosedyremessig", "imperativ" eller "funksjonell" brukes ofte) har utviklet og overvunnet de "urolige tidene" på 80-90-tallet, da det fantes utallige programmeringsspråk.

Demonstrasjonskampen mellom «Pascal» og «Si» varte lenge og var brutal, men endte nøytralt og stille. Det som gjenstår er ideen om et godt programmeringsspråk og flere vellykkede implementeringer av det.

Dette er ikke å si at Prolog som programmeringsspråk ikke har utviklet seg. Men han nådde ikke sine uttalte mål. I dag kan vi ikke bare si, men også rettferdiggjøre: "Prolog" er et akademisk språk for:

• Læringsmål;
• predikatlogikk;
• matematikk;
• smal applikasjon.

Det er tvilsomt om denne påstanden kan tilbakevises. Kunstig intelligens er ikke bare mye brukt, men også en svært alvorlig hendelse som radikalt endrer den sosiale strukturen og verdensbildet.

Programmering på Prolog-språket for kunstig intelligens fant ikke sted: i mer enn førti år av språkets historie har det ikke vært en eneste radikalt ny hendelse som er relevant for den offentlige bevisstheten, noe som indikerer det motsatte.

Den objektive virkeligheten er denne: det er ikke så mye den sterkeste som overlever, men heller det som er etterspurt og relevant.

"Prolog" er et deklarativt programmeringsspråk

Å ha et verktøy for å beskrive fakta og regler er bra, men hva er vitsen? Fakta og regler passer perfekt inn i en vanlig database. En kvalifisert klassisk programmerer gir en interaktiv dialog for brukeren, og sistnevnte løser sine problemer.

Om nødvendig foredler programmereren dialogen, og brukeren supplerer databasen med fakta og regler. Et absolutt fungerende og tiår-testet alternativ for å implementere en masse allerede løste og løsbare problemer.

En deklarativ presentasjon av fakta og regler i enhver implementering av programmeringsspråket Prolog er en konvensjon, et forsøk på å formalisere virkeligheten i dens intellektuelle tilstand. Konvensjonell programmering berører ikke intellektet. Klassisk programmering er fornøyd med stillingen: beskrivelse og behandling av data. Det er mange problemer her, men det er mange strålende løsninger som fungerer.

"Prolog" som programmeringsspråk er fakta:

• mor (Maria, Natasha); - Maria - Natasjas mor;
• pappa (Evgeniy, Marina); - Evgeniy er faren til Marina.

Her er et faktum umiddelbart over bord: "Maria" og "Marina" er forskjellige navn. Ingenting hindrer deg i å legge til faktum:

• pappa (Eugene, Maria); - Evgeniy er Marias far.

Disse beskrivelsene gir reglene liv:

• forelder(x,y)<- папа (x, y);
• forelder(x,y)<- мама (x, y);

Men de tillater oss ikke å konkludere med at pappa er Marinas far, og Marina er Marias mor. Dette problemet kan løses; du kan legge til en regel til, legge til ett faktum. Men hvor mange av disse handlingene bør tas i en reell situasjon?

Faktisk er "Prolog" som programmeringsspråk et eksempel på en erklæring om fakta og regler, men ikke logikken som bevisstheten til en klassisk programmerer er vant til. "Prolog" posisjonerer seg som et predikatlogisk språk, men du kan bare lære programmering i det gjennom eksempler og eksempelbeskrivelser fra utviklerne av en spesifikk implementering av språket.

Prologfamilien

Frankrike regnes som fødestedet til Prologue, og 1973 er ​​fødselsåret. Interessen for språket ble med jevne mellomrom fornyet, men avtok med misunnelsesverdig stabilitet. Språkets motto: «Predikatlogikk er elementært! Dette er en måte å forklare hvordan tenkning fungerer» - og forble mottoet.

Enhver implementering av programmeringsspråket Prolog fulgte strengt predikatlogikken, men inkluderte alltid klassiske ideer om prosedyreprogrammering. Det er mer riktig å si "imperativ", siden dette begrepet brukes med mer formalitet enn prosedyremessig, funksjonelt, objektorientert eller annet.

Enhver programmering handler om data og deres behandling. Språkkonstruksjoner må beskrive problemet som løses så nøyaktig som mulig, og det er derfor alle kjente implementeringer av Prolog: Turbo Prolog, Win Prolog, SWI Prolog, GNU Prolog, Visual Prolog og andre inneholder, i tillegg til deklarative konstruksjoner, vanlige imperativuttrykk.

Det antas at Prologue-familien er utviklet i akademiske og forskningsorganisasjoner og derfor bare kan snakkes om som et felles språk i konseptuell forstand. Likevel kan selve det faktum at konseptet "Prolog" er levende og utviklende vurderes: dette språket har et omfang, og det er etterspurt i en viss rekke oppgaver.

Grunnlaget for kunstig intelligens

Interessen for kunstig intelligens har aldri avtatt, de begynner bare å snakke om det når neste anledning byr seg, men Prolog har aldri blitt assosiert med kunstig intelligens mer enn et vanlig klassisk programmeringsspråk.

På slutten av 80-tallet var det et ekte, relevant og populært intellektuelt prosjekt "The Inventing Machine". Det var et reelt forsøk på å bruke Prolog til å formalisere en enorm praktisk kunnskapsbase (data) om oppfinnelser, fysiske, kjemiske og andre lover.

Resultatet ble ikke oppnådd, for mange fakta og regler måtte skrives i Prolog som programmeringsspråk, som var av banal imperativ karakter. I mellomtiden ble mange vellykkede programvareprodukter implementert parallelt på vanlige språk.

På begynnelsen av 90-tallet ble et prosjekt med et ekte intellektuelt system vellykket implementert som simulerte oppførselen til et barn under 3 år på en EU-datamaskin! Alternativet for å bruke Prolog ble ikke engang vurdert.

Dette intellektuelle systemet "fant ut" ikke bare hva mor og far var, og hvordan Maria skilte seg fra Marina, men hoppet også, uten mye anstrengelse, uavhengig fra den ervervede kunnskapen om disse spørsmålene til kuler og deres forskjeller fra kuber, til fargene på objekter og... (!) til elementær matematikk: enkle aritmetiske operasjoner viste seg å være innenfor hennes evner basert på kunnskapen tilegnet ved å løse helt andre problemer.

Man kan ikke si at klassisk programmering ligger foran Prolog når det gjelder å mestre territoriet til kunstig intelligens, men det gir reelle resultater.

Når det gjelder intelligens som en oppgave, ligger spørsmålet her tilsynelatende ikke i språket, men i ideen om implementering. Hvis 1991-montøren kunne "bli grunnlaget" for et intelligent system for situasjonell intelligens, så ligger problemet tydeligvis ikke i implementeringsspråket, men i ideen.

Prolog programmeringsspråk er et av de ledende logiske programmeringsspråkene. Den ble laget av Alain Colmerauer på 1970-tallet. Det var et forsøk på å lage et programmeringsspråk for nybegynnere som gjør det mulig å uttrykke logikk, fremfor å spesifisere nøye hva man vil oppnå med instruksjoner på en dataskjerm.

Prolog brukes i mange kunstig intelligens-programmer, men syntaksen og semantikken er veldig enkel og tydelig (det opprinnelige formålet var å tilby et verktøy for dataspråklige lingvister). Navnet Prolog er et akronym for LOGIC PROGRAMMING og er viden kjent for å lære det grunnleggende om programmering.

Prolog er basert på predikatregning (mer presist, førsteordens predikatregning), men den er begrenset til Horns formler. Prolog-programmer er effektive for å bevise teoremer til en første tilnærming. Grunnleggende konsepter for sammenføyning, halerekursjon og sporing.

Datatyper

Prolog bruker ikke datatyper på den måten vi er vant til i vanlige programmeringsspråk. Vi kan snakke om Prolog leksikale elementer i stedet for datatyper, noe som er uvanlig i programmering for dummies.

Den konstante teksten legges inn ved hjelp av atomer. Et atom er en sekvens av bokstaver, tall og et understrek som begynner med en liten bokstav. Vanligvis, hvis disse ikke er alfanumeriske atomer, er det nødvendig å ramme dem med apostrof (for eksempel er "+" et atom, + er en operator).

De fleste Prolog-implementeringer skiller ikke mellom reelle og brøktall.

Variabler

Variabler identifiseres med en streng som består av bokstaver, tall og understrekinger, som starter med en stor bokstav. I Prolog-miljøet er ikke en variabel en beholder som kan tildeles (i motsetning til prosedyreprogrammeringsspråk). Dens oppførsel er nærmere en modell som ligner sammenføyninger.

Såkalte anonyme variabler skrives som en enkelt understrek (_).

Vilkår er den eneste måten Prolog kan representere komplekse data på. Begrepet består av et hode, også kalt en funktor (som må være et atom) og parametere (ikke begrenset til typer). Antall parametere, de såkalte arities av begrepet, er viktig. Et begrep er definert av hode og aritet, vanligvis skrevet som funktor/aritet.
Lister

En liste er ikke en frittstående datatype fordi den er definert av rekursiv konstruksjon (bruker termen /2 "."):

Atom - tom liste

For enkelhets skyld for programmereren kan lister konstrueres og ødelegges på forskjellige måter.

Hvis L er en liste og X er et element, så "." (X, L) er medlem av listen. Det første elementet X etterfulgt av innholdet i konteksten L er syntaktisk representert som.

For enkelhets skyld for programmereren kan lister bygges og ødelegges på forskjellige måter.

Vareoppføring:
Forord til ett element:
Foreløpig flere elementer:
Termutvidelse: "."(abc, "."(1, "."(f(x), "."(Y, "."(g(A, første), ))))))

Strenger skrives vanligvis som en sekvens av tegn innenfor anførselstegn. De er ofte representert som lister over ASCII-tegnkoder.

Programmering i PROLOG er veldig forskjellig fra å jobbe med prosedyrespråk. I Prolog jobber du med databaser med fakta og regler, du kan kjøre databasespørringer. Grunnenheten til Prolog er et predikat som er definert til å være sant. Et predikat består av et hode og en rekke argumenter. For eksempel:

Her er "katt" hodet og "tom" er argumentet. Her er noen eksempelspørsmål du kan kjøre ved å bruke Prolog-oversetteren basert på dette faktum:

Katt(tom).
ja.

Katt(X).
X = tom;
Nei.

Predikater er vanligvis definert for å uttrykke et faktum som et program vet om verden. I de fleste tilfeller krever bruk av predikater visse konvensjoner. Så hvilket av følgende vil bety at Pat er Sallys far?

Far (sally, pat).
far (klapp, sally).

"far" er i begge tilfeller hodet, og "sally" og "klapp" er argumentene. Men i det første tilfellet er Sally på førsteplass i listen over argumenter, og Pat er på andreplass og omvendt. Det første tilfellet er et eksempel på en definisjon i rekkefølgen Verb Subject og Object, men i det andre eksemplet er rekkefølgen Verb Object Subject. Siden Prolog ikke forstår engelsk, er begge versjonene fine, men det anses som god programmeringsstil å holde seg til en stil, kalt en konvensjon, mens du skriver ett program, i stedet for å måtte skrive noe sånt som:

Far (pat, sally). far (jessica, james).

Enkelte predikater er innebygd i språket og lar Prolog redusere sliten ved hverdagslige aktiviteter (som input/output ved bruk av grafikk og annen kommunikasjon med operativsystemet). For eksempel kan skrivepredikater brukes for visning som dette:

Skriv ("hei")

Vil vise ordet "Hei" på skjermen.

Regler

Den andre typen utsagn i Prolog er regler. Eksempelregel:

Lys(på) :- slå(på).

":-" betyr "hvis", denne regelen betyr at lys(på) er sant (på) hvis bryter(på) er sant (ellers hvis bryteren er på så er det lys). Regler kan også bruke variabler; variabler begynner med stor bokstav mens konstanter begynner med små bokstaver. For eksempel,

Far(X,Y):- forelder(X,Y),mann(Y).

Dette betyr, "hvis noen er en forelder og han er en mann, så er han en far." Årsaker og virkninger kan også være i omvendt rekkefølge, så dette strider ikke mot vanlig logikk. Du kan plassere flere predikater i konsekvensdelen ved å kombinere dem, for eksempel:

Noe som tilsvarer flere erklæringer:

A:- d. b:- d. c:- d.

Men instruksjoner som:

Som tilsvarer "hvis c så a eller b". Dette er på grunn av begrensningen pålagt av Horns formel.