{"id":458,"date":"2022-06-22T15:00:03","date_gmt":"2022-06-22T15:00:03","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=458"},"modified":"2022-06-22T15:00:03","modified_gmt":"2022-06-22T15:00:03","slug":"prolog-etape-b","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/prolog-etape-b\/","title":{"rendered":"PROLOG : \u00e9tape B"},"content":{"rendered":"\n<div class=\"wp-block-jetpack-markdown\"><p><code>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l'universit\u00e9 de Bourgogne.<\/code><\/p>\n<h1>R\u00e8gles complexes &#8211; D\u00e9couverte<\/h1>\n<p>Cette <strong>activit\u00e9 de d\u00e9couverte<\/strong> consiste \u00e0 \u00e9tudier des <strong>pr\u00e9sentations explicatives<\/strong> et \u00e0 traiter tous les <strong>exercices de d\u00e9couverte<\/strong> propos\u00e9s. Si vous ne r\u00e9pondez pas correctement \u00e0 un exercice de d\u00e9couverte, revenez en arri\u00e8re pour relire les explications et identifier la cause de votre erreur.<\/p>\n<h2>Activit\u00e9 de d\u00e9couverte B.dec<\/h2>\n<h3>Introduction<\/h3>\n<p>Nous allons d\u00e9couvrir comment et pourquoi \u00e9crire des r\u00e8gles r\u00e9cursives, mais aussi quelques briques de constructions permettant d&rsquo;enrichir la puissance d&rsquo;expression des pr\u00e9dicats, telles que la n\u00e9gation, les variables anonymes, et le moyen de r\u00e9aliser des calculs arithm\u00e9tiques.<\/p>\n<h3>B.dec1 : R\u00e9cursivit\u00e9<\/h3>\n<p>On introduit une nouvelle relation qui d\u00e9crit une hi\u00e9rarchie entre joueurs. Cette relation est d\u00e9finie par le pr\u00e9dicat <code>mentor<\/code>.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pB1.png\" alt=\"pB1\"><\/p>\n<p>Dans le code Prolog, ce pr\u00e9dicat est d\u00e9fini par les faits suivants :<\/p>\n<pre><code>mentor(anne,charlie).\nmentor(charlie,dave).\nmentor(dave,edouard).\nmentor(anne,bart).\n<\/code><\/pre>\n<p>On d\u00e9finit un pr\u00e9dicat <code>sup<\/code>, repr\u00e9sentant le concept de sup\u00e9rieur hi\u00e9rarchique, de la mani\u00e8re suivante :<\/p>\n<pre><code>sup(S,J) :- mentor(S,J).\nsup(S,J) :- mentor(S,T), sup(T,J).\n<\/code><\/pre>\n<p>Ce pr\u00e9dicat est r\u00e9cursif. Il est d\u00e9finit par deux clauses qui pourraient \u00eatre traduite en fran\u00e7ais de la mani\u00e8re suivante.<\/p>\n<p><strong>Premi\u00e8re clause<\/strong> :<\/p>\n<blockquote>\n<p><strong>Si<\/strong> <code>S<\/code> est un mentor de <code>J<\/code>, <strong>alors<\/strong> <code>S<\/code> est un sup\u00e9rieur hi\u00e9rarchique de <code>J<\/code>.<\/p>\n<\/blockquote>\n<p><strong>Deuxi\u00e8me clause<\/strong> :<\/p>\n<blockquote>\n<p><strong>Si<\/strong> <code>S<\/code> est un mentor de <code>T<\/code> <strong>et<\/strong> si <code>T<\/code> est un sup\u00e9rieur hi\u00e9rarchique de  <code>J<\/code>, <strong>alors<\/strong> <code>S<\/code> est un sup\u00e9rieur hi\u00e9rarchique de <code>J<\/code>.<\/p>\n<\/blockquote>\n<p>Par exemple, le but&#8230;<\/p>\n<pre><code>sup(S,edouard).\n<\/code><\/pre>\n<p>&#8230;a pour r\u00e9sultat :<\/p>\n<pre><code>S = dave\nS = anne\nS = charlie\n<\/code><\/pre>\n<p>Dans un Prolog id\u00e9al, on devrait pouvoir donner les sous-buts d&rsquo;une clause dans n&rsquo;importe quel ordre, et \u00e9crire par exemple :<\/p>\n<pre><code>sup(S,J) :- mentor(S,J).\nsup(S,J) :- sup(T,J), mentor(S,T).\n<\/code><\/pre>\n<p>Mais en pratique, une telle impl\u00e9mentation va conduire \u00e0 des bouclages infinis lors de l&rsquo;ex\u00e9cution de certains buts.<\/p>\n<p>La bonne pratique \u00e0 respecter est de faire les appels r\u00e9cursifs le plus tardivement possible dans la liste des sous-buts des clauses r\u00e9cursives.<\/p>\n<h5>Exercice de d\u00e9couverte B.x1<\/h5>\n<p>Sans utiliser d&rsquo;interpr\u00e9teur Prolog, d\u00e9terminez le r\u00e9sultat du but suivant :<\/p>\n<pre><code>sup(charlie,J).\n<\/code><\/pre>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code>J = dave\nJ = edouard\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On dit que deux joueurs sont <strong>condisciples<\/strong> s&rsquo;ils ont au moins un sup\u00e9rieur hi\u00e9rarchique commun. Sp\u00e9cifiez un pr\u00e9dicat <code>cond\/2<\/code> tel que <code>cond(A,B)<\/code> est satisfait si et seulement si <code>A<\/code> et <code>B<\/code> sont condisciples.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code>cond(A,B) :- sup(S,A), sup(S,B).\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>B.dec2 : N\u00e9gation et variables anonymes<\/h3>\n<p>On dit qu&rsquo;un joueur <code>L<\/code> est <strong>leader<\/strong> d&rsquo;un joueur <code>J<\/code> si et seulement si <code>L<\/code> est un sup\u00e9rieur hi\u00e9rarchique de <code>J<\/code> et n&rsquo;a lui-m\u00eame aucun sup\u00e9rieur hi\u00e9rarchique.<\/p>\n<p>Pour d\u00e9finir le pr\u00e9dicat <code>leader<\/code> exprimant cette propri\u00e9t\u00e9, nous utilisons une n\u00e9gation et une variable anonyme :<\/p>\n<pre><code>leader(L,J) :- sup(L,J), not(mentor(_,L)).\n<\/code><\/pre>\n<p>Le premier sous-but \u00e9tant \u00e9vident, int\u00e9ressons-nous au deuxi\u00e8me :<\/p>\n<ul>\n<li>Dans <code>mentor(_,L)<\/code>, le symbole <code>_<\/code> repr\u00e9sente une variable dont la valeur n&rsquo;est pas r\u00e9utilis\u00e9e et n&rsquo;a pas d&rsquo;importance. Le but <code>mentor(_,L)<\/code> est satisfait si <code>L<\/code> a au moins un mentor, dont le nom est sans importance.<\/li>\n<li>La n\u00e9gation <code>not(mentor(_,L))<\/code> a pour r\u00e9sultat la n\u00e9gation logique de l&rsquo;\u00e9valuation de <code>mentor(_,L)<\/code>.<\/li>\n<\/ul>\n<p><strong>L&rsquo;\u00e9valuation d&rsquo;une n\u00e9gation ne peut pas instancier de variable.<\/strong> Son r\u00e9sultat est juste une valeur de v\u00e9rit\u00e9, <code>true<\/code> ou <code>false<\/code>. En d&rsquo;autres termes, les variables situ\u00e9es dans un <code>not<\/code> ne peuvent \u00eatre utilis\u00e9es comme sorties. Si elle ne sont pas instanci\u00e9es (n&rsquo;ont pas de valeur) au moment de l&rsquo;\u00e9valuation du <code>not<\/code>, elle sont consid\u00e9r\u00e9es comme des variables anonymes.<\/p>\n<p>Par exemple, le but&#8230;<\/p>\n<pre><code>not(leader(L,charlie)).\n<\/code><\/pre>\n<p>&#8230;a pour r\u00e9sultat <code>false<\/code>. Ce but ne permet <strong>pas<\/strong> de r\u00e9cup\u00e9rer tous les joueurs qui ne sont pas leader de Charlie, comme on aurait pu l&rsquo;esp\u00e9rer. C&rsquo;est une limitation de la n\u00e9gation en Prolog.<\/p>\n<p>Si on veut d\u00e9terminer les joueurs qui ne sont pas leader de Charlie, on peut utiliser le but suivant :<\/p>\n<pre><code>jc(J,_), not(leader(J,charlie)).\n<\/code><\/pre>\n<p>On obtient la r\u00e9ponse :<\/p>\n<pre><code>J = bart\nJ = charlie\nJ = dave\nJ = edouard\n<\/code><\/pre>\n<p>Le premier sous-but permet d&rsquo;instancier <code>J<\/code>, utilis\u00e9e en sortie, successivement avec tous les joueurs. Pour chaque valeur de <code>J<\/code> remont\u00e9e, le deuxi\u00e8me sous-but r\u00e9ussi si et seulement si la valeur de <code>J<\/code>, qui est utilis\u00e9e en entr\u00e9e, n&rsquo;est <strong>pas<\/strong> leader de Charlie.<\/p>\n<h5>Exercice de d\u00e9couverte B.x2<\/h5>\n<p>Donnez le but permettant de rechercher les joueurs qui ont au moins un sup\u00e9rieur hi\u00e9rarchique et ne sont sup\u00e9rieur hi\u00e9rarchique de personne. (Le r\u00e9sultat devrait \u00eatre <code>edouard<\/code> et <code>bart<\/code>.)<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code>sup(_,J), not(sup(J,_)).\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On veut afficher les joueurs qui ne sont pas paladin. Le but suivant ne permet pas de r\u00e9aliser cette requ\u00eate car son ex\u00e9cution retourne <code>false<\/code>.<\/p>\n<pre><code>not(jc(J,paladin)).\n<\/code><\/pre>\n<p>Proposez un moyen de produire le r\u00e9sultat attendu.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code>jc(J,_), not(jc(J,paladin)).\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>B.dec3 : Arithm\u00e9tique<\/h3>\n<p>Les entiers naturels peuvent \u00eatre repr\u00e9sent\u00e9s par des termes fonctionnels, comme les autres donn\u00e9es pouvant \u00eatre trait\u00e9es par Prolog, mais cette approche, bien que tr\u00e8s puissante (elle permet \u00e0 Prolog de  de r\u00e9soudre des \u00e9quations), est inefficace pour beaucoup d&rsquo;applications pratiques, lorsque les valeurs manipul\u00e9es d\u00e9passent quelques centaines d&rsquo;unit\u00e9s.<\/p>\n<p>Cette limitation peut \u00eatre contourn\u00e9e avec des extensions de Prolog permettant de sp\u00e9cifier et r\u00e9soudre des contraintes arithm\u00e9tiques sur des entiers ou des r\u00e9els. On entre alors dans le domaine, tr\u00e8s vaste, de la programmation logique avec contraintes.<\/p>\n<p>Mais en Prolog de base, l&rsquo;instruction <code>is<\/code> est le seul moyen d&rsquo;\u00e9valuer le r\u00e9sultat d&rsquo;un calcul arithm\u00e9tique. Par exemple, le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">X is (10-4) * 3.\n<\/code><\/pre>\n<p>&#8230;a pour r\u00e9sultat :<\/p>\n<pre><code>X = 18\n<\/code><\/pre>\n<p>Si on remplace <code>is<\/code> par le symbole <code>=<\/code>, appel\u00e9 symbole d&rsquo;unification, comme ceci&#8230;<\/p>\n<pre><code class=\"language-Prolog\">X = (10-4) * 3.\n<\/code><\/pre>\n<p>&#8230;on obtient :<\/p>\n<pre><code>X = (10-4)*3\n<\/code><\/pre>\n<p>Il n&rsquo;y a pas d&rsquo;erreur de syntaxe, mais l&rsquo;expression arithm\u00e9tique n&rsquo;est pas \u00e9valu\u00e9e. La variable <code>X<\/code> est instanci\u00e9e avec l&rsquo;expression elle-m\u00eame, qui a le statut de terme fonctionnel, et non avec le r\u00e9sultat. L&rsquo;\u00e9valuation peut d&rsquo;ailleurs \u00eatre diff\u00e9r\u00e9e. Le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">X = (10-4) * 3, Y is X.\n<\/code><\/pre>\n<p>&#8230;produit le r\u00e9sultat :<\/p>\n<pre><code>X = (10-4)*3, Y = 18\n<\/code><\/pre>\n<p>L&rsquo;instruction <code>is<\/code> ne fonctionne que si toutes les valeurs de l&rsquo;expression \u00e0 \u00e9valuer sont connues au moment de l&rsquo;\u00e9valuation. Elle n&rsquo;est pas r\u00e9versible. Par exemple, le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">12 = 7 + X.\n<\/code><\/pre>\n<p>&#8230;\u00e9choue. Il ne permet <strong>pas<\/strong> de trouver la valeur <code>X<\/code> telle que <code>7 + X<\/code> vaut 12.<\/p>\n<p>Voici un pr\u00e9dicat permettant de calculer une factorielle. C&rsquo;est un exemple compl\u00e8tement bateau, mais qui permet de comprendre certains points importants.<\/p>\n<pre><code class=\"language-Prolog\">fact(0,1).\nfact(N,F) :- N&gt;0, N1 is N-1, fact(N1,F1), F is N*F1.\n<\/code><\/pre>\n<p>Voici un exemple d&rsquo;utilisation de ce pr\u00e9dicat pour calculer la factorielle de 5.<\/p>\n<pre><code>fact(5,R).\n<\/code><\/pre>\n<p>Le r\u00e9sultat est :<\/p>\n<pre><code>R = 120\n<\/code><\/pre>\n<p>Le pr\u00e9dicat <code>fact<\/code> est d\u00e9fini de mani\u00e8re <strong>r\u00e9cursive<\/strong>. Il s&rsquo;appuie sur la d\u00e9finition par r\u00e9currence de la fonction factorielle :<\/p>\n<ul>\n<li>$0! = 1$<\/li>\n<li>Pour tout $N &gt; 0$, $N! = N \\cdot (N-1)!$<\/li>\n<\/ul>\n<p>Si vous \u00eates habitu\u00e9 \u00e0 un langage de programmation proc\u00e9dural, objet ou m\u00eame fonctionnel, la d\u00e9finition du pr\u00e9dicat <code>fact<\/code> peut vous para\u00eetre d\u00e9routante, mais elle est en fait facile \u00e0 comprendre si on tient compte de deux faits :<\/p>\n<ol>\n<li>Un pr\u00e9dicat Prolog ne retourne pas de valeur. Il peut juste r\u00e9ussir ou \u00e9chouer. Mais il peut permettre de produire une ou plusieurs valeurs en les faisant remonter dans une variable non instanci\u00e9e situ\u00e9e dans un slot utilis\u00e9 en sortie.<\/li>\n<li>Tout calcul arithm\u00e9tique doit \u00eatre r\u00e9alis\u00e9 en utilisant l&rsquo;instruction <code>is<\/code>.<\/li>\n<\/ol>\n<p>Le premier slot de <code>fact<\/code> ne peut \u00eatre utilis\u00e9 qu&rsquo;en entr\u00e9e en raison des limitations de l&rsquo;instruction <code>is<\/code>. Le deuxi\u00e8me slot peut \u00eatre utilis\u00e9 en entr\u00e9e, mais nous allons raisonner uniquement sur la cas o\u00f9 il est utilis\u00e9 en sortie, pour r\u00e9cup\u00e9rer le r\u00e9sultat du calcul d&rsquo;une factorielle, ce qui est la vocation premi\u00e8re du pr\u00e9dicat.<\/p>\n<p>Cette figure illustre les diff\u00e9rentes \u00e9tapes de calcul dans le cas o\u00f9 <code>N<\/code> a une valeur sup\u00e9rieure \u00e0 0 et montre le cheminement des r\u00e9sultats interm\u00e9diaires successifs.<\/p>\n<p>Nous sommes assez loin de l&rsquo;id\u00e9al d\u00e9claratif de Prolog, mais pour utiliser ce langage en pratique, il ne faut pas s&rsquo;enfermer dans un dogmatisme rigide.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pB2.png\" alt=\"pB2\"><\/p>\n<p>Supposons donc qu&rsquo;une valeur d&rsquo;entr\u00e9e <code>N<\/code> sup\u00e9rieure \u00e0 0 soit plac\u00e9e dans le premier slot. Voici les diff\u00e9rentes \u00e9tapes d&rsquo;\u00e9valuation de cette clause, qui correspondent au buts num\u00e9rot\u00e9s de 1 \u00e0 4.<\/p>\n<ol>\n<li>Le but <code>N&gt;0<\/code> r\u00e9ussit seulement si <code>N<\/code> est strictement positif. Dans le cas contraire, c&rsquo;est la premi\u00e8re clause qui aura fournit le r\u00e9sultat.<\/li>\n<li>Le but <code>N1 is N-1<\/code> calcule la valeur $N-1$ et place le r\u00e9sultat dans la variable <code>N1<\/code>.<\/li>\n<li>Le but <code>fact(N1,F1)<\/code> invoque r\u00e9cursivement le pr\u00e9dicat <code>fact<\/code> pour calculer la factorielle de $N-1$ et faire remonter le r\u00e9sultat dans la variable <code>F1<\/code>.<\/li>\n<li>Le but <code>F is N*F1<\/code> calcule le r\u00e9sultat en multipliant factorielle de $N-1$ par $N$ et le place dans la variable de sortie <code>F<\/code>.<\/li>\n<\/ol>\n<p>On peut aussi d\u00e9crire cette clause de mani\u00e8re d\u00e9clarative :<\/p>\n<blockquote>\n<p><strong>Si<\/strong> <code>N<\/code> est strictement positif <strong>et<\/strong> <code>N1<\/code> vaut <code>N-1<\/code> <strong>et<\/strong> <code>F1<\/code> est la factorielle de <code>N1<\/code> <strong>et<\/strong> <code>F<\/code> vaut <code>N<\/code> fois <code>N1<\/code> <strong>alors<\/strong> <code>F<\/code> est la factorielle de <code>N<\/code>.<\/p>\n<\/blockquote>\n<p>Cette description est toutefois un peu trompeuse dans le cas de ce pr\u00e9dicat pour lequel l&rsquo;ordre des buts est critique (alors qu&rsquo;en logique, le connecteur <strong>et<\/strong> est commutatif) et qui utilise l&rsquo;instruction <code>is<\/code> qui n&rsquo;est pas d\u00e9clarative, mais imp\u00e9rative : elle d\u00e9crit un calcul et non une relation.<\/p>\n<h5>Exercice de d\u00e9couverte B.x3<\/h5>\n<p>D\u00e9finissez le pr\u00e9dicat <code>fibo<\/code> tel que le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">fibo(N_in,R_out).\n<\/code><\/pre>\n<p>&#8230;, o\u00f9 <code>N_in<\/code> est une valeur d&rsquo;entr\u00e9e et <code>R_out<\/code> une variable de sortie, produise dans la variable <code>R_out<\/code> le terme de rang <code>N_in<\/code> de la suite de Fibonacci.<\/p>\n<p>La suite de Fibonacci est d\u00e9finie de la mani\u00e8re suivante :<\/p>\n<ul>\n<li>Les termes de rang 0 et 1 ont la valeur 1.<\/li>\n<li>Chacun des autres termes a pour valeur la somme des deux termes pr\u00e9c\u00e9dents.<\/li>\n<\/ul>\n<p>Voici le d\u00e9but de cette suite.<\/p>\n<table>\n<thead>\n<tr>\n<th>rang<\/th>\n<th>0<\/th>\n<th>1<\/th>\n<th>2<\/th>\n<th>3<\/th>\n<th>4<\/th>\n<th>5<\/th>\n<th>6<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>valeur<\/td>\n<td>1<\/td>\n<td>1<\/td>\n<td>2<\/td>\n<td>3<\/td>\n<td>5<\/td>\n<td>8<\/td>\n<td>13<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Par exemple, le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">fibo(4,R).\n<\/code><\/pre>\n<p>&#8230;produit le r\u00e9sultat <code>R=5<\/code>.<\/p>\n<p>Dans cet exercice, vous ne devez pas vous soucier de l&rsquo;efficacit\u00e9 de l&rsquo;impl\u00e9mentation, mais opter pour la solution la plus simple.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;Indice1&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Trois clauses sont n\u00e9cessaires. Les deux premi\u00e8res d\u00e9terminent les valeurs des termes de rang 0 et 1. La troisi\u00e8me dit que pour $N$ plus grand que 1, le terme de rang $N$ est la somme des termes de rangs $N-1$ et $N-2$.<\/p>\n<p>Rappelez-vous que tout calcul doit \u00eatre r\u00e9alis\u00e9 avec l&rsquo;instruction <code>is<\/code>. Dans votre solution, il y a trois calculs :<\/p>\n<ul>\n<li>le calcul de $N-1$,<\/li>\n<li>le calcul de $N-2$,<\/li>\n<li>le calcul de la somme des termes de rangs $N-1$ et $N-2$ (apr\u00e8s leur production par invocation r\u00e9cursive du pr\u00e9dicat <code>fibo<\/code>).<\/li>\n<\/ul>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;Indice2&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-Prolog\">fibo(0,1).\nfibo(1,1).\nfibo(N,F) :- N&gt;1, N1 is N-1, N2 is N-2, \n    fibo(..... , .....), fibo(..... , .....), F is .......... .\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<pre><code class=\"language-Prolog\">fibo(0,1).\nfibo(1,1).\nfibo(N,F) :- N&gt;1, N1 is N-1, N2 is N-2, \n    fibo(N1,F1), fibo(N2,F2), F is F1+F2.\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h2>Pr\u00eat pour la suite ?<\/h2>\n<p>Si vous n&rsquo;avez pas bien compris certaines explications, ou des exemples, ou des solutions propos\u00e9es pour les exercices de d\u00e9couverte, vous devez poser \u00e0 une personne ma\u00eetrisant bien Prolog des questions pr\u00e9cises qui ciblent vos difficult\u00e9s.<\/p>\n<p>Vous avez compris les notions et principes qui viennent d&rsquo;\u00eatre introduits ? Vous devez maintenant continuer votre apprentissage en r\u00e9alisant les activit\u00e9s d&rsquo;entrainement <strong>B.ent<\/strong>.<\/p>\n<hr>\n<\/div>\n","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[6],"tags":[],"class_list":["post-458","post","type-post","status-publish","format-standard","hentry","category-prolog","entry"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/458","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/comments?post=458"}],"version-history":[{"count":1,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/458\/revisions"}],"predecessor-version":[{"id":459,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/458\/revisions\/459"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=458"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=458"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=458"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}