Programmation logique - Logic programming

« Basé sur des règles » redirige ici. Pour la méthode de traduction automatique, voir Traduction automatique basée sur des règles . Pour les méthodes d'apprentissage automatique, consultez Apprentissage automatique basé sur des règles .
Paradigmes de programmation

La programmation logique est un paradigme de programmation largement basé sur la logique formelle . Tout programme écrit dans un langage de programmation logique est un ensemble de phrases sous forme logique, exprimant des faits et des règles concernant un domaine problématique. Les principales familles de langages de programmation logique incluent Prolog , la programmation par ensemble de réponses (ASP) et Datalog . Dans tous ces langages, les règles sont écrites sous forme de clauses :

H :- B1, …, Bn.

et sont lues déclarativement comme des implications logiques :

H if B1 and … and Bn.

Hs'appelle la tête de la règle et , ..., s'appelle le corps . Les faits sont des règles qui n'ont pas de corps, et sont écrites sous la forme simplifiée : B1Bn

H.

Dans le cas le plus simple où H, , ... , sont toutes des formules atomiques , ces clauses sont appelées clauses définies ou clauses de Horn . Cependant, il existe de nombreuses extensions de ce cas simple, la plus importante étant le cas dans lequel les conditions dans le corps d'une clause peuvent également être des négations de formules atomiques. Les langages de programmation logique qui incluent cette extension ont les capacités de représentation des connaissances d'une logique non monotone . B1Bn

En ASP et Datalog, les programmes logiques n'ont qu'une lecture déclarative , et leur exécution est effectuée au moyen d'une procédure de preuve ou d'un générateur de modèle dont le comportement n'est pas destiné à être contrôlé par le programmeur. Cependant, dans la famille des langages Prolog, les programmes logiques ont également une interprétation procédurale en tant que procédures de réduction d'objectifs :

résoudre H, résoudre , et ... et résoudre .B1Bn

Prenons l'exemple de la clause suivante :

fallible(X) :- human(X).

basé sur un exemple utilisé par Terry Winograd pour illustrer le langage de programmation Planner . En tant que clause dans un programme logique, elle peut être utilisée à la fois comme procédure pour tester si Xest fallibleen testant si Xest human, et comme procédure pour trouver un Xqui est fallibleen trouvant un Xqui est human. Même les faits ont une interprétation procédurale. Par exemple, la clause :

human(socrates).

peut être utilisé à la fois comme procédure pour montrer que socratesest human, et comme procédure pour trouver un Xqui est humanen "assignant" socratesà X.

La lecture déclarative des programmes logiques peut être utilisée par un programmeur pour vérifier leur exactitude. De plus, les techniques de transformation de programme basées sur la logique peuvent également être utilisées pour transformer des programmes logiques en programmes logiquement équivalents qui sont plus efficaces. Dans la famille Prolog des langages de programmation logique, le programmeur peut également utiliser le comportement de résolution de problèmes connu du mécanisme d'exécution pour améliorer l'efficacité des programmes.

Histoire

L'utilisation de la logique mathématique pour représenter et exécuter des programmes informatiques est également une caractéristique du calcul lambda , développé par Alonzo Church dans les années 1930. Cependant, la première proposition d'utiliser la forme clausale de la logique pour représenter les programmes informatiques a été faite par Cordell Green . Cela a utilisé une axiomatisation d'un sous-ensemble de LISP , ainsi qu'une représentation d'une relation d'entrée-sortie, pour calculer la relation en simulant l'exécution du programme dans LISP. Absys de Foster et Elcock , d'autre part, a utilisé une combinaison d'équations et de calcul lambda dans un langage de programmation assertif qui n'impose aucune contrainte sur l'ordre dans lequel les opérations sont effectuées.

La programmation logique sous sa forme actuelle remonte aux débats de la fin des années 1960 et du début des années 1970 sur les représentations déclaratives et procédurales de la connaissance en intelligence artificielle . Les défenseurs des représentations déclaratives travaillaient notamment à Stanford , associés à John McCarthy , Bertram Raphael et Cordell Green, et à Édimbourg , avec John Alan Robinson (un universitaire invité de l'université de Syracuse ), Pat Hayes et Robert Kowalski . Les défenseurs des représentations procédurales étaient principalement centrés au MIT , sous la direction de Marvin Minsky et Seymour Papert .

Bien qu'il soit basé sur les méthodes de preuve de la logique, Planner , développé au MIT, a été le premier langage à émerger au sein de ce paradigme procéduraliste. Planificateur présenté appel dirigé motif des plans de procédure d'objectifs (c. -à- objectif de réduction ou chaînage arrière ) et des assertions (c. -à chaînage avant ). La mise en œuvre la plus influente de Planner était le sous-ensemble de Planner, appelé Micro-Planner, mis en œuvre par Gerry Sussman , Eugene Charniak et Terry Winograd . Il a été utilisé pour mettre en œuvre le programme de compréhension du langage naturel SHRDLU de Winograd , qui était un point de repère à l'époque. Pour faire face aux systèmes de mémoire très limités à l'époque, Planner a utilisé une structure de contrôle de retour en arrière de sorte qu'un seul chemin de calcul possible devait être stocké à la fois. Planner a donné naissance aux langages de programmation QA-4, Popler, Conniver, QLISP et au langage concurrent Ether.

Hayes et Kowalski à Édimbourg ont tenté de concilier l'approche déclarative fondée sur la logique de la représentation des connaissances avec l'approche procédurale de Planner. Hayes (1973) a développé un langage équationnel, Golux, dans lequel différentes procédures pouvaient être obtenues en modifiant le comportement du prouveur de théorème. Kowalski, d'autre part, a développé la résolution SLD , une variante de la résolution SL, et a montré comment elle traite les implications comme des procédures de réduction d'objectifs. Kowalski a collaboré avec Colmerauer à Marseille, qui a développé ces idées dans la conception et la mise en œuvre du langage de programmation Prolog .

L' Association for Logic Programming a été fondée pour promouvoir la programmation logique en 1986.

Prolog a donné lieu à des langages de programmation ALF , FRIL , Gödel , Mercure , Oz , Ciao , Visual Prolog , XSB et λProlog , ainsi qu'une variété de langages de programmation logiques simultanées , programmation logique contrainte langues et Datalog .

notions

Logique et contrôle

Article détaillé : Programmation déclarative

La programmation logique peut être considérée comme une déduction contrôlée. Un concept important dans la programmation logique est la séparation des programmes en leur composant logique et leur composant de contrôle. Avec les langages de programmation purement logiques, le composant logique seul détermine les solutions produites. Le composant de commande peut être modifié pour fournir d'autres manières d'exécuter un programme logique. Cette notion est capturée par le slogan

Algorithme = Logique + Contrôle

où « Logique » représente un programme logique et « Contrôle » représente différentes stratégies de preuve de théorème.

Résolution de problème

Dans le cas propositionnel simplifié dans lequel un programme logique et un objectif atomique de niveau supérieur ne contiennent aucune variable, le raisonnement en arrière détermine un arbre et-ou , qui constitue l'espace de recherche pour résoudre l'objectif. L'objectif de niveau supérieur est la racine de l'arbre. Etant donné tout nœud de l'arbre et toute clause dont la tête correspond au nœud, il existe un ensemble de nœuds enfants correspondant aux sous-buts dans le corps de la clause. Ces nœuds enfants sont regroupés par un "et". Les ensembles alternatifs d'enfants correspondant à des manières alternatives de résoudre le nœud sont regroupés par un "ou".

N'importe quelle stratégie de recherche peut être utilisée pour rechercher cet espace. Prolog utilise une stratégie de retour en arrière séquentiel, dernier entré, premier sorti, dans laquelle une seule alternative et un seul sous-objectif sont pris en compte à la fois. D'autres stratégies de recherche, telles que la recherche parallèle, le backtracking intelligent ou la recherche du meilleur premier pour trouver une solution optimale, sont également possibles.

Dans le cas plus général, où les sous-objectifs partagent des variables, d'autres stratégies peuvent être utilisées, comme le choix du sous-objectif le plus instancié ou suffisamment instancié pour qu'une seule procédure s'applique. De telles stratégies sont utilisées, par exemple, dans la programmation logique concurrente .

La négation comme échec

Article détaillé : La négation comme échec

Pour la plupart des applications pratiques, ainsi que pour les applications qui nécessitent un raisonnement non monotone en intelligence artificielle, les programmes logiques de la clause Horn doivent être étendus aux programmes logiques normaux, avec des conditions négatives. Une clause dans un programme logique normal a la forme :

H :- A1, …, An, not B1, …, not Bn.

et se lit déclarativement comme une implication logique :

H if A1 and … and An and not B1 and … and not Bn.

où Het tous les et sont des formules atomiques. La négation dans les littéraux négatifs est communément appelée « négation en tant qu'échec », car dans la plupart des implémentations, une condition négative est démontrée en montrant que la condition positive ne tient pas. Par exemple: AiBi not Bi not Bi Bi

canfly(X) :- bird(X), not abnormal(X).
abnormal(X) :- wounded(X).
bird(john).
bird(mary).
wounded(john).

Étant donné l'objectif de trouver quelque chose qui peut voler : 

:- canfly(X).

il y a deux solutions candidates, qui résolvent le premier sous-objectif bird(X), à savoir X = johnet X = mary. Le deuxième sous-objectif not abnormal(john)de la première solution candidate échoue, car wounded(john)réussit et abnormal(john)réussit donc . Cependant, le deuxième sous-objectif not abnormal(mary)de la deuxième solution candidate réussit, car wounded(mary)échoue et donc abnormal(mary)échoue. Par conséquent, X = maryest la seule solution de l'objectif.

Micro-Planner avait une construction, appelée "thnot", qui, lorsqu'elle est appliquée à une expression, renvoie la valeur true si (et seulement si) l'évaluation de l'expression échoue. Un opérateur équivalent existe généralement dans les implémentations modernes de Prolog . Il est généralement écrit sous la forme ou , où est un objectif (proposition) à prouver par le programme. Cet opérateur diffère de la négation en logique du premier ordre : une négation telle que échoue lorsque la variable a été liée à l'atome , mais elle réussit dans tous les autres cas, y compris lorsqu'elle n'est pas liée. Cela rend le raisonnement de Prolog non monotone : échoue toujours, tandis que peut réussir, se liant à , selon qu'il a été initialement lié (notez que le Prolog standard exécute les objectifs dans l'ordre de gauche à droite). not(Goal)\+ GoalGoal\+ X == 1X1XX = 1, \+ X == 1\+ X == 1, X = 1X1X

Le statut logique de la négation en tant qu'échec n'était pas résolu jusqu'à ce que Keith Clark [1978] montre que, dans certaines conditions naturelles, il s'agit d'une mise en œuvre correcte (et parfois complète) de la négation classique par rapport à l'achèvement du programme. L'achèvement revient approximativement à considérer l'ensemble de toutes les clauses du programme avec le même prédicat sur le côté gauche, disons

H :- Body1.
…
H :- Bodyk.

comme définition du prédicat

H iff (Body1 or … or Bodyk)

où « si » signifie « si et seulement si ». L'écriture de la complétion nécessite également l'utilisation explicite du prédicat d'égalité et l'inclusion d'un ensemble d'axiomes appropriés pour l'égalité. Cependant, la mise en œuvre de la négation en tant qu'échec n'a besoin que des demi-si des définitions sans les axiomes d'égalité.

Par exemple, l'achèvement du programme ci-dessus est :

canfly(X) iff bird(X), not abnormal(X).
abnormal(X) iff wounded(X).
bird(X) iff X = john or X = mary.
X = X.
not john = mary.
not mary = john.

La notion d'achèvement est étroitement liée à la sémantique de circonscription de McCarthy pour le raisonnement par défaut, et à l' hypothèse du monde fermé .

Comme alternative à la sémantique de complétion, la négation en tant qu'échec peut également être interprétée de manière épistémique, comme dans la sémantique du modèle stable de la programmation d'ensembles de réponses . Dans cette interprétation not(B i ) signifie littéralement que B i n'est pas connu ou n'est pas cru. L'interprétation épistémique a l'avantage de pouvoir être combinée très simplement avec la négation classique, comme dans la "programmation logique étendue", pour formaliser des phrases telles que "le contraire ne peut pas être démontré", où "contraire" est la négation classique et "ne peut pas être montré » est l'interprétation épistémique de la négation comme échec.

Représentation des connaissances

Le fait que les clauses de Horn puissent recevoir une interprétation procédurale et, vice versa, que les procédures de réduction d'objectifs puissent être comprises comme des clauses de Horn + un raisonnement à rebours signifie que les programmes logiques combinent des représentations déclaratives et procédurales de la connaissance . L'inclusion de la négation comme échec signifie que la programmation logique est une sorte de logique non monotone .

Malgré sa simplicité par rapport à la logique classique, cette combinaison de clauses de Horn et de négation comme échec s'est avérée étonnamment expressive. Par exemple, il fournit une représentation naturelle des lois de sens commun de cause à effet, telles qu'elles sont formalisées à la fois par le calcul de situation et le calcul d'événement . Il s'est également avéré qu'il correspondait tout naturellement au langage semi-formel de la législation. En particulier, Prakken et Sartor attribuent à la représentation de la British Nationality Act en tant que programme logique d'être « extrêmement influente pour le développement de représentations informatiques de la législation, montrant comment la programmation logique permet des représentations intuitivement attrayantes qui peuvent être directement déployées pour générer des inférences automatiques ». .

Variantes et extensions

Prologue

Article principal : Prologue

Le langage de programmation Prolog a été développé en 1972 par Alain Colmerauer . Il est né d'une collaboration entre Colmerauer à Marseille et Robert Kowalski à Edimbourg. Colmerauer travaillait sur la compréhension du langage naturel , en utilisant la logique pour représenter la sémantique et en utilisant la résolution pour les questions-réponses. Au cours de l'été 1971, Colmerauer et Kowalski ont découvert que la forme clausale de la logique pouvait être utilisée pour représenter des grammaires formelles et que les démonstrateurs de théorème de résolution pouvaient être utilisés pour l'analyse. Ils ont observé que certains prouveurs de théorèmes, comme l'hyper-résolution, se comportent comme des analyseurs syntaxiques ascendants et d'autres, comme la résolution SL (1971), se comportent comme des analyseurs syntaxiques descendants.

C'est au cours de l'été 1972 suivant, que Kowalski, travaillant à nouveau avec Colmerauer, développa l'interprétation procédurale des implications. Cette double interprétation déclarative/procédurale s'est ensuite formalisée dans la notation Prolog

H :- B1, …, Bn.

qui peut être lu (et utilisé) à la fois de manière déclarative et procédurale. Il est également devenu clair que de telles clauses pourraient être restreintes à des clauses définies ou à des clauses de Horn , où H, , ..., sont toutes des formules de logique de prédicat atomique, et que la résolution SL pourrait être restreinte (et généralisée) à la résolution LUSH ou SLD . L'interprétation procédurale de Kowalski et LUSH ont été décrites dans un mémo de 1973, publié en 1974. B1Bn

Colmerauer, avec Philippe Roussel, a utilisé cette double interprétation des clauses comme base de Prolog, qui a été mis en œuvre à l'été et à l'automne 1972. Le premier programme Prolog, également écrit en 1972 et mis en œuvre à Marseille, était un système français de questions-réponses. . L'utilisation de Prolog comme langage de programmation pratique a reçu un grand élan par le développement d'un compilateur par David Warren à Edimbourg en 1977. Des expériences ont démontré que Edinburgh Prolog pouvait rivaliser avec la vitesse de traitement d'autres langages de programmation symboliques tels que Lisp . Edinburgh Prolog est devenu la norme de facto et a fortement influencé la définition de la norme ISO Prolog.

Programmation logique abductive

La programmation logique abductive est une extension de la programmation logique normale qui permet à certains prédicats, déclarés comme prédicats abductibles, d'être "ouverts" ou indéfinis. Une clause dans un programme logique abductif a la forme :

H :- B1, …, Bn, A1, …, An.

où Hest une formule atomique qui n'est pas abductible, tous les sont des littéraux dont les prédicats ne sont pas abductibles, et les sont des formules atomiques dont les prédicats sont abductibles. Les prédicats abductibles peuvent être contraints par des contraintes d'intégrité, qui peuvent avoir la forme : BiAi

false :- L1, …, Ln.

où les sont des littéraux arbitraires (définis ou abductibles, et atomiques ou niés). Par exemple: Li

canfly(X) :- bird(X), normal(X).
false :- normal(X), wounded(X).
bird(john).
bird(mary).
wounded(john).

où le prédicat normalest abductible.

La résolution de problèmes est réalisée en dérivant des hypothèses exprimées en termes de prédicats abductibles en tant que solutions de problèmes à résoudre. Ces problèmes peuvent être soit des observations qui doivent être expliquées (comme dans le raisonnement abductif classique ) soit des objectifs à résoudre (comme dans la programmation logique normale). Par exemple, l'hypothèse normal(mary)explique l'observation canfly(mary). De plus, la même hypothèse entraîne la seule solution X = marydu but de trouver quelque chose qui puisse voler : 

:- canfly(X).

La programmation logique abductive a été utilisée pour le diagnostic des pannes, la planification, le traitement du langage naturel et l'apprentissage automatique. Il a également été utilisé pour interpréter la négation comme un échec comme une forme de raisonnement abductif.

Programmation métalologique

Parce que la logique mathématique a une longue tradition de distinction entre le langage objet et le métalangage, la programmation logique permet également la programmation au niveau méta . Le programme métalogique le plus simple est le méta-interprète dit " vanille " : 

    solve(true).
    solve((A,B)):- solve(A),solve(B).
    solve(A):- clause(A,B),solve(B).

où true représente une conjonction vide, et clause(A,B) signifie qu'il existe une clause de niveau objet de la forme A :- B.

La programmation métalologique permet de combiner des représentations au niveau objet et au niveau méta, comme en langage naturel. Il peut également être utilisé pour implémenter toute logique spécifiée en tant que règles d'inférence . Metalogic est utilisé dans la programmation logique pour implémenter des métaprogrammes, qui manipulent d'autres programmes, bases de données, bases de connaissances ou théories axiomatiques en tant que données.

Programmation logique de contraintes

Article principal: programmation de logique de contrainte

La programmation logique de contraintes combine la programmation logique de clause Horn avec la résolution de contraintes . Il étend les clauses Horn en permettant à certains prédicats, déclarés comme prédicats de contrainte, d'apparaître sous forme de littéraux dans le corps des clauses. Un programme logique de contraintes est un ensemble de clauses de la forme :

H :- C1, …, Cn ◊ B1, …, Bn.

où Het tous les sont des formules atomiques, et les sont des contraintes. De manière déclarative, de telles clauses sont lues comme des implications logiques ordinaires : BiCi

H if C1 and … and Cn and B1 and … and Bn.

Cependant, alors que les prédicats dans les têtes de clauses sont définis par le programme de logique de contraintes, les prédicats dans les contraintes sont prédéfinis par une structure ou une théorie théorique du modèle spécifique au domaine.

Sur le plan procédural, les sous-objectifs dont les prédicats sont définis par le programme sont résolus par réduction de but, comme dans la programmation logique ordinaire, mais la satisfiabilité des contraintes est vérifiée par un solveur de contraintes spécifique au domaine, qui implémente la sémantique des prédicats de contraintes. Un problème initial est résolu en le réduisant à une conjonction satisfiable de contraintes.

Le programme logique de contrainte suivant représente une base de données temporelle de jouet de l' john'shistoire en tant qu'enseignant : 

teaches(john, hardware, T) :- 1990 ≤ T, T < 1999.
teaches(john, software, T) :- 1999 ≤ T, T < 2005.
teaches(john, logic, T) :- 2005 ≤ T, T ≤ 2012.
rank(john, instructor, T) :- 1990 ≤ T, T < 2010.
rank(john, professor, T) :- 2010 ≤ T, T < 2014.

Voici ≤et <sont des prédicats de contraintes, avec leur sémantique habituelle. La clause de but suivante interroge la base de données pour savoir quand à la johnfois enseigné logicet était un professor:

:- teaches(john, logic, T), rank(john, professor, T).

La solution est 2010 ≤ T, T ≤ 2012.

La programmation de logique de contrainte a été utilisée pour résoudre des problèmes dans des domaines tels que le génie civil , le génie mécanique , la vérification de circuits numériques , l'établissement d'horaires automatisés , le contrôle du trafic aérien et la finance. Elle est étroitement liée à la programmation logique abductive .

Programmation logique concurrente

Article principal: programmation logique concurrente

La programmation logique concurrente intègre les concepts de programmation logique avec la programmation concurrente . Son développement a reçu une grande impulsion dans les années 1980 par son choix pour le langage de programmation système du Japanese Fifth Generation Project (FGCS) .

Un programme logique concurrent est un ensemble de clauses Horn gardées de la forme :

H :- G1, …, Gn | B1, …, Bn.

La conjonction est appelée la garde de la clause et est l'opérateur d'engagement. De manière déclarative, les clauses de Horn gardées sont lues comme des implications logiques ordinaires : G1, ... , Gn |

H if G1 and … and Gn and B1 and … and Bn.

Cependant, procéduralement, lorsqu'il y a plusieurs clauses dont les têtes H correspondent à un but donné, alors toutes les clauses sont exécutées en parallèle, en vérifiant si leurs gardes tiennent. Si les gardes de plus d'une clause tiennent, alors un choix engagé est fait pour l'une des clauses, et l'exécution se poursuit avec les sous-buts de la clause choisie. Ces sous-objectifs peuvent également être exécutés en parallèle. Ainsi, la programmation logique concurrente implémente une forme de « non-déterminisme » plutôt que « je ne sais pas le non-déterminisme ». G1, ... , Gn B1, ..., Bn

Par exemple, le programme logique concurrent suivant définit un prédicat shuffle(Left, Right, Merge) , qui peut être utilisé pour mélanger deux listes Leftet Right, les combinant en une seule liste Mergequi préserve l'ordre des deux listes Leftet Right: 

shuffle([], [], []).
shuffle(Left, Right, Merge) :-
    Left = [First | Rest] |
    Merge = [First | ShortMerge],
    shuffle(Rest, Right, ShortMerge).
shuffle(Left, Right, Merge) :-
    Right = [First | Rest] |
    Merge = [First | ShortMerge],
    shuffle(Left, Rest, ShortMerge).

Ici, []représente la liste vide, et [Head | Tail]représente une liste avec le premier élément Headsuivi de list Tail, comme dans Prolog. (Notez que la première occurrence de | dans les deuxième et troisième clauses est le constructeur de liste, tandis que la deuxième occurrence de | est l'opérateur d'engagement.) Le programme peut être utilisé, par exemple, pour mélanger les listes [ace, queen, king]et [1, 4, 2]en appelant la clause goal : 

shuffle([ace, queen, king], [1, 4, 2], Merge).

Le programme générera de manière non déterministe une solution unique, par exemple Merge = [ace, queen, 1, king, 4, 2].

On peut soutenir que la programmation logique concurrente est basée sur la transmission de messages, elle est donc soumise à la même indétermination que les autres systèmes de transmission de messages concurrents, tels que les acteurs (voir Indétermination dans le calcul concurrent ). Carl Hewitt a soutenu que la programmation logique concurrente n'est pas basée sur la logique dans le sens où les étapes de calcul ne peuvent pas être déduites logiquement. Cependant, dans la programmation logique concurrente, tout résultat d'un calcul de fin est une conséquence logique du programme, et tout résultat partiel d'un calcul partiel est une conséquence logique du programme et de l'objectif résiduel (réseau de processus). Ainsi l'indétermination des calculs implique que toutes les conséquences logiques du programme ne peuvent pas être déduites.

Programmation logique de contraintes concurrentes

Article principal: programmation de logique de contrainte concurrente

La programmation logique à contraintes concurrentes combine la programmation logique concurrente et la programmation logique à contraintes , en utilisant des contraintes pour contrôler la concurrence. Une clause peut contenir une garde, qui est un ensemble de contraintes pouvant bloquer l'applicabilité de la clause. Lorsque les gardes de plusieurs clauses sont satisfaites, la programmation logique à contraintes concurrentes fait un choix engagé pour n'en utiliser qu'une.

Programmation logique inductive

Article principal: programmation logique inductive

La programmation logique inductive s'intéresse à la généralisation d'exemples positifs et négatifs dans le contexte des connaissances de base : l'apprentissage automatique des programmes logiques. Des travaux récents dans ce domaine, combinant programmation logique, apprentissage et probabilité, ont donné naissance au nouveau domaine de l'apprentissage relationnel statistique et de la programmation logique inductive probabiliste .

Programmation logique d'ordre supérieur

Plusieurs chercheurs ont étendu la programmation logique avec des fonctionnalités de programmation d'ordre supérieur dérivées de la logique d'ordre supérieur , telles que les variables de prédicat. Ces langages incluent les extensions Prolog HiLog et λProlog .

Programmation logique linéaire

Baser la programmation logique dans la logique linéaire a abouti à la conception de langages de programmation logique qui sont considérablement plus expressifs que ceux basés sur la logique classique. Les programmes de clause Horn ne peuvent représenter le changement d'état que par le changement d'arguments en prédicats. En programmation logique linéaire, on peut utiliser la logique linéaire ambiante pour prendre en charge le changement d'état. Parmi les premiers modèles de langages de programmation logique basés sur la logique linéaire, citons LO [Andreoli & Pareschi, 1991], Lolli, ACL et Forum [Miller, 1996]. Forum fournit une interprétation orientée vers un objectif de toute la logique linéaire.

Programmation logique orientée objet

F-logic étend la programmation logique avec des objets et la syntaxe des trames.

Logtalk étend le langage de programmation Prolog avec la prise en charge d'objets, de protocoles et d'autres concepts de POO. Il prend en charge la plupart des systèmes Prolog conformes aux normes en tant que compilateurs principaux.

Programmation logique de transaction

La logique de transaction est une extension de la programmation logique avec une théorie logique des mises à jour modifiant l'état. Il a à la fois une sémantique théorique des modèles et une sémantique procédurale. Une implémentation d'un sous-ensemble de logique de transaction est disponible dans le système Flora-2 . D'autres prototypes sont également disponibles .

Voir également

Citations

Sources

Présentations générales

Autres sources

Lectures complémentaires

Liens externes