Fril

Fril
Paradigm Logisk programmering
Designad av Trevor Martin
Dök först upp 1980 ; 43 år sedan ( 1980 )
Stabil frisättning
4.984 / 23 augusti 2011 ; för 11 år sedan ( 2011-08-23 )
Licens Proprietär programvara
Filnamnstillägg .frl
Influerad av
mikro-PROLOG [ es ]

Fril är ett programmeringsspråk för första ordningens predikatkalkyl . Den inkluderar semantiken för Prolog som en delmängd, men tar sin syntax från mikro-PROLOG [ es ] av Logic Programming Associates och lägger till stöd för fuzzy sets , support logic och metaprogrammering .

Fril utvecklades ursprungligen av Trevor Martin och Jim Baldwin vid University of Bristol runt 1980. 1986 plockades den upp och vidareutvecklades av Equipu AI Research, som senare blev Fril Systems Ltd. Namnet Fril var ursprungligen en akronym för Fuzzy Relational Inferensspråk .

Prolog och Fril jämförelse

Bortsett från osäkerhetshanteringsfunktionerna hos Fril, finns det några mindre skillnader i Frils implementering av standard Prolog-funktioner.

Typer

De grundläggande typerna i Fril liknar de i Prolog , med ett viktigt undantag: Prologs sammansatta datatyp är termen , med listor definierade som kapslade termer med hjälp av . funktör; i Fril är den sammansatta typen själva listan, som ligger till grund för de flesta konstruktioner. Variabler särskiljs av identifierare som endast innehåller versaler och understreck (medan Prolog endast kräver att det första tecknet är versaler). Som i Prolog är namnet _ reserverat för att betyda "vilket värde som helst", med flera förekomster av _ ersatta av distinkta variabler.

Syntax

Prolog har en syntax med en typisk mängd skiljetecken, medan Fril har en extremt enkel syntax som liknar den för Lisp . En (propositionell) klausul är en lista som består av ett predikat följt av dess argument (om några). Bland typerna av konstruktioner på toppnivå finns regler och kommandon i direktläge.

Regel

En regel är en lista som består av en slutsats följt av hypoteserna ( målen ). De allmänna formerna ser ut så här:

  (  faktum  ) (  slutsats  mål_1  ...  mål_n  ) 

Dessa är likvärdiga med respektive Prolog-konstruktioner:

 faktum  .  slutsats  :-  mål_1  , ...,  mål_n  . 

Tänk till exempel på medlemspredikatet i Prolog:

  
      medlem  (  E  ,  [  E  |  _  ]).  medlem  (  E  ,  [  _  |  T  ])  :-  medlem  (  E  ,  T  ). 

I Fril blir detta:

((medlem E (E|_))) ((medlem E (_|T)) (medlem ET))

Relation

Vissa data kan representeras i form av relationer . En relation är likvärdig med en uppsättning fakta med samma predikatnamn och konstant aritet , förutom att ingen av fakta kan tas bort (annat än genom att döda relationen); en sådan representation förbrukar mindre minne internt. En relation skrivs ordagrant som en lista som består av predikatnamnet följt av en eller flera tuplar av relationen (alla argumenten för motsvarande faktum utan predikatnamnet). Ett predikat kan också förklaras som en relation genom att anropa def_rel -predikatet; detta fungerar bara om det föreslagna namnet inte redan finns i kunskapsbasen . När ett predikat är en relation, lägger allt som vanligtvis skulle lägga till en regel (och inte bryter mot begränsningarna för relationer) automatiskt till en tupel till relationen istället.

Här är ett exempel. Följande faktauppsättning:

((min-mindre-än 2 3)) ((min-mindre-än 8 23)) ((min-mindre-än 42 69))

kan skrivas om som relationen:

(min-mindre-än (2 3) (8 23) (42 69))

Direktläge

Ett predikat kan anropas med exakt ett argument med hjälp av syntaxen:

  predikatargument  _ 

Frågor skickas med denna syntax, med predikatet ? (eller något av de andra frågerelaterade predikaten).

Luddiga uppsättningar

Fril stöder både kontinuerliga och diskreta fuzzy set, alla med sina egna speciella syntaxer. En diskret uppsättning ( dtype ) listar diskreta värden och deras grader av medlemskap, med denna syntax:

  {  värde  :  dom  värde  :  dom  ...  värde  :  dom  } 

värde är en atom eller ett tal, och dom är ett värde i intervallet [0, 1].

En kontinuerlig uppsättning ( itype ) listar reella tal och deras grader av medlemskap; graden av medlemskap är den linjära interpolationen över dessa mappningar. Syntaxen är alltså:

  [  värde  :  dom  värde  :  dom  ...  värde  :  dom  ] 

där värdena ska anges i icke-fallande ordning.

Varje dtype och itype kan begränsas till ett universum (en uppsättning tillåtna värden). Fril har predikat för fuzzy set-operationer (men stöder inte direkt kontroll genom fuzzy logic ). Det är till och med möjligt att kombinera dtypes och itypes genom vissa operationer, så länge som dtypes endast innehåller reella tal.

Stödpar

Vilken regel som helst kan ha ett sannolikhetsintervall (kallat stödpar) associerat med sig genom att lägga till :( min max ) till den, där min och max är minsta och maximala sannolikheter. Fril inkluderar predikat som beräknar stödet för en given fråga.

Åtskiljande

Medan Prolog använder skiljetecken — nämligen ; — för disjunktion inom satser har Fril istället ett inbyggt predikat orr .

Meriter

Det finns fördelar och nackdelar med denna enklare syntax. På den positiva sidan gör det predikat som Prologs =.. (som mappar mellan listor och satser) onödiga, eftersom en sats är en lista. Å andra sidan är det svårare att läsa.

Beteende

Som en logisk programmeringsmiljö är Fril väldigt lik Prolog. Här är några av skillnaderna:

  • Både Prolog och Fril har skalapplikationer , som fungerar som standardsättet att interagera med dem. Prolog läser kommandon i två lägen: i läsläge för källfil accepterar den direktiv och satser; i användarinteraktionsläge accepterar den endast frågor (även om det är möjligt att säga till Prolog att läsa direktiv och klausuler från standardinmatning genom att använda consult(användare). ). Fril gör ingen skillnad: alla typer av kommandon kan ges både från källfiler och på kommandoraden.
  • Prolog-skalet skriver automatiskt ut värdena för alla instansierade variabler som visas i en fråga, tillsammans med ett ja eller nej -svar. Fril-skalet ger bara svaret; det är användarens ansvar att skriva ut variabler om så önskas.

externa länkar