{"id":472,"date":"2022-06-22T15:38:16","date_gmt":"2022-06-22T15:38:16","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=472"},"modified":"2022-06-22T15:38:16","modified_gmt":"2022-06-22T15:38:16","slug":"prolog-etape-c","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/prolog-etape-c\/","title":{"rendered":"PROLOG : \u00e9tape C"},"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>Listes et coupe choix &#8211; d\u00e9couverte<\/h1>\n<p>Les <strong>activit\u00e9s de d\u00e9couverte<\/strong> consistent \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 C.dec<\/h2>\n<h3>Introduction<\/h3>\n<p>Nous allons d\u00e9couvrir comment repr\u00e9senter des listes, ce qui ouvre la voie \u00e0 la mod\u00e9lisation et \u00e0 la r\u00e9solution de nombreux probl\u00e8mes, et comment limiter le nombre de possibilit\u00e9s explor\u00e9es par Prolog lors de l&rsquo;\u00e9valuation d&rsquo;un but.<\/p>\n<h3>C.dec1 : Repr\u00e9sentation des listes<\/h3>\n<p>Prolog permet de construire et exploiter des listes repr\u00e9sent\u00e9e de la mani\u00e8re suivante. Une liste est :<\/p>\n<ul>\n<li>soit vide (on note <code>[]<\/code>),<\/li>\n<li>soit compos\u00e9e d&rsquo;un \u00e9l\u00e9ment de t\u00eate <code>T<\/code> et d&rsquo;un reste <code>R<\/code>, qui est une liste pouvant \u00eatre vide (on note <code>[T|R]<\/code>).<\/li>\n<\/ul>\n<p>Par exemple, le but&#8230;<\/p>\n<pre><code>[7,5,3] = [T|R].\n<\/code><\/pre>\n<p>&#8230;donne comme r\u00e9sultat :<\/p>\n<pre><code>R = [5, 3], T = 7\n<\/code><\/pre>\n<p>Ou encore, par exemple&#8230;<\/p>\n<pre><code>[a|[]] = L.\n<\/code><\/pre>\n<p>&#8230; produit le r\u00e9sultat :<\/p>\n<pre><code>L = [a]\n<\/code><\/pre>\n<p>Cette repr\u00e9sentation permet d\u00e9finir des pr\u00e9dicats exploitant des listes, tels que par exemple le pr\u00e9dicat <code>dernier<\/code> qui permet de r\u00e9cup\u00e9rer le dernier \u00e9l\u00e9ment d&rsquo;une liste :<\/p>\n<pre><code>dernier([D],D).\ndernier([_|R],D) :- dernier(R,D).\n<\/code><\/pre>\n<p>La premi\u00e8re clause repr\u00e9sente le cas trivial (ne n\u00e9cessitant pas d&rsquo;appel r\u00e9cursif) dans lequel la liste comporte un unique \u00e9l\u00e9ment.<\/p>\n<blockquote>\n<p>Le dernier \u00e9l\u00e9ment d&rsquo;une liste qui contient un seul \u00e9l\u00e9ment est cet \u00e9l\u00e9ment.<\/p>\n<\/blockquote>\n<p>La deuxi\u00e8me clause repr\u00e9sente le cas d&rsquo;une liste de plusieurs \u00e9l\u00e9ments.<\/p>\n<blockquote>\n<p><strong>Si<\/strong> D est le dernier \u00e9l\u00e9ment de la liste <code>R<\/code>, <strong>alors<\/strong> <code>D<\/code> est le dernier \u00e9l\u00e9ment de toute liste ayant pour reste <code>R<\/code>.<\/p>\n<\/blockquote>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC1.png\" alt=\"pC1\"><\/p>\n<p>Une chose int\u00e9ressante avec ce pr\u00e9dicat est que son deuxi\u00e8me slot peut \u00eatre utilis\u00e9 <strong>en entr\u00e9e ou en sortie<\/strong>. Voici deux exemples de buts qui illustrent ces deux situations :<\/p>\n<pre><code>dernier([1,2,3],D). --&gt; D=3\ndernier([1,2,3],2). --&gt; false\n<\/code><\/pre>\n<p>Dans les deux buts, le premier slot est utilis\u00e9 en entr\u00e9e. Le deuxi\u00e8me slot est utilis\u00e9 en sortie dans le premier but et en entr\u00e9e dans le deuxi\u00e8me. Le pr\u00e9dicat peut donc permettre de tester si un \u00e9l\u00e9ment donn\u00e9 est le dernier \u00e9l\u00e9ment d&rsquo;une liste et de produire le dernier \u00e9l\u00e9ment d&rsquo;une liste.<\/p>\n<p>Dans le cas o\u00f9 la liste d&rsquo;entr\u00e9e est vide, le r\u00e9sultat est toujours <code>false<\/code> :<\/p>\n<pre><code>dernier([],D). --&gt; false\n<\/code><\/pre>\n<h5>Exercice de d\u00e9couverte C.x1<\/h5>\n<p>On veut d\u00e9finir un pr\u00e9dicat <code>addFin<\/code> tel que si <code>L<\/code> est une liste connue, <code>F<\/code> un \u00e9l\u00e9ment connu et <code>R<\/code> est une variable de sortie (non instanci\u00e9e), alors le but&#8230;<\/p>\n<pre><code>addFin(L,F,R)\n<\/code><\/pre>\n<p>&#8230;fait remonter dans <code>R<\/code> la liste obtenue en ajoutant <code>F<\/code> \u00e0 la fin de <code>L<\/code>.<\/p>\n<p>Par exemple,<\/p>\n<pre><code>addFin([1,2,3],4,L).\n<\/code><\/pre>\n<p>&#8230;a pour r\u00e9sultat :<\/p>\n<pre><code>L = [1, 2, 3, 4]\n<\/code><\/pre>\n<p>voici la d\u00e9finition du pr\u00e9dicat <code>addFin<\/code> \u00e0 compl\u00e9ter.<\/p>\n<pre><code>addFin([],F,[F]).\naddFin([T|Q],F,[T|R]) :- \u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026\u2026 .\n<\/code><\/pre>\n<p>La premi\u00e8re clause dit :<\/p>\n<blockquote>\n<p>La liste obtenue en ajoutant <code>F<\/code> \u00e0 la fin d&rsquo;une liste vide est <code>[F]<\/code>.<\/p>\n<\/blockquote>\n<p>La deuxi\u00e8me clause dit :<\/p>\n<blockquote>\n<p>La liste  obtenue (troisi\u00e8me slot) en ajoutant l&rsquo;\u00e9l\u00e9ment <code>F<\/code> \u00e0 la fin d&rsquo;une liste <code>[T|Q]<\/code> a<\/p>\n<ul>\n<li>pour t\u00eate <code>T<\/code><\/li>\n<li>et pour reste la liste <code>R<\/code> obtenue en&#8230; (Tentez de comp\u00e9ter cette phrase.)<\/li>\n<\/ul>\n<\/blockquote>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;Indice&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<blockquote>\n<p>La liste  obtenue (troisi\u00e8me slot) en ajoutant l&rsquo;\u00e9l\u00e9ment <code>F<\/code> \u00e0 la fin d&rsquo;une liste <code>[T|Q]<\/code> a<\/p>\n<ul>\n<li>pour t\u00eate <code>T<\/code><\/li>\n<li>et pour reste la liste <code>R<\/code> obtenue en <strong>ajoutant F \u00e0 la fin de Q<\/strong>.<\/li>\n<\/ul>\n<\/blockquote>\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>addFin([],F,[F]).\naddFin([T|Q],F,[T|R]) :- addFin(Q,F,R).\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Bien que, lors de la conception du pr\u00e9dicat, nous ayons raisonn\u00e9 en consid\u00e9rant que le premier et le deuxi\u00e8me slots \u00e9taient des entr\u00e9es et le troisi\u00e8me une sortie, il est parfaitement possible d&rsquo;utiliser le pr\u00e9dicat de mani\u00e8re diff\u00e9rente.<\/p>\n<p>Donnez le but permettant de r\u00e9cup\u00e9rer dans une variable <code>D<\/code> le dernier \u00e9l\u00e9ment de la liste <code>[1,2,3]<\/code> et dans une variable <code>L<\/code> tous les \u00e9l\u00e9ments de cette m\u00eame liste sauf le dernier.<\/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>addFin(L,D,[1,2,3]).\n<\/code><\/pre>\n<p>Le r\u00e9sultat obtenu est :<\/p>\n<pre><code>D = 3, L = [1, 2]\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<h3>C.dec2 : quelques mots sur l&rsquo;unification<\/h3>\n<p>Dans un esprit de simplification, on peut dire que l&rsquo;unification est un processus permettant de rendre deux termes identiques en rempla\u00e7ant toutes les occurrences d&rsquo;une ou plusieurs variables par des termes. Parce que la d\u00e9finition formelle du concept nous entra\u00eenerait au del\u00e0 des objectifs de cette initiation, nous limiterons \u00e0 des exemples.<\/p>\n<p>Deux termes sans variable ne s&rsquo;unifient que s&rsquo;ils sont identiques. Ceci s&rsquo;applique aux listes, qui sont des cas particuliers de termes. Par exemple :<\/p>\n<ul>\n<li><code>[]<\/code> ne s&rsquo;unifie qu&rsquo;avec <code>[]<\/code><\/li>\n<li><code>[1,2,3]<\/code> ne s&rsquo;unifie qu&rsquo;avec <code>[1,2,3]<\/code><\/li>\n<li><code>tarte<\/code> ne s&rsquo;unifie qu&rsquo;avec <code>tarte<\/code><\/li>\n<li><code>[tarte, cake]<\/code> ne s&rsquo;unifie qu&rsquo;avec <code>[tarte, cake]<\/code>.<\/li>\n<\/ul>\n<p>Une variable s&rsquo;unifie avec elle m\u00eame et avec n&rsquo;importe quel terme qui ne la contient pas. Par exemple :<\/p>\n<ul>\n<li><code>X<\/code> s&rsquo;unifie avec <code>[1,2]<\/code>. On note <code>X=[1,2]<\/code>.<\/li>\n<li><code>[]<\/code> (liste vide) s&rsquo;unifie avec <code>Z<\/code>. On note <code>Z=[]<\/code>.<\/li>\n<li><code>[X,5,Y]<\/code> s&rsquo;unifie avec <code>Z<\/code>. On note <code>Z=[X,5,Y]<\/code>.<\/li>\n<li><code>[X,5,Y]<\/code> ne s&rsquo;unifie <strong>pas<\/strong> avec <code>X<\/code>.<\/li>\n<\/ul>\n<p>Dans le cas de deux termes contenant des variables, on doit rechercher s&rsquo;il est possible de les rendre identiques en r\u00e9alisant des substitutions de variables par des termes. Voici quelques exemples :<\/p>\n<ul>\n<li><code>[1,X]<\/code> s&rsquo;unifie avec <code>[1,2]<\/code> par la substitution not\u00e9e <code>X=2<\/code>.<\/li>\n<li><code>[1,X]<\/code> ne s&rsquo;unifie <strong>pas<\/strong> avec <code>[1,2,3]<\/code> car les listes ne comportent pas le m\u00eame nombre d&rsquo;\u00e9l\u00e9ments.<\/li>\n<li><code>[1|X]<\/code> s&rsquo;unifie avec <code>[1,2,3]<\/code> par la substitution <code>X=[2,3]<\/code>.<\/li>\n<li><code>[1|X]<\/code> s&rsquo;unifie avec <code>[1,2]<\/code> par la substitution <code>X=[2]<\/code>. (Et pas avec <code>X=2<\/code>. ne confondez pas la virgule qui s\u00e9pare les \u00e9l\u00e9ments d&rsquo;une liste et le caract\u00e8re <code>|<\/code> qui la d\u00e9compose en un \u00e9l\u00e9ment de t\u00eate et une liste.<\/li>\n<li><code>[1,B|X]<\/code> s&rsquo;unifie avec <code>[1,2]<\/code> par la substitution <code>B=2<\/code> et <code>X=[]<\/code>.<\/li>\n<\/ul>\n<h5>Exercice de d\u00e9couverte C.x2<\/h5>\n<p>Les termes <code>[T|Q]<\/code> et <code>[1,2]<\/code> s&rsquo;unifient-ils ? Si oui, par quelle substitution ?<\/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<p>Oui, par <code>T=1<\/code> et <code>Q=[2]<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Les termes <code>[T|Q]<\/code> et <code>[7]<\/code> s&rsquo;unifient-ils ? Si oui, par quelle substitution ?<\/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<p>Oui, par <code>T=7<\/code> et <code>Q=[]<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Les termes <code>[T|Q]<\/code> et <code>[]<\/code> s&rsquo;unifient-ils ? Si oui, par quelle substitution ?<\/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<p>Non. La liste repr\u00e9sent\u00e9e par le premier terme comporte n\u00e9cessairement au moins un \u00e9l\u00e9ment.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>Les termes <code>[1,2|Q]<\/code> et <code>[1|R]<\/code> s&rsquo;unifient-ils ? Si oui, par quelle substitution ?<\/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<p>Oui, par <code>R=[2|Q]<\/code>.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3>C.dec3 : Coupe choix<\/h3>\n<p>Le coupe choix est une entorse au caract\u00e8re d\u00e9claratif de Prolog. Il permet de limiter l&rsquo;exploration des solutions lors de l&rsquo;\u00e9valuation d&rsquo;un pr\u00e9dicat. Pour comprendre son fonctionnement, examinons un exemple bas\u00e9 sur les deux pr\u00e9dicats suivants :<\/p>\n<pre><code class=\"language-Prolog\">val(1).\nval(2).\n\np([X,Y]) :- val(X), val(Y).\np([X])   :- val(X).\n<\/code><\/pre>\n<p>Pour \u00e9valuer le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">p(L).\n<\/code><\/pre>\n<p>&#8230;Prolog recherche tous les moyens de satisfaire <code>p(L)<\/code> avec chacune des deux clauses d\u00e9finissant le pr\u00e9dicat <code>p<\/code>. Examinons d&rsquo;abord les \u00e9tapes de cette recherche avec la premi\u00e8re clause, \u00e0 savoir :<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- val(X), val(Y).\n<\/code><\/pre>\n<p>Dans un premier temps, Prolog v\u00e9rifie si la t\u00eate de la clause, <code>p([X,Y])<\/code> peut s&rsquo;unifier avec le but <code>p(L)<\/code>. Cette unification r\u00e9ussi et a pour r\u00e9sultat <code>L=[X,Y]<\/code>.<\/p>\n<p>Ensuite, Il recherche toutes les valeurs de <code>X<\/code> permettant de satisfaire le premier sous-but <code>val(X)<\/code>, puis pour chacune d&rsquo;elles toutes les valeurs de <code>Y<\/code> permettant de satisfaire le deuxi\u00e8me sous-but <code>val(Y)<\/code>. Pour repr\u00e9senter de mani\u00e8re plus lisible les quatre cheminement conduisant aux quatre solutions, on peut repr\u00e9senter la clause sous la forme&#8230;<\/p>\n<p>$\\text{val}(X) \\wedge \\text{val}(Y) \\to \\text{p}([X,Y])$<\/p>\n<p>&#8230;dans laquelle le symbole $\\to$ repr\u00e9sente l&rsquo;<strong>implication<\/strong> logique et le symbole $\\wedge$ repr\u00e9sente le <strong>et<\/strong> logique.<\/p>\n<blockquote>\n<p><strong>Si<\/strong> $\\text{val}(X)$ est vrai <strong>et si<\/strong> $\\text{val}(Y)$ est vrai <strong>alors<\/strong> $\\text{p}([X,Y])$ est vrai.<\/p>\n<\/blockquote>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC2.png\" alt=\"pC2\"><\/p>\n<p>Les r\u00e9sultat du but <code>p(L)<\/code> issu de la premi\u00e8re clause sont :<\/p>\n<pre><code>L = [1, 1]\nL = [1, 2]\nL = [2, 1]\nL = [2, 2]\n<\/code><\/pre>\n<p>Ces r\u00e9sultats sont compl\u00e9t\u00e9s par ceux obtenus \u00e0 l&rsquo;aide de la deuxi\u00e8me clause, qui sont :<\/p>\n<pre><code class=\"language-Prolog\">L = [1]\nL = [2]\n<\/code><\/pre>\n<hr>\n<p>Le coupe choix, not\u00e9 <code>!<\/code>, permet d&rsquo;annuler les explorations qui n&rsquo;ont pas encore \u00e9t\u00e9 r\u00e9alis\u00e9es au moment o\u00f9 il est atteint. Si par exemple on le place \u00e0 la fin de la premi\u00e8re clause de <code>p<\/code>, comme ceci&#8230;<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- val(X), val(Y), !.\np([X]) :- val(X).\n<\/code><\/pre>\n<p>&#8230;alors le coupe choix est atteint au moment o\u00f9 la premi\u00e8re solution issue de la premi\u00e8re clause est produite. Toutes les explorations en attente sont annul\u00e9es :<\/p>\n<ul>\n<li>celles relatives aux autres mani\u00e8res de satisfaire les buts de la premi\u00e8re clause,<\/li>\n<li>et celles relatives \u00e0 la deuxi\u00e8me clause.<\/li>\n<\/ul>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC3.png\" alt=\"pC3\"><\/p>\n<p>Le r\u00e9sultat du but <code>p(L)<\/code> est :<\/p>\n<pre><code>L = [1, 1]\n<\/code><\/pre>\n<p>Si on place le coupe choix ici&#8230;<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- val(X), !, val(Y).\np([X]) :- val(X).\n<\/code><\/pre>\n<p>&#8230;alors il annule :<\/p>\n<ul>\n<li>les autres possibilit\u00e9s en attente de satisfaire le but <code>val(X)<\/code> situ\u00e9 avant le coupe choix,<\/li>\n<li>et les explorations exploitant la deuxi\u00e8me clause.<\/li>\n<\/ul>\n<p>Par contre, les deux mani\u00e8res de satisfaire le but <code>val(Y)<\/code>, situ\u00e9 apr\u00e8s le coupe choix dans la premi\u00e8re clause, sont explor\u00e9es.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC4.png\" alt=\"pC4\"><\/p>\n<p>Le r\u00e9sultat du but <code>p(L)<\/code> est :<\/p>\n<pre><code>L = [1, 1]\nL = [1, 2]\n<\/code><\/pre>\n<p>Si on place le coupe choix ici&#8230;<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- val(X), val(Y).\np([X]) :- val(X), !.\n<\/code><\/pre>\n<p>&#8230;alors il annule les choix en attente apr\u00e8s la production du premier r\u00e9sultat issu de la deuxi\u00e8me clause. Le but <code>p(L)<\/code> a donc pour r\u00e9sultat :<\/p>\n<pre><code>L = [1, 1]\nL = [1, 2]\nL = [2, 1]\nL = [2, 2]\nL = [1]\n<\/code><\/pre>\n<h5>Exercice de d\u00e9couverte C.x3<\/h5>\n<p>Cet exercice doit \u00eatre trait\u00e9 sans utiliser d&rsquo;interpr\u00e9teur Prolog.<\/p>\n<p>On place de coupe choix ici :<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- !, val(X), val(Y).\np([X]) :- val(X).\n<\/code><\/pre>\n<p>Quel sera le r\u00e9sultat du but <code>p(L)<\/code> ? Pourquoi ?<\/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<p>Le r\u00e9sultat est :<\/p>\n<pre><code>L = [1, 1]\nL = [1, 2]\nL = [2, 1]\nL = [2, 2]\n<\/code><\/pre>\n<p>Les possibilit\u00e9s offertes par la premi\u00e8re clause, qui correspondent \u00e0 des buts situ\u00e9s dans la clause apr\u00e8s le coupe choix, ne sont pas affect\u00e9es. Par contre, la deuxi\u00e8me clause de <code>p<\/code> sera neutralis\u00e9e.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On d\u00e9finit le pr\u00e9dicat <code>p<\/code> de la mani\u00e8re suivante :<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- val(X), val(Y), Y\\==X.\np([X]) :- val(X).\n<\/code><\/pre>\n<p>Donnez le r\u00e9sultat du but <code>p(L)<\/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>L = [1, 2]\nL = [2, 1]\nL = [1]\nL = [2]\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On ajoute un coupe choix ici :<\/p>\n<pre><code class=\"language-Prolog\">p([X,Y]) :- val(X), val(Y), !, Y\\==X.\np([X]) :- val(X).\n<\/code><\/pre>\n<p>Quelle est le r\u00e9sultat du but <code>p(L)<\/code> ?<\/p>\n<p>Rappelez vous bien que les possibilit\u00e9s non explor\u00e9es situ\u00e9es avant le coupe choix (ainsi que les clauses suivantes du pr\u00e9dicat) sont annul\u00e9es lorsque le coupe choix est atteint.<\/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<p>Le r\u00e9sultat du but est <strong>false<\/strong>. En effet, lorsque le coupe choix est atteint, <code>X<\/code> et <code>Y<\/code> ont toutes les deux la valeur 1 et la condition <code>X\\==Y<\/code> \u00e9choue. Comme toutes les autres possibilit\u00e9s \u00e0 explorer sont annul\u00e9es par le coupe choix, il n&rsquo;y a aucune solution.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<h3>Pens\u00e9e r\u00e9cursive<\/h3>\n<p>Avant d&rsquo;aller un peu plus loin avec les listes, je vous propose de faire le point sur l&rsquo;approche r\u00e9cursive de la r\u00e9solution de probl\u00e8mes.<\/p>\n<p>Nous appellerons probl\u00e8me tout ensemble d&rsquo;<strong>instances<\/strong> ayant chacune ayant une, plusieurs, ou aucune <strong>solution(s)<\/strong>.<\/p>\n<p>Quelques exemples :<\/p>\n<ul>\n<li>Le probl\u00e8me <code>concat_v1<\/code> :\n<ul>\n<li>Instances : couples de deux listes.<\/li>\n<li>Solution d&rsquo;une instance $(A,B)$ : la liste constitu\u00e9e des \u00e9l\u00e9ments de $A$ suivis des \u00e9l\u00e9ments de $B$, appel\u00e9e <strong>concat\u00e9nation<\/strong> de $A$ et $B$.<\/li>\n<\/ul>\n<\/li>\n<li>Le probl\u00e8me <code>concat_v2<\/code> :\n<ul>\n<li>Instances : triplets de trois listes.<\/li>\n<li>Solution d&rsquo;une instance $(A,B,C)$ : <code>oui<\/code> si $C$ est constitu\u00e9e des \u00e9l\u00e9ments de $A$ suivis de ceux de $B$, <code>non<\/code> dans le cas contraire.<\/li>\n<\/ul>\n<\/li>\n<li>Le probl\u00e8me <code>somme<\/code> :\n<ul>\n<li>Instances : couples $(L,v)$ o\u00f9 $L$ est une liste d&rsquo;entiers positifs et $v$ un entier naturel.<\/li>\n<li>Solution d&rsquo;un instance $(L,v)$ : toute liste d&rsquo;\u00e9l\u00e9ments de $L$ dont la somme est \u00e9gale \u00e0 $v$. Chaque \u00e9l\u00e9ment de $L$ peut \u00eatre utilis\u00e9 au plus une fois.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<p>Pour r\u00e9soudre r\u00e9cursivement un probl\u00e8me, il faut associer (de mani\u00e8re implicite ou explicite) \u00e0 chaque instance un nombre que nous appellerons <strong>difficult\u00e9<\/strong>. Par souci de simplification, nous allons consid\u00e9rer que la difficult\u00e9 d&rsquo;une instance est un entier naturel.<\/p>\n<p>Nous avons aussi besoin de deux ingr\u00e9dients :<\/p>\n<ol>\n<li>Un moyen de r\u00e9soudre imm\u00e9diatement toute instance de difficult\u00e9 inf\u00e9rieure ou \u00e9gale \u00e0 un certain entier $d_\\text{triv}$. De telles instances seront dites <strong>triviales<\/strong>.<\/li>\n<li>Un moyen de r\u00e9soudre toute instance de difficult\u00e9 $d&gt;d_\\text{triv}$ en utilisant des solutions d&rsquo;instances de difficult\u00e9s inf\u00e9rieures \u00e0 $d$.<\/li>\n<\/ol>\n<p>Par exemple, dans le cas du probl\u00e8me <code>concat_v1<\/code>, on peut d\u00e9finir la difficult\u00e9 d&rsquo;une instance $(A,B)$ comme \u00e9tant le nombre d&rsquo;\u00e9l\u00e9ment de la liste $A$ et fixer le seuil $d_\\text{triv}$ \u00e0 0. Ce choix peut paraitre arbitraire, mais il permet d&rsquo;obtenir facilement les deux ingr\u00e9dients n\u00e9cessaires \u00e0 une r\u00e9solution r\u00e9cursive du probl\u00e8me :<\/p>\n<ol>\n<li>La concat\u00e9nation de la liste vide <code>[]<\/code> avec une liste $B$ est la liste $B$.<\/li>\n<li>Soit une instance non triviale $([T|R],B)$. Si $Q$ est la solution de l&rsquo;instance $(R,B)$, alors la solution de l&rsquo;instance $(A,B)$ est $[T|Q]$.<\/li>\n<\/ol>\n<p>Le deuxi\u00e8me ingr\u00e9dient vous para\u00eet indigeste ? En voici une illustration.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC6.png\" alt=\"pC6\"><\/p>\n<p>En ajoutant l&rsquo;\u00e9l\u00e9ment $T$ en t\u00eate de la concat\u00e9nation de $R$ et $B$, on obtient la concat\u00e9nation de $A$ et $B$.<\/p>\n<p>Nous avons les ingr\u00e9dients pour d\u00e9finir un pr\u00e9dicat <code>concat<\/code> permettant de r\u00e9soudre notre probl\u00e8me.<\/p>\n<p>Une premi\u00e8re clause d\u00e9crit le cas trivial correspondant \u00e0 notre premier ingr\u00e9dient : la concat\u00e9nation d&rsquo;une liste vide et d&rsquo;une liste <code>B<\/code> est la liste <code>B<\/code>.<\/p>\n<pre><code class=\"language-Prolog\">concat([],B,B).\n<\/code><\/pre>\n<p>Le deuxi\u00e8me ingr\u00e9dient sera exploit\u00e9 par la clause r\u00e9cursive suivante :<\/p>\n<pre><code class=\"language-Prolog\">concat([T|R],B,[T|Q]) :- concat(R,B,Q).\n<\/code><\/pre>\n<p>Litt\u00e9ralement :<\/p>\n<blockquote>\n<p>Si <code>Q<\/code> est la concat\u00e9nation de <code>R<\/code> et <code>B<\/code> alors <code>[T|Q]<\/code> est la concat\u00e9nation de <code>[T|R]<\/code> et <code>B<\/code>.<\/p>\n<\/blockquote>\n<p>Ou encore, dans une interpr\u00e9tation plus constructive :<\/p>\n<blockquote>\n<p>Pour concat\u00e9ner <code>[T|R]<\/code> et <code>B<\/code>,  on ajoute <code>T<\/code> en t\u00eate de la concat\u00e9nation de <code>R<\/code> et <code>B<\/code>.<\/p>\n<\/blockquote>\n<p>Le bon fonctionnement du pr\u00e9dicat <code>concat<\/code> &#8211; et de tout pr\u00e9dicat d\u00e9fini r\u00e9cursivement &#8211; repose sur le <strong>principe de r\u00e9currence<\/strong>, tr\u00e8s utilis\u00e9 en math\u00e9matiques. Je ne le d\u00e9velopperai pas ici, mais vous pouvez vous documenter sur le sujet. Si vous faites confiance \u00e0 ce principe, alors vous pouvez concevoir des pr\u00e9dicats r\u00e9cursifs sans vous soucier de la mani\u00e8re dont Prolog \u00e9value les buts utilisant ces pr\u00e9dicats.<\/p>\n<p>Le pr\u00e9dicat <code>concat<\/code> permet <strong>aussi<\/strong> de r\u00e9soudre le probl\u00e8me <code>concat_v2<\/code>, c&rsquo;est \u00e0 dire de v\u00e9rifier si une liste connue est la concat\u00e9nation de deux listes connues. Il permet \u00e9galement de r\u00e9soudre d&rsquo;autres probl\u00e8mes, tels que :<\/p>\n<ul>\n<li>Soient deux listes $B$ et $C$. Trouver la liste $A$ telle que la concat\u00e9nation de $A$ et $B$ est $C$.<\/li>\n<li>Soient deux listes $A$ et $C$. Trouver la liste $B$ telle que la concat\u00e9nation de $A$ et $B$ est $C$.<\/li>\n<li>Soit une liste $C$. Trouver toutes les listes $A$ et $B$ telles que la concat\u00e9nation de $A$ et $B$ est $C$.<\/li>\n<\/ul>\n<h5>Exercice de d\u00e9couverte C.x4<\/h5>\n<p>Si une liste $L$ est la concat\u00e9nation d&rsquo;une liste $P$ avec une liste quelconque (possiblement vide), on dit que $P$ est un <strong>pr\u00e9fixe<\/strong> de $L$. Par exemple, les pr\u00e9fixes de <code>[1,2,3]<\/code> sont les listes <code>[]<\/code>, <code>[1]<\/code>, <code>[1,2]<\/code>, <code>[1,2,3]<\/code>.<\/p>\n<p>Donnez un but permettant de produire tous les pr\u00e9fixes de la liste <code>[1,2,3,4]<\/code> avec le pr\u00e9dicat <code>concat<\/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 class=\"language-Prolog\">concat(P,_,[1,2,3,4]).\n<\/code><\/pre>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>On veux maintenant d\u00e9finir un pr\u00e9dicat <code>pref<\/code> d\u00e9di\u00e9 \u00e0 la production des <strong>pr\u00e9fixes non vides<\/strong> d&rsquo;une liste.<\/p>\n<p>Par exemple, le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">pref(P,[1,2,3,4]).\n<\/code><\/pre>\n<p>&#8230;.doit produire le r\u00e9sultat :<\/p>\n<pre><code>P = [1]\nP = [1, 2]\nP = [1, 2, 3]\nP = [1, 2, 3, 4]\n<\/code><\/pre>\n<p>Les deux ingr\u00e9dients permettant de traiter ce probl\u00e8me r\u00e9cursivement sont les suivants :<\/p>\n<ol>\n<li>Une liste comportant un seul \u00e9l\u00e9ment a pour seul pr\u00e9fixe elle-m\u00eame.<\/li>\n<li>Soit une liste <code>[T|R]<\/code>. Les pr\u00e9fixes de cette liste sont :\n2.1 d&rsquo;une part <code>[T]<\/code> ,\n2.2 et d&rsquo;autre part, si applicable, toutes les listes obtenues en ajoutant <code>T<\/code> au d\u00e9but des pr\u00e9fixes non vides de <code>R<\/code>.<\/li>\n<\/ol>\n<p>Pour simplifier la d\u00e9finition du pr\u00e9dicat <code>pref<\/code>, on peut utiliser deux clauses, une non r\u00e9cursive et une r\u00e9cursive, ayant les r\u00f4les suivants :<\/p>\n<ul>\n<li>La  clause non r\u00e9cursive produit tous les pr\u00e9fixes de taille 1, quelle que soit la taille de la liste d&rsquo;entr\u00e9e. Cette clause exploite donc l&rsquo;ingr\u00e9dient 1 et l&rsquo;ingr\u00e9dient 2.1.<\/li>\n<li>La clause r\u00e9cursive produit tous les pr\u00e9fixes de tailles sup\u00e9rieures \u00e0 1 en utilisant l&rsquo;ingr\u00e9dient 2.2.<\/li>\n<\/ul>\n<p>Voici une illustration de ce que dit la clause non r\u00e9cursive.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC9.png\" alt=\"pC9\"><\/p>\n<p>Compl\u00e9tez cette d\u00e9finition du pr\u00e9dicat <code>pref<\/code> (la liste d&rsquo;entr\u00e9e occupe le deuxi\u00e8me slot, les pr\u00e9fixes produits remontent dans le premier slot) :<\/p>\n<pre><code class=\"language-Prolog\">pref([T],[T|_]).\npref(..... , [T|R]) :- pref(..... , .....).\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 class=\"language-Prolog\">pref([T],[T|_]).\npref([T|P],[T|R]) :- pref(P,R).\n<\/code><\/pre>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC10.png\" alt=\"pC10\"><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>La clause r\u00e9cursive peut se d\u00e9crire de mani\u00e8re d\u00e9clarative de la fa\u00e7on suivante :<\/p>\n<blockquote>\n<p>Quel que soit l&rsquo;\u00e9l\u00e9ment <code>T<\/code>, <strong>si<\/strong> <code>P<\/code> est un pr\u00e9fixe de <code>R<\/code>, <strong>alors<\/strong> <code>[T|P]<\/code> est un pr\u00e9fixe de <code>[T|R]<\/code>.<\/p>\n<\/blockquote>\n<p>Mais s&rsquo;il est <em>relativement<\/em> facile de r\u00e9diger une telle description <em>apr\u00e8s<\/em> avoir \u00e9crit la clause, il me semble plus difficile de r\u00e9diger une telle description comme \u00e9tape pr\u00e9alable \u00e0 l&rsquo;\u00e9criture de la clause. C&rsquo;est la raison pour laquelle je privil\u00e9gie l&rsquo;approche constructive lors de la conception de la d\u00e9finition d&rsquo;un pr\u00e9dicats.<\/p>\n<p>Toutefois, je ne saurais pr\u00e9tendre que cette approche est la meilleure pour tout le monde. C&rsquo;est \u00e0 vous de trouver votre propre voie.<\/p>\n<h3>C.dec4 : Un peu plus loin avec les listes<\/h3>\n<p>Je vous propose une \u00e9tude de cas : r\u00e9soudre le <strong>probl\u00e8me de la somme<\/strong>, c&rsquo;est \u00e0 dire rechercher s&rsquo;il est possible de produire un entier $s$ appel\u00e9 <strong>valeur cible<\/strong> en additionnant certains des \u00e9l\u00e9ments d&rsquo;une liste $L$.<\/p>\n<p>Par exemple, si $L$ est la liste $[3,5,11,13,17]$ et $s$ vaut 26, alors il n&rsquo;y a aucune solution. Avec la m\u00eame liste, si la valeur cible est 27 alors il y a une solution : 3+11+13= 27.<\/p>\n<p>Pour r\u00e9soudre ce probl\u00e8me, nous allons d\u00e9finir un pr\u00e9dicat <code>somme<\/code> tel que si <code>L_in<\/code> est une liste d&rsquo;entiers positifs , <code>X_in<\/code> un entier positif ou nul, et <code>S_out<\/code> une variable non instanci\u00e9e, alors le but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">somme(L_in, X_in, S_out).\n<\/code><\/pre>\n<p>&#8230;fait remonter dans <code>S_out<\/code> les listes d&rsquo;\u00e9l\u00e9ments de <code>L_in<\/code> dont la somme est <code>X_in<\/code>.<\/p>\n<p>Par exemple, l&rsquo;\u00e9valuation du but&#8230;<\/p>\n<pre><code class=\"language-Prolog\">somme([1,3,5,11,13,17],25,S).\n<\/code><\/pre>\n<p>&#8230;produira les solutions :<\/p>\n<pre><code>S = [1, 11, 13]\nS = [3, 5, 17]\n<\/code><\/pre>\n<hr>\n<p>Pour r\u00e9soudre le probl\u00e8me r\u00e9cursivement, nous allons consid\u00e9rer que la difficult\u00e9 d&rsquo;une instance est la taille de la liste d&rsquo;entr\u00e9e. Commen\u00e7ons par chercher nos deux ingr\u00e9dients. Pour m\u00e9moire, le premier ingr\u00e9dient doit permettre de construire ou de d\u00e9crire les solutions des instances dont la difficult\u00e9 est sous un certain seuil. Le deuxi\u00e8me argument doit nous permettre de construire ou de d\u00e9crire les solutions d&rsquo;une instance \u00e0 partir de celles d&rsquo;une ou plusieurs instances moins difficiles.<\/p>\n<p>Pour le probl\u00e8me de la somme, <strong>le premier ingr\u00e9dient<\/strong> est que si la liste d&rsquo;entr\u00e9e est vide (instances de difficult\u00e9 0, qu&rsquo;on appellera instances triviales), la seule valeur r\u00e9alisable avec une somme d&rsquo;\u00e9l\u00e9ments de la liste d&rsquo;entr\u00e9e est 0.  Il permet d&rsquo;\u00e9crire la clause non r\u00e9cursive suivante :<\/p>\n<pre><code class=\"language-Prolog\">somme([],0,[]). % Cas trivial\n<\/code><\/pre>\n<p>Notre <strong>deuxi\u00e8me ingr\u00e9dient<\/strong> doit nous permettre de produire (ou d\u00e9crire) les solutions d&rsquo;une instance non triviales en exploitant des solutions d&rsquo;instances bas\u00e9es sur les listes de valeurs plus petites. Je vous propose d&rsquo;y r\u00e9fl\u00e9chir en faisant l&rsquo;exp\u00e9rience de pens\u00e9e suivante :<\/p>\n<ul>\n<li>Vous voulez r\u00e9soudre une instance de difficult\u00e9 5.<\/li>\n<li>Vous disposez d&rsquo;un moyen de r\u00e9soudre des instances de difficult\u00e9 4.<\/li>\n<\/ul>\n<h5>Exercice de d\u00e9couverte C.x5<\/h5>\n<p>On consid\u00e8re l&rsquo;instance suivante du probl\u00e8me de la somme.<\/p>\n<ul>\n<li>La liste d&rsquo;entr\u00e9e est [2,3,4,10,11].<\/li>\n<li>La valeur cible est 25.<\/li>\n<\/ul>\n<p>On <strong>suppose<\/strong> qu&rsquo;on dispose d&rsquo;un pr\u00e9dicat <code>somme_<\/code> capable de r\u00e9soudre le probl\u00e8me de la somme, mais seulement avec des listes d&rsquo;entr\u00e9e d&rsquo;au plus 4 \u00e9l\u00e9ments.<\/p>\n<p>En utilisant le pr\u00e9dicat <code>somme_<\/code>, donnez <strong>deux buts<\/strong> permettant d&rsquo;obtenir des informations \u00e0 partir desquelles on peut imm\u00e9diatement d\u00e9terminer les solutions de l&rsquo;instance du probl\u00e8me de la somme d\u00e9crite plus haut. D\u00e9duisez-en les solutions.<\/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<p>On peut \u00e9valuer les deux buts suivants dans lesquels la liste d&rsquo;entr\u00e9e comporte tous les \u00e9l\u00e9ments de la liste initiale sauf le premier :<\/p>\n<pre><code class=\"language-Prolog\">somme_([3,4,10,11],23,S).\nsomme_([3,4,10,11],25,S).\n<\/code><\/pre>\n<p>Le premier but tente d&rsquo;obtenir 25 en utilisant la premi\u00e8re valeur de la liste initiale, ce qui n\u00e9cessite donc de r\u00e9aliser 25-2, soit 23, avec la liste <code>[3,4,10,11]<\/code>.<\/p>\n<p>Le deuxi\u00e8me but tente d&rsquo;obtenir 25 sans utiliser la premi\u00e8re valeur de la liste initiale, ce qui n\u00e9cessite de r\u00e9aliser 25 avec la liste <code>[3,4,10,11]<\/code>.<\/p>\n<p>Le premier but \u00e9choue, donc il n&rsquo;existe pas de solution utilisant la valeur 2.<\/p>\n<p>Le deuxi\u00e8me but produit une seule solution : <code>[4,10,11]<\/code>, qui est de fait l&rsquo;unique solution de l&rsquo;instance \u00e0 r\u00e9soudre.<\/p>\n<p><\/div>\n\t\t\t<\/div>\n<hr>\n<p>En g\u00e9n\u00e9ralisant le principe utilis\u00e9 dans l&rsquo;exercice pr\u00e9c\u00e9dent, nous obtenons notre deuxi\u00e8me ingr\u00e9dient, qui peut \u00eatre exploit\u00e9 par les deux clauses r\u00e9cursives suivantes :<\/p>\n<pre><code class=\"language-Prolog\">somme([T|R],S,[T|Q]) :- T=&lt;S, S1 is S-T, somme(R,S1,Q).\nsomme([_|R],S,Q) :- somme(R,S,Q).\n<\/code><\/pre>\n<ul>\n<li>La premi\u00e8re clause r\u00e9cursive permet de rechercher les solutions utilisant le premier \u00e9l\u00e9ment de la liste d&rsquo;entr\u00e9e, \u00e0 condition que sa valeur ne soit pas plus grande que la valeur cible.<\/li>\n<li>La deuxi\u00e8me clause r\u00e9cursive permet de rechercher les solutions n&rsquo;utilisant pas le premier \u00e9l\u00e9ment de la liste d&rsquo;entr\u00e9e.<\/li>\n<\/ul>\n<p>La d\u00e9finition compl\u00e8te du pr\u00e9dicat <code>somme<\/code> est la suivante :<\/p>\n<pre><code class=\"language-Prolog\">somme([],0,[]).\nsomme([T|R],S,[T|Q]) :- T=&lt;S, S1 is S-T, somme(R,S1,Q).\nsomme([_|R],S,Q) :- somme(R,S,Q).\n<\/code><\/pre>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/06\/pC5.png\" alt=\"pC5\"><\/p>\n<p>Faisons un petit essai pour le fun. Comment obtenir 301 avec 14, 25, 32, 47, 59, 61, 78, 83, 96 ?<\/p>\n<pre><code class=\"language-Prolog\">somme([14,25,32,47,59,61,78,83,96],301,S).\n<\/code><\/pre>\n<p>Solutions :<\/p>\n<pre><code>S = [14, 47, 61, 83, 96]\nS = [32, 47, 61, 78, 83]\n<\/code><\/pre>\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-472","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\/472","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=472"}],"version-history":[{"count":1,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/472\/revisions"}],"predecessor-version":[{"id":473,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/472\/revisions\/473"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=472"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=472"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=472"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}