QAVAID  SOFTWARE  -- Prolog II"LEARN  14 juin 1988"to-begin ->   set-window("console",1,4,44,508,338)   set-line-width(70)   page   outml("LEARN")   line   outml("juin 88")   line   effacer(jour)   date-string(d)   line   outml(d)   assert(jour(d),nil)   purge   new-subworld("Suite",20000)   insert("LEARN.SUITE")   close-input   monde("Connaissance")   line   mise-�-jour-menu   /;ed1 ->   monde("Normal")   edit;ed2 ->   monde("Suite")   edit;"AUTOMATE"tracer-derni�res ->   une-phrase-lue   demander-mode(m-ode)   segment-mode   line   outml("Mise � jour de la grammaire:")   line   derni�re(phrase-lue,n)   �num�rer(i,1,n)   phrase-lue(i,s)   afficher(format,num�ro,i,s)   tracer(s,"S",nil)   line   impasse;tracer-derni�res ->   effacer(sp�cif)   une-phrase-lue   effacer(phrase-lue)   segmenter-au-cas-o�;tracer-derni�res ->;segment-mode ->   effacer(segmentation-compl�te)   non(segment�)   /;segment-mode ->   outml("Segmentation compl�te ? O/N ")   in-char'(c)   interpr�ter(c,r)   segment-mode(r);segment-mode(oui) -> ajouter(segmentation-compl�te) /;segment-mode(r) ->;tracer(nil,X-in,X-fin) -> /;tracer(s,X-in,X-fin) ->   d�rive-de(s,X-in,X-fin,l)   outml("Rien � modifier.")   effacer(phrase-lue(i,s))   /;tracer(s,X-in,X-fin) ->   mode(m-ode)   effacer(nouveau)   effacer(noeuds)   effacer(pas-toujours-vrai)   effacer(d�j�-copi�)   effacer(d�j�-coup�)   effacer(g�n�-possible(ind,g))   chercher-pr�fixes(s,X-in,X-fin)   pr�fixe(avant,i,p-lus-grand-pr�fixe)   pr�fixe(arri�re,j,p-lus-grand-suffixe)   sp�cifique(m-ode,s,l-ongueur-mini)   sup-ou-�gal(l-ongueur-mini,l-ongueur)   outm("? chemin longueur ")   outl(l-ongueur)   reconna�tre-pr�fixe(avant,X-in,X-fin,p-lus-grand-pr�fixe,s,i-nutile   ,X1,T1,q-ueue1,s1)   reste-possible(s1,l-ongueur,r-este)   renverser(s1,s1')   dif(X1,X2)   reconna�tre-pr�fixe(arri�re,X-fin,X-in,p-lus-grand-suffixe,s1',   r-este,X2,T2,q-ueue2,s2)   renverser(s2,s2')   coupure-ter(s,s3,s1)   coupure-ter(s1,s2',s4)   sp�cifique-oui(s3,s2',s4)   renverser(q-ueue2,q-ueue2')   effacer(pr�fixe)   compl�ter-free(X1,T1,q-ueue1,X2,T2,q-ueue2',s2')   line   /   effacer(nouveau-nom);sp�cifique-oui(a,b,c) -> sp�cif(non,b) / impasse;sp�cifique-oui(a,b,c) ->   outm("Chemin sp�cif: ")   afficher(a)   outm("/")   afficher(b)   outm("/")   afficher(c)   line   segmentation-compl�te   /;sp�cifique-oui(a,b,c) -> sp�cif(oui,b) /;sp�cifique-oui(a,b,c) -> mot-connu(b) /;sp�cifique-oui(a,b,c) ->   beep   outm("Accepter ? O/N ")   in-char'(c')   interpr�ter(c',r)   ajouter(sp�cif(r,b))   eq(r,oui);reste-possible(s,l-ongueur,r-este) ->   arg(0,s,l)   val(inf(l,l-ongueur),0)   val(sub(l,l-ongueur),r-este)   mode(m-ode)   reste-assez(m-ode,r-este);reste-assez(m-ode,0) -> /;reste-assez(chop,n) ->;reste-assez(chunk,n) ->   val(inf(1,n),1);chercher-pr�fixes(s,X-in,X-fin) ->   effacer(pr�fixe)   plus-grand-pr�fixe(avant,s,X-in,X-fin)   renverser(s,s')   plus-grand-pr�fixe(arri�re,s',X-fin,X-in)   /;plus-grand-pr�fixe(s-ens,s,X-in,X-fin) ->   mode(m-ode)   assert(pr�fixe(s-ens,0,nil),nil)   pr�fixe-connu(s-ens,m-ode,s,X-in,X-fin,nil,p,0,l-ongueur)   noter-si-max(s-ens,l-ongueur,p)   impasse;plus-grand-pr�fixe(s-ens,s,X-in,X-fin) ->;pr�fixe-connu(s-ens,m-ode,s,X,X-fin,p,p',l,l') ->   liaison(s-ens,X,T,X')   dif(X',X-fin)   fre(w,2,T,y,nil)   bon-sens(s-ens,y,s1)   coupure(s,s1,s2)   assez-long(m-ode,s2)   peut-franchir(s-ens,X')   arg(0,s1,n)   val(add(l,n),l1)   pr�fixe-connu(s-ens,m-ode,s2,X',X-fin,(T.X'.nil).p,p',l1,l');pr�fixe-connu(s-ens,m-ode,s,X,X-fin,p,p',l,l') ->   non(segmentation-compl�te)   liaison(s-ens,X,T,X')   fre(w,2,T,y,nil)   bon-sens(s-ens,y,y')   coupure-bis(y',y1,y2)   assez-long(m-ode,y1)   assez-long(m-ode,y2)   coupure(s,y1,s2)   assez-long(m-ode,s2)   non(noeud-�-�viter(s-ens,X'))   arg(0,y1,n)   val(add(l,n),l')   renverser((T.X'.y1).p,p');pr�fixe-connu(s-ens,m-ode,s,X,X-fin,p,p',l,l) ->   assez-long(m-ode,s)   renverser(p,p');bon-sens(avant,s,s) ->;bon-sens(arri�re,s,s') -> renverser(s,s');noter-si-max(s-ens,n,p) ->   pr�fixe(s-ens,i,p')   val(inf(i,n),1)   rule(pr�fixe(s-ens,i,p'),nil)   suppress(1)   assert(pr�fixe(s-ens,n,p),nil)   /;noter-si-max(s-ens,n,p) ->;reconna�tre-pr�fixe(s-ens,X,X-fin,(T.X'.nil).l,s,r-este,X1,T1,q1,s')    ->   bound(T)   dif(r-este,0)   liaison(s-ens,X,T,X')   fre(w,2,T,y,nil)   bon-sens(s-ens,y,s1)   coupure(s,s1,s2)   arg(0,s1,n)   nouveau-reste(r-este,n,r-este')   reconna�tre-pr�fixe(s-ens,X',X-fin,l,s2,r-este',X1,T1,q1,s');reconna�tre-pr�fixe(s-ens,X,X-fin,(T.X'.s1).nil,s,r-este,X,T,s1,s') ->   non(segmentation-compl�te)   dif(r-este,0)   liaison(s-ens,X,T,X')   fre(w,2,T,y,nil)   bon-sens(s-ens,y,y')   bonne-coupure(s-ens,y',r-este,X',s1,s,s');reconna�tre-pr�fixe(s-ens,X,X-fin,(T.X'.m).l,s,r-este,X1,T1,q1,s') ->   bound(T)   dif(r-este,0)   reconna�tre-pr�fixe(s-ens,X,X-fin,(a.b.c).nil,s,r-este,X1,T1,q1,s')   ;reconna�tre-pr�fixe(s-ens,X,X-fin,(a.b.c).nil,s,r-este,X1,T1,q1,s') ->   dif(r-este,0)   free(a)   mode(m-ode)   dif(X',X-fin)   liaison(s-ens,X,T,X')   fre(w,2,T,y,nil)   bon-sens(s-ens,y,s1)   coupure(s,s1,s2)   peut-franchir(s-ens,X')   assez-long(m-ode,s2)   arg(0,s1,n)   nouveau-reste(r-este,n,r-este')   reconna�tre-pr�fixe(s-ens,X',X-fin,(a'.b'.c').nil,s2,r-este',X1,T1,   q1,s');reconna�tre-pr�fixe(s-ens,X,X-fin,l,s,0,X,nil,nil,s) ->;bonne-coupure(s-ens,y,r-este,X,s1,s,s') ->   mode(m-ode)   coupure-bis(y,s1,s2)   assez-long(m-ode,s1)   assez-long(m-ode,s2)   coupure(s,s1,s')   assez-long(m-ode,s')   arg(0,s1,r-este)   non(noeud-�-�viter(s-ens,X))   bon-sens(s-ens,s1,s1')   bon-sens(s-ens,s2,s2')   bon-sens(s-ens,s1'.s2'.nil,s1''.s2''.nil)   coupure-autoris�e(s1'',s2'',r)   plausible(r)   /;coupure-autoris�e(nil,nil,oui) -> /;coupure-autoris�e(s1,s2,r) ->   c�sure(r,s1,s2)   out(r)   outm(" ")   afficher(s1.s2)   outml(" d�j� vu")   /;coupure-autoris�e(s1,s2,oui) ->   mot-connu(s1)   mot-connu(s2)   afficher(s1)   outm(" et ")   afficher(s2)   outml(" connus")   /;coupure-autoris�e(s1,s2,r) ->   mode(m-ode)   coupure-bis(s1,s11,s12)   assez-long(m-ode,s12)   mot-connu(s11)   coupure-autoris�e(s12,s2,r);coupure-autoris�e(s1,s2,r) ->   mode(m-ode)   coupure(s2,s21,s22)   assez-long(m-ode,s21)   mot-connu(s22)   coupure-autoris�e(s1,s21,r);coupure-autoris�e(s1,s2,r) ->   outm("? ")   afficher(s1.s2)   line   outm("O)ui  N)on  E)ssayer  R)etour sur choix pr�c�dent ")   beep   in-char'(c)   interpr�ter(c,r)   noter-coupure(r,s1,s2)   plausible(r);mot-connu(y) -> fre(w,2,T,y,nil) /;noter-coupure(essai,s1,s2) ->;noter-coupure(oui,s1,s2) ->   ajouter(c�sure(oui,s1,s2))   effacer(c�sure(non,s1,s2))   cr�er-terminal(T1,s1)   cr�er-terminal(T2,s2);noter-coupure(non,s1,s2) ->   ajouter(c�sure(non,s1,s2))   effacer(c�sure(oui,s1,s2));nouveau-reste(r,n,r') ->   bound(r)   val(inf(r,n),0)   val(sub(r,n),r');nouveau-reste(r,n,r') ->   free(r)   freeze(r',val(add(r',n),r));liaison(avant,X,T,Y) ->   fre(w,1,X,T,Y);liaison(arri�re,X,T,Y) ->   fre(w,1,Y,T,X);sp�cifique(m-ode,s,k) ->   arg(0,s,l)   pr�fixe(avant,i,p1)   pr�fixe(arri�re,j,p2)   val(inf(i,l),1)   val(sub(l,i),l')   val(inf(j,l'),1)   val(sub(l',j),k)   assez-long(m-ode,k)   /;sp�cifique(chop,s,1) ->;sp�cifique(chunk,s,2) ->;assez-long(chop,l) ->;assez-long(chunk,k) -> integer(k) / dif(k,1);assez-long(chunk,l) -> eq(l,a.nil) / impasse;assez-long(chunk,l) ->;peut-franchir(arri�re,X) ->   noeud-�-effacer(X)   /   impasse;peut-franchir(avant,X) ->   non(converge(X));peut-franchir(arri�re,X) ->   non(diverge(X));noeud-�-effacer(X) ->   fusion-en-cours(X0)   successeur(X0,X)   /;successeur(X,X) -> /;successeur(X1,X2) ->   fre(w,1,X1,T,X1')   non(converge(X1'))   successeur(X1',X2)   /;noeud-�-�viter(arri�re,X) -> noeud-�-effacer(X);noeud(X) -> diverge(X) /;noeud(X) -> converge(X) /;diverge("S") -> /;diverge(X) ->   fre(w,1,X,T1,Y1)   dif(T1.Y1,T2.Y2)   fre(w',1,X,T2,Y2)   /;converge(nil) -> /;converge(X) ->   fre(w,1,Y1,T1,X)   dif(Y1.T1,Y2.T2)   fre(w',1,Y2,T2,X)   /;compl�ter-free(X1,T,q1,X2,T,q2,s) ->   rule(fre(w,1,X1,T,X2),nil)   suppress(1)   fre(w',2,T,y,nil)   coupure(y,q1,y')   cr�er-terminal(T1,q1)   cr�er-production(1,X1,T1,X1',"X".nil)   coupure(y',y'',q2)   fre(w'',2,T',y',nil)   cr�er-terminal(T2,q2)   cr�er-production(1,X2',T2,X2,"X".nil)   cr�er-terminal(T3,y'')   cr�er-production(1,X1',T3,X2',i-nutile)   cr�er-terminal(T4,s)   cr�er-production(1,X1',T4,X2',i-nutile')   v�rifier-acc�s(T)   v�rifier-acc�s(T')   /;compl�ter-free(X1,T1,q1,X2,T2,q2,s) ->   scinder(avant,X1,T1,X1',q1,q1')   scinder(arri�re,X2,T2,X2',q2',q2)   cr�er-terminal(T,s)   changer-nom(X1',X1'')   changer-nom(X2',X2'')   cr�er-production(1,X1'',T,X2'',i-nutile)   /;scinder(s-ens,X,T,X,nil,nil) ->;scinder(s-ens,X,T,X'',q,q') ->   dif(q,nil)   dif(q',nil)   liaison(s-ens,X,T,X')   fre(w,2,T,y,nil)   coupure(y,q,q')   cr�er-terminal(T1,q)   cr�er-terminal(T2,q')   couper-lien(s-ens,X,T,X')   bon-sens(s-ens,T1.T2.nil,T1'.T2'.nil)   cr�er-lien(s-ens,X,T1',X'')   cr�er-lien(s-ens,X'',T2',X')   v�rifier-acc�s(T);couper-lien(avant,X,T,X') -> effacer-production(1,X,T,X');couper-lien(arri�re,X,T,X') -> effacer-production(1,X',T,X);cr�er-lien(avant,X,T,X') -> cr�er-production(1,X,T,X',"X".nil);cr�er-lien(arri�re,X,T,X') -> cr�er-production(1,X',T,X,"X".nil);cr�er-production(t,X,Y,Z,�-tiquette) ->   free(�-tiquette)   fre(w,t,X,Y,Z)   /;cr�er-production(1,X,T,Y,�-tiquette) ->   bound(X)   bound(Y)   dif(Y,Y')   fre(w,1,X,T,Y')   sous-langage(Y,Y')   superposer(Y,Y')   /;cr�er-production(1,X,T,Z,�-tiquette) ->   bound(X)   bound(Z)   dif(X,X')   fre(w,1,X',T,Z)   assert(fre(0,1,X,T,Z),nil)   essai-fusion(X,T,Z,X')   /;cr�er-production(t,X,Y,Z,�-tiquette) ->   nouvelle-variable(X,�-tiquette)   nouvelle-variable(Z,�-tiquette)   assert(fre(0,t,X,Y,Z),nil)   /;essai-fusion(X,T,Z,X') ->   sous-langage(X,X')   sous-langage(X',X)   rule(fre(w,1,X,T,Z),nil)   suppress(1)   /   outm("je fusionne ")   out(X)   outm(" avec ")   outl(X')   fusionner(sous,X,X')   effacer(fusion-en-cours(X));essai-fusion(X,T,Z,X') ->;fusionner(f,X,X') ->   effacer(nouveau(u,X))   assert(nouveau-nom(X,X'),nil)   assert(fusion-en-cours(X),nil)   effacer-production(1,X,T,nil)   cr�er-production(1,X',T,nil,i-nutile)   impasse;fusionner(f,X,X') ->   rebrancher-sur(X,X')   impasse;fusionner(plus,X,X') ->   changer-nom(X',X'')   retracer-langage(X,X'')   impasse;fusionner(f,X,X') ->   dif(Y,nil)   effacer-production(1,X,T,Y)   effacer-suite(Y)   v�rifier-acc�s(T)   impasse;fusionner(f,X,X') -> corriger-liste-g�n�;rebrancher-sur(Y,Y') ->   fre(w,1,X,T,Y)   cr�er-production(1,X,T,Y',i-nutile)   effacer-autres(X,T,Y,Y')   /;rebrancher-sur(Y,Y') ->;effacer-autres(X,T,Y,Y') ->   nouveau-nom(X,X')   /;effacer-autres(X,T,Y,Y') ->   effacer-production(t,X,T,Y)   impasse;retracer-langage(Y,Y') ->   changer-nom(Y',Y'')   d�rive-de(s,Y,nil,l)   non(d�rive-de(s,Y'',nil,l'))   outm("== ")   afficher(s)   line   tracer(s,Y'',nil)   impasse;retracer-langage(Y,Y') ->;effacer-suite(X) ->   dif(X,"S")   dif(X,nil)   fre(w,1,X,T,Y)   non(fre(w',t',V,T',X))   effacer-production(t,X,T,Y)   effacer(nouveau(u,X))   ajouter(nouveau-nom(X,nil))   v�rifier-acc�s(T)   effacer-suite(Y)   joindre-peut-�tre(Y)   impasse;effacer-suite(Y) ->;joindre-peut-�tre(Y) -> segment� /;joindre-peut-�tre(Y) -> joindre-arcs(Y);superposer(Y,Y') ->   non-d�t(X,T,Y,Y')   outm("Je superpose ")   outm(Y)   outm(" sur ")   outml(Y')   effacer(nouveau(u,Y))   assert(nouveau-nom(Y,Y'),nil)   assert(fusion-en-cours(Y),nil)   effacer-production(1,X,T,Y)   rebrancher-sur(Y,Y')   changer-nom(Y',Y'')   retracer-langage(Y,Y'')   effacer-suite(Y)   /   corriger-liste-g�n�   effacer(fusion-en-cours(Y));non-d�t(X,T,Y,Y') ->   fre(w,1,X,T,Y)   dif(Y,Y')   fre(w',1,X,T,Y');corriger-liste-g�n� ->   rule(g�n�-possible(g-�n�,y1.y2.E1.E2),nil)   suppress(1)   changer-nom(E1,E1')   changer-nom(E2,E2')   variable(E1')   variable(E2')   assert(g�n�-possible(g-�n�,y1.y2.E1'.E2'),nil)   impasse;corriger-liste-g�n� ->   rule(phrase-bis(g-�n�.E1.E2,s),nil)   suppress(1)   changer-nom(E1,E1')   changer-nom(E2,E2')   variable(E1')   variable(E2')   assert(phrase-bis(g-�n�.E1'.E2',s),nil)   impasse;corriger-liste-g�n� ->;variable(nil) -> / impasse;variable(T) -> fre(w,1,X,T,Y) /;variable(X) -> fre(w,1,X,T,Y) /;changer-nom(X,X') ->   nouveau-nom(X,X')   /;changer-nom(X,X) ->;sous-langage(X1,X2) ->   d�rive-de(s,X2,X1,l)   /   impasse;sous-langage(X1,X2) ->   d�rive-de(s,X1,X2,l)   /   impasse;sous-langage(X1,X2) ->   d�rive-de(s,X1,nil,l)   non(d�rive-de(s,X2,nil,l'))   /   impasse;sous-langage(X1,X2) ->;liste-successeurs(X,l) -> liste-succ(X,nil,l);liste-succ(X,l,l'') ->   dif(Y,nil)   fre(w,1,X,T,Y)   hors-de(Y,l)   liste-succ(X,Y.l,l')   liste-succ(Y,l',l'')   /;liste-succ(X,l,l) ->;v�rifier-acc�s(T) ->   fre(w,1,X1,T,X2)   /;v�rifier-acc�s(T) ->   effacer-production(2,T,l,nil)   effacer(nouveau(u,T))   ajouter(nouveau-nom(T,nil))   /;v�rifier-acc�s(t) ->;cr�er-terminal(X,l) -> fre(w,2,X,l,nil) /;cr�er-terminal(X,l) ->   dif(l,nil)   �tiquette-terminale(l,�-tiquette)   cr�er-production(2,X,l,nil,�-tiquette);�tiquette-terminale(l,�-tiquette) ->   arg(0,l,n)   string-integer(N,n)   split(N,L)   concat�ner("T".nil,L,�-tiquette);nouvelle-variable(X,u.v-al) ->   free(X)   nouveau-label(u.v-al,L)   concat�ner(u.nil,L,l1)   concat�ner(l1,v-al,l2)   list-string(l2,X)   ajouter(nouveau(u,X));nouvelle-variable(X,�-tiquette) -> bound(X);nouveau-label(�-tiquette,L') ->   rule(label(�-tiquette,L),nil)   suppress(1)   incr�menter-label(L,L')   assert(label(�-tiquette,L'),nil)   /;nouveau-label(�-tiquette,"A".nil) ->   assert(label(�-tiquette,"A".nil),nil);incr�menter-label(l,l') ->   incr�menter-bis(l,l')   /;incr�menter-label(l,"A".l') ->   suite-de-as(l,l');incr�menter-bis(c.l,c.l') ->   dif(l,nil)   incr�menter-bis(l,l')   /;incr�menter-bis(c.l,c'.l') ->   suite-lettre(c,c')   suite-de-as(l,l')   /;suite-de-as(nil,nil) ->;suite-de-as(c.l,"A".l') ->   suite-de-as(l,l');suite-lettre("Z",c') -> impasse;suite-lettre(c,c') ->   dif(c,"Z")   char-code(c,n)   val(add(n,1),n1)   char-code(c',n1);effacer-production(t,X,Y,Z) ->   rule(fre(w,t,X,Y,Z),nil)   suppress(1);"SEGMENTATION"vocabulaire ->   mode(m-ode)   effacer(d�j�-copi�)   couper-terminaux(m-ode)   titre("Vocabulaire connu:")   /   fre(w,2,T,Y,nil)   d�composition(man,incompl�te,m-ode,Y,l)   afficher(l)   impasse;d�composition(c-ontr�le,compl�te,chunk,a.b.nil,(a.b.nil).nil) -> /;d�composition(c-ontr�le,c,m-ode,y,y1.l) ->   dif(m-ode,nil)   dif(y2,nil)   coupure(y,y1,y2)   assez-long(m-ode,y2)   fre(w,2,T,y1,nil)   non(c�sure(non,y1,y2))   d�composition(c-ontr�le,c,m-ode,y2,l)   /;d�composition(c-ontr�le,compl�te,m-ode,y,l') ->   dif(m-ode,nil)   dif(y1,nil)   coupure-bis(y,y1,y2)   assez-long(m-ode,y1)   fre(w,2,T,y2,nil)   non(c�sure(non,y1,y2))   d�composition(c-ontr�le,compl�te,m-ode,y1,l)   concat�ner(l,y2.nil,l')   /;d�composition(c-ontr�le,incompl�te,m-ode,y,y.nil) ->   fre(w,2,T,y,nil);d�composition(c-ontr�le,compl�te,m-ode,y,y.nil) ->   dif(y,nil)   assez-long(m-ode,y)   autoris�(c-ontr�le,y);d�composition(man,compl�te,m-ode,y,y1.y2.nil) ->   dif(m-ode,nil)   dif(y2,nil)   coupure(y,y1,y2)   assez-long(m-ode,y2)   fre(w,2,T,y1,nil)   coupure-autoris�e(y1,y2,r)   confirmer(r)   /;d�composition(man,compl�te,m-ode,y,y1.y2.nil) ->   dif(m-ode,nil)   dif(y1,nil)   coupure-bis(y,y1,y2)   assez-long(m-ode,y1)   fre(w,2,T,y2,nil)   coupure-autoris�e(y1,y2,r)   confirmer(r)   /;confirmer(oui) ->;confirmer(essai) ->   outm("Confirmer choix pr�c�dent ? O/N ")   in-char'(c)   interpr�ter(c,oui);autoris�(c-ontr�le,y) -> fre(w,2,T,y,nil) /;autoris�(auto,y) ->;segmenter-au-cas-o� ->   segment�   line   outml("    Segmentation:")   mode(m-ode)   segmenter(m-ode)   /;segmenter-au-cas-o� ->;proposer-segmentation -> segment� /;proposer-segmentation ->   non(grammaire-vide)   line   outml("    Il est pr�f�rable de segmenter d'abord.")   outm("    Voulez-vous le faire ? O/N ")   in-char'(c)   line   interpr�ter(c,non)   /;proposer-segmentation -> segmenter;segmenter ->   non(grammaire-vide)   /   effacer(d�j�-copi�)   titre("Segmentation du vocabulaire")   mode(m-ode)   segmenter(m-ode)   assert(segment�,nil)   mise-�-jour-menu   /;segmenter ->;segmenter(m-ode) ->   effacer(d�j�-coup�)   couper-terminaux(m-ode)   fre(w,2,T,y,nil)   d�composition(auto,incompl�te,m-ode,y,l)   arg(0,l,n)   dif(n,1)   outm("* ")   afficher(l)   fractionner(y,l)   impasse;segmenter(m-ode) -> effacer(g�n�-possible);d�segmenter -> non(segment�) /;d�segmenter ->   effacer(d�j�-copi�)   titre("D�segmentation")   outm("Tout d�segmenter ? O/N ")   in-char'(c)   line   interpr�ter(c,non)   /   ressouder-mots;d�segmenter -> d�faire-noeuds mise-�-jour-menu;d�faire-noeuds -> non(segment�) /;d�faire-noeuds ->   outml("Je d�segmente.")   fre(w,1,X,T,X')   non(noeud(X))   joindre-arcs(X)   impasse;d�faire-noeuds ->   effacer(segment�)   effacer(d�j�-coup�)   effacer(g�n�-possible);ressouder-mots ->   encore   prendre-mots(l)   afficher-mots(1,l)   mots-choisis(l,T1,T2)   ressouder(T1,T2)   line   outm("Autre couple de mots ? O/N ")   in-char'(c)   line   interpr�ter(c,non)   /   effacer(liste-des-mots)   effacer(g�n�-possible);mots-choisis(l,T1,T2) ->   arg(0,l,n)   encore   outml("Num�ros des mots � ressouder ? (0,0) pour quitter")   outm("Premier mot: ")   in-word(i',i)   integer(i)   val(inf(n,i),0)   outm("Deuxi�me mot: ")   in-word(j',j)   integer(j)   val(inf(n,j),0)   line   arg(i,l,T1)   arg(j,l,T2)   peut-ressouder(T1,T2)   commenter(T1,T2)   /;afficher-mots(i,nil) -> line;afficher-mots(i,T.l) ->   mode(m-ode)   fre(w,2,T,m,nil)   d�composition(auto,incompl�te,m-ode,m,d)   afficher(sans-format,num�ro,i,d)   val(add(i,1),i1)   afficher-mots(i1,l);commenter(n,T) -> integer(n);commenter(T,n) -> integer(n);commenter(T1,T2) ->   fre(w1,2,T1,y1,nil)   fre(w2,2,T2,y2,nil)   afficher(y1.y2)   outm(" ? O/N ")   in-char'(c)   line   interpr�ter(c,oui)   effacer(c�sure(oui,y1,y2))   ajouter(c�sure(non,y1,y2));peut-ressouder(n,T) -> integer(n);peut-ressouder(T,n) -> integer(n);peut-ressouder(T1,T2) ->   fre(w1,1,X,T1,Y)   fre(w2,1,Y,T2,Z)   /;peut-ressouder(T1,T2) ->   fre(w1,2,T1,y1,nil)   fre(w2,2,T2,y2,nil)   afficher(y1)   outm("/")   afficher(y2)   outml(" ne peuvent pas �tre soud�s.")   /   impasse;ressouder(n,T) -> integer(n);ressouder(T,n) -> integer(n);ressouder(T1,T2) ->   passe-par(Y,T1,T2)   joindre-arcs(Y)   impasse;ressouder(T1,T2) ->   v�rifier-acc�s(T1)   v�rifier-acc�s(T2);passe-par(Y,T1,T2) ->   fre(w1,1,X,T1,Y)   fre(w2,1,Y,T2,Z)   isoler(X,T1,Y,T2,Z);prendre-mots(l) ->   prendre-mots(nil,l);prendre-mots(l,l') ->   fre(w,2,T,m,nil)   hors-de(T,l)   prendre-mots(T.l,l')   /;prendre-mots(l,l) ->;couper-terminaux(m-ode) -> d�j�-coup� /;couper-terminaux(m-ode) ->   line   outml("Coupure des mots")   couper-termi(m-ode)   line   /;couper-termi(m-ode) -> d�j�-coup� /;couper-termi(m-ode) ->   encore   fre(w,2,T,y,nil)   outm("? ")   afficher(y)   line   d�composition(man,compl�te,m-ode,y,l)   cr�er-terminaux(l,r)   eq(r,non)   plus-rien-�-couper(m-ode)   /   assert(d�j�-coup�,nil);couper-termi(m-ode) -> couper-termi(m-ode) /;plus-rien-�-couper(m-ode) ->   fre(w,2,T,y,nil)   d�composition(auto,compl�te,m-ode,y,l)   �l�ment-de(y',l)   non(fre(w',2,T',y',nil))   /   impasse;plus-rien-�-couper(m-ode) ->;isoler(X,T1,Y,T2,Z) -> non(noeud(Y)) /;isoler(X,T1,Y,T2,Z) ->   converge(Y)   cr�er-production(1,Y',T2,Z,"X".nil)   dif(V,X)   effacer-production(1,V,T4,Y)   cr�er-production(1,V,T4,Y',i-nutile)   impasse;isoler(X,T1,Y,T2,Z) ->   diverge(Y)   cr�er-production(1,X,T1,Y'',"X".nil)   dif(W,Z)   effacer-production(1,Y,T3,W)   cr�er-production(1,Y'',T3,W,i-nutile)   impasse;isoler(X,T1,Y,T2,Z) ->;cr�er-terminaux(nil,non) ->;cr�er-terminaux(x.l,r) ->   fre(w,2,T,x,nil)   cr�er-terminaux(l,r)   /;cr�er-terminaux(x.l,oui) ->   cr�er-terminal(X,x)   simplif-c�sure(x)   cr�er-terminaux(l,r);simplif-c�sure(x) ->   mode(m-ode)   rule(c�sure(r,s1,s2),nil)   coupures(s1,x,s11)   dif(s11,nil)   assez-long(m-ode,s11)   suppress(1)   ajouter(c�sure(r,s11,s2))   impasse;simplif-c�sure(x) ->   mode(m-ode)   rule(c�sure(r,s1,s2),nil)   coupures-bis(s2,s21,x)   dif(s21,nil)   assez-long(m-ode,s21)   suppress(1)   ajouter(c�sure(r,s1,s21))   impasse;simplif-c�sure(x) ->;fractionner(y,l) ->   effacer-production(2,T,y,nil)   effacer-production(1,X1,T,X2)   cr�er-liaisons(X1,X2,l)   impasse;fractionner(y,l) ->;cr�er-liaisons(X1,X2,m.nil) ->   cr�er-terminal(T,m)   cr�er-production(1,X1,T,X2,"X".nil);cr�er-liaisons(X1,X2,m.l) ->   dif(l,nil)   cr�er-terminal(T,m)   cr�er-production(1,X1,T,X,"X".nil)   changer-nom(X,X')   changer-nom(X2,X2')   ajouter(nouveau("X",X'))   cr�er-liaisons(X',X2',l)   /;joindre-arcs(X) -> noeud(X) /;joindre-arcs(X) ->   fre(w1,1,X1,T1,X)   fre(w2,1,X,T2,X2)   nouveaux-arcs(X1,X2,T1,T2)   effacer-production(1,X1,T1,X)   effacer-production(1,X,T2,X2)   v�rifier-acc�s(T1)   v�rifier-acc�s(T2)   /;joindre-arcs(X) ->;nouveaux-arcs(X1,X2,T1,T2) ->   fre(w1,2,T1,l1,nil)   fre(w2,2,T2,l2,nil)   concat�ner(l1,l2,l3)   cr�er-terminal(T3,l3)   cr�er-production(1,X1,T3,X2,i-nutile)   impasse;nouveaux-arcs(X1,X2,T1,T2) ->;"DERIVATIONS"v�rifier(s,oui) -> d�rive-de(s,"S",nil,l) /;v�rifier(s,non) ->;d�rive-de(nil,�-tat-final,�-tat-final,nil) ->;d�rive-de(s,X1,X2,(X1.T).l-iste-�tats) ->   fre(w1,1,X1,T,X1')   fre(w2,2,T,s1,nil)   coupure(s,s1,s2)   d�rive-de(s2,X1',X2,l-iste-�tats);phrase-d�riv�e(nil,nil) ->;phrase-d�riv�e((X.T).l,s') ->   fre(w,2,T,y,nil)   phrase-d�riv�e(l,s)   concat�ner(y,s,s');"INITIALISATION"initialisation ->   titre("Initialisation")   s�curit�   effacer-clavier   monde("Suite")   purge   mise-�-jour-menu   /;initialisation ->;"MONDES"remonter(m-onde) -> climb(m-onde) /;remonter(m-onde) ->;monde("Normal") ->   remonter("Connaissance")   remonter("Suite")   remonter("Normal")   /;monde("Suite") ->   monde("Normal")   down("Suite")   /;monde("Connaissance") ->   monde("Normal")   down("Suite")   down("Connaissance")   /;monde("Connaissance") -> cr�er("Connaissance");cr�er(m-onde) ->   monde("Suite")   d�truire(m-onde)   new-subworld(m-onde,25000);d�truire(m-onde) -> kill-subworld(m-onde) /;d�truire(m-onde) ->;entrer-nom(n-om) ->   nom-courant(n)   /   outm("    Changer le nom ? O/N ")   in-char(c)   /   line   interpr�ter(c,r)   autre-nom(r,n,n-om);entrer-nom(n-om) ->;autre-nom(non,n,n) ->;autre-nom(oui,n,n-om) ->;sauvegarde ->   titre("Sauvegarde")   line   entrer-nom(n-om)   close-output   output(n-om)   effacer(nom-courant)   assert(nom-courant(n-om),nil)   effacer(date-dossier)   jour(d)   assert(date-dossier(d),nil)   top   list(10000)   close-output   output("console")   outm("    Ecriture de ")   outl(n-om)   /;reprise ->   titre("Reprise d'un fichier")   s�curit�   monde("Suite")   purge   cr�er("Connaissance")   input(n-om)   line   outm("    Lecture de ")   outl(n-om)   insert   outm("    Derni�re modification: ")   date-dossier(d)   outml(d)   close-input   effacer(histoire)   update;s�curit� ->   code(i,a)   dif(i,0)   /   outm("    Effacer le fichier en m�moire ? O/N ")   in-char'(c)   line   interpr�ter(c,oui);s�curit� ->;interpr�ter("o",oui) ->;interpr�ter("O",oui) ->;interpr�ter("y",oui) ->;interpr�ter("Y",oui) ->;interpr�ter("n",non) ->;interpr�ter("N",non) ->;interpr�ter("?",oui) ->;interpr�ter("?",non) ->;interpr�ter("Q",quitter) ->;interpr�ter("q",quitter) ->;interpr�ter("E",essai) ->;interpr�ter("e",essai) ->;interpr�ter("E",non) ->;interpr�ter("e",non) ->;interpr�ter("P",possible) ->;interpr�ter("p",possible) ->;plausible(oui) ->;plausible(essai) ->;mise-�-jour-menu ->   monde("Connaissance")   effacer-menu   set-exec-item(1,gr-worlds)   string-ident("-",t-rait)   set-exec-item(2,t-rait)   proc�dure(i,p,m)   placer(i,p,m)   impasse;mise-�-jour-menu ->   ajouter(code(0,"-"))   statut-clavier;statut-clavier ->   outm("    Codes clavier: ")   cod�   outml("ACTIFS")   line   /;statut-clavier ->   non(cod�)   outml("INACTIFS")   line;effacer-menu ->   �num�rer(i,1,18)   set-exec-item(i,nil)   impasse;effacer-menu ->;proc�dure(3,clavier,nil) ->;proc�dure(4,phrases,nil) ->;proc�dure(5,production,fre) ->;proc�dure(6,c�sures,c�sure) ->;proc�dure(7,renommer-variables,fre) ->;proc�dure(8,vocabulaire,fre) ->;proc�dure(9,segmenter,fre) -> non(segment�);proc�dure(9,d�segmenter,fre) -> segment�;proc�dure(10,ambiguit�,fre) ->;proc�dure(11,g�n�ralisation,fre) -> segment�;proc�dure(13,format-affichage,nil) ->;proc�dure(14,affichage-grammaire,fre) ->;proc�dure(16,sauvegarde,fre) ->;proc�dure(17,reprise,nil) ->;proc�dure(18,initialisation,nil) ->;placer(i,p,m) ->   r�gle-pr�sente(m)   set-exec-item(i,p)   /;placer(i,p,m) ->;r�gle-pr�sente(nil) ->;r�gle-pr�sente(m) -> find-rule(m);type(fre) ->;type(reg) ->;choisir-mode(m-ode) -> mode(m-ode) /;choisir-mode(nil) ->;demander-mode(m-ode) -> mode(m-ode) / proposer-segmentation;demander-mode(m-ode) ->   encore   outml("Modes de regroupement:")   outml("'chunk': pas de mot de longueur 1")   outml("'chop': pas de restriction sur la longueur")   line   outm("Entrer mode: ")   in-word(s,s')   string-ident(s,m-ode)   mode-connu(m-ode)   /   assert(mode(m-ode),nil);mode-connu(chunk) ->;mode-connu(chop) ->;afficher-seg ->   segment�   outml("    Apr�s segmentation")   /;afficher-seg -> outml("    Non segment�");titre(s) ->   monde("Connaissance")   page   outml(">>> LEARN")   afficher("Fichier:",nom-courant(n))   afficher-jour   afficher("Mode:",mode(m-ode))   afficher-seg   line   outm("    ")   outml(s)   line   /;"DIVERS"update ->   monde("Connaissance")   version(i)   traiter-version(i)   effacer(version)   impasse;update ->   ajouter(version(1))   mise-�-jour-menu;traiter-version(0) ->   rule(fre(t,X,Y,Z),nil)   suppress(1)   assert(fre(0,t,X,Y,Z),nil)   impasse;traiter-version(i) ->;afficher-production(X,Y,Z) ->   fre(w,t,X,Y,Z)   outm("<")   out(w)   outm("> ")   afficher(X)   outm(" --> ")   afficher(Y)   outm(" ")   afficher(Z)   line;afficher(l,<p,x>) -> <p,x> outm("   ") outm(l) outl(x) /;afficher(l,<p,nil>) ->;afficher(f-ormat,num�ro,i,s) ->   outm("[")   out(i)   outm("] ")   afficher(f-ormat,s);afficher(f-ormat,nil) -> /;afficher(sans-format,s) -> afficher(s);afficher(format,s) ->   outm(">> ")   lire(laya(l))   lire(divisions(d))   afficher(l,d,s)   /   line;afficher(nil,d,s) -> afficher(s) /;afficher(l,d,nil) ->;afficher(l,d.d',x.s) ->   dif(l,0)   d�coder(x,x')   outm(x')   val(sub(l,1),l1)   afficher(l1,d.d',s);afficher(0,d.d',s) ->   dif(s,nil)   dif(d,1)   outm("  ")   laya(l)   val(sub(d,1),d1)   afficher(l,d1.d',s);afficher(0,1.d',s) ->   dif(s,nil)   line   outm("  ")   laya(l)   afficher(l,d',s);afficher(0,nil,s) ->   dif(s,nil)   divisions(d)   dif(d,nil)   afficher(0,d,s);afficher(l,nil,x.s) ->   dif(l,0)   d�coder(x,x')   outm(x')   val(sub(l,1),l1)   afficher(l1,nil,s);afficher(0,nil,s) ->   dif(s,nil)   outm(" ")   laya(l)   afficher(l,nil,s);afficher(x.nil) -> eq(x,a.b) afficher(x) line;afficher(x.l) ->   eq(x,a.b)   dif(l,nil)   afficher(x)   outm(" / ")   afficher(l);afficher(split,nil) ->;afficher(split,a.l) ->   afficher(a)   afficher(split,l);afficher(nil) -> /;afficher(a.b) ->   d�coder(a,a')   outm(a')   afficher(b)   /;afficher(a) ->   d�coder(a,a')   outm(a')   outm("  ")   /;afficher-automate ->   titre("Automate:")   reg(t,X,a,Y)   afficher(X)   outm(" --> ")   afficher(a)   outm("  ")   afficher(Y)   outm("      ")   outl(t)   impasse;encoder(nil,nil) ->;encoder(fin,fin) ->;encoder(nonsens,nonsens) ->;encoder(a.l,a'.l') ->   traduction(a,a')   encoder(l,l')   /;encoder(a.l,l') -> encoder(l,l');traduction("-",0) -> /;traduction(a,i) ->   code(i,a)   /;traduction(a,i) ->   non(petit-char(a))   /   impasse;traduction(a,i) ->   code(j,a')   val(add(j,1),i)   assert(code(i,a),nil)   /;traduction(a,1) ->   assert(code(1,a),nil);petit-char(a) ->   char-code(a,n)   val(inf(n,97),0)   val(inf(122,n),0);d�coder(i,a) ->   code(i,a)   /;d�coder(0,"-") -> /;d�coder(a,a) ->;grammaire-vide -> fre(w,t,X,Y,Z) / impasse;grammaire-vide ->;une-phrase-lue -> phrase-lue(i,s) /;une-phrase-non -> phrase-non(i,s) /;une-phrase -> une-phrase-lue /;une-phrase -> une-phrase-non;ajouter-phrase(p,nil) -> /;ajouter-phrase(p,fin) -> /;ajouter-phrase(p,nonsens) -> /;ajouter-phrase(p,s) ->   derni�re(p,n)   val(add(n,1),n1)   ajouter(<p,n1,s>)   /;derni�re(p,n) ->   <p,n,s>   /;derni�re(p,0) ->;dernier(p,i,x) ->   dernier'(p,1,i)   <p,i,x>   /;dernier(p,0,x) ->;dernier'(p,i,j) ->   <p,i,x>   val(add(i,1),i1)   dernier'(p,i1,j)   /;dernier'(p,i,i) -> <p,i,x>;lire(<p,x>) -> <p,x> /;lire(<p,nil>) ->;lirentier(i,i-max) ->   line   encore   outm("    Choix: ")   in-word(i',i)   integer(i)   val(inf(i-max,i),0)   /   line;encore ->;encore -> encore;oui(p) -> p /;non(p) -> p / impasse;non(p) ->;oppos�(oui,non) ->;oppos�(non,oui) ->;ajouter(p) -> p /;ajouter(<p,nil>) -> /;ajouter(<p,i,nil>) -> /;ajouter(p) -> assert(p,nil);effacer(p) ->   rule(p,nil)   suppress(1)   /   effacer(p)   /;effacer(p) ->   ident(p)   find-rule(p)   suppress(1)   /   effacer(p)   /;effacer(p) ->;construire-liste(nil,nil) ->;construire-liste(x.l,x'.l') ->   string-integer(x,x')   construire-liste(l,l')   /;construire-liste(x.l,l') ->   construire-liste(l,l');concat�ner(nil,l,l) ->;concat�ner(x.y,l,x.z) ->   concat�ner(y,l,z);coupure(l,l1,l2) ->   free(l)   freeze(l1,freeze(l2,concat�ner(l1,l2,l)));coupure(l,l1,l2) ->   bound(l)   s�parer(l,l1,l2);coupures(l,x,l'') ->   coupure(l,x,l')   coupures(l',x,l'')   /;coupures(l,x,l') -> coupure(l,x,l');coupure-ter(l,nil,l) ->;coupure-ter(a.l,a.l1,l2) ->   coupure-ter(l,l1,l2);coupure-bis(a.l,a.l1,l2) ->   coupure-bis(l,l1,l2);coupure-bis(a.l,a.nil,l) -> dif(l,nil);coupures-bis(l,l'',x) ->   coupure-bis(l,l',x)   coupures-bis(l',l'',x)   /;coupures-bis(l,l',x) -> coupure-bis(l,l',x);s�parer(a.l,a.nil,l) ->;s�parer(a.l,a.l1,l2) ->   s�parer(l,l1,l2);renverser(l,l') -> renverser'(l,nil,l');renverser'(nil,l,l) ->;renverser'(x.y,l,l') ->   renverser'(y,x.l,l');�l�ment-de(x,x.l) ->;�l�ment-de(x,y.l) ->   dif(x,y)   �l�ment-de(x,l);hors-de(x,l) -> non(�l�ment-de(x,l));supprimer(x,nil,nil) ->;supprimer(x,x.l,l') -> supprimer(x,l,l');supprimer(x,y.l,y.l') ->   dif(x,y)   supprimer(x,l,l');sup-ou-�gal(i,i) ->;sup-ou-�gal(i,j) ->   sup-ou-�gal(i,i')   val(add(i',1),j);�num�rer(x,x,n2) ->   val(inf(n2,x),0);�num�rer(x,n1,n2) ->   val(inf(n2,n1),0)   val(add(n1,1),n1')   �num�rer(x,n1',n2);afficher-jour ->   jour(d)   outm(">>> Date: ")   outml(d);afficher-jour ->;jour("mardi 14 juin 1988") ->;;End world: Normal"                       LEARN.SUITE                          ""                       14 juin 1988                         "" ""----------------------  SAISIE -----------------------------"phrases ->   titre("Traitement de phrases")   traiter-entr�e   annuler-lue   annuler-non   encore   line   outml("(0) Quitter")   outml("(1) Saisie de phrases au clavier")   outml("(2) Saisie d'un fichier du disque")   lirentier(i,2)   entr�e(i)   eq(i,0)   /   mise-�-jour-menu;phrases -> mise-�-jour-menu;entr�e(0) -> /;entr�e(i) ->   effacer(d�j�-coup�)   impasse;entr�e(1) ->   autorisation-clavier   empiler-phrases   /   quoi-faire   /;entr�e(1) ->;entr�e(2) ->   autorisation-clavier   close-input   input(n-om)   lire-fichier-phrases   close-input   /   quoi-faire   /;entr�e(2) ->;autorisation-clavier ->   statut-clavier   outm("    OK ? O/N ")   in-char'(c)   line   interpr�ter(c,oui)   /;autorisation-clavier -> option-clavier statut-clavier;traiter-entr�e ->   une-phrase   outm("Traiter les exemples et contrexemples ? O/N ")   in-char'(c)   interpr�ter(c,oui)   /   quoi-faire   /;traiter-entr�e ->;empiler-phrases ->   encore   outml("*** Tapez une phrase (phrase nulle pour terminer):")   entrer-ligne(s)   afficher(format,s)   continuer(s)   eq(s,nil)   /;continuer(nil) ->;continuer(fin) ->;continuer(s) ->   dif(s,nil)   dif(s,fin)   outm("Correct ? O/N ")   in-char'(c)   interpr�ter(c,oui)   ajouter-phrase(phrase-lue,s);entrer-ligne(s) ->   set-eol(".")   in-sentence(s',x)   �clater(s',s'')   set-eol(" ")   encoder(s'',s)   /;lire-fichier-phrases ->   encore   lire-ligne(f,s)   garder-ligne(s)   eq(f,fin)   /;garder-ligne(nil) -> /;garder-ligne(a.nil) -> /;garder-ligne(s) ->   ajouter-phrase(phrase-lue,s)   phrase-lue(i,s)   afficher(split,num�ro,i,s)   /;lire-ligne(f,s) ->   lire-garb   lire-phrase(f,s1)   donner-sens(s1,s2)   encoder(s2,s)   line   /;lire-garb ->   encore-lire(c)   dif(c,fin)   non(petit-char(c))   /   in-char'(c)   lire-garb   /;lire-garb ->;donner-sens(s,s) -> non(cod�) /;donner-sens(fin,fin) ->;donner-sens(nil,nil) ->;donner-sens("-".l,"-".l') -> donner-sens(l,l') /;donner-sens(w.l,w1.l') ->   key(c,w1)   conc-string(w1,w2,w)   outm(".")   dif(l',nonsens)   donner-sens(w2.l,l')   /;donner-sens("".l,l') ->   outm(" ")   donner-sens(l,l')   /;donner-sens(w.l,nonsens) -> outm("?");lire-phrase(fin,nil) -> encore-lire(c) eq(c,fin) /;lire-phrase(f,"-".s) ->   encore-lire("-")   in-char'(c)   /   lire-phrase(f,s);lire-phrase(f,w.s) ->   encore-lire(c)   petit-char(c)   in-word(w,w')   /   lire-phrase(f,s);lire-phrase(suite,nil) ->;�clater(s,s) -> non(cod�) /;�clater(".".nil,".".nil) ->;�clater(s.".".nil,s'') ->   cod�   split(s,s')   traduire-cl�(s',s'');�clater(s.l,s') ->   �clater(s.".".nil,s1)   �clater(l,s2)   concat�ner(s1,s2,s');traduire-cl�(nil,nil) ->;traduire-cl�(".".l,l') ->   traduire-cl�(l,l')   /;traduire-cl�("-".l,"-".l') -> traduire-cl�(l,l') /;traduire-cl�(c.l,x.l') ->   key(c,x)   traduire-cl�(l,l')   /;traduire-cl�(c.l,l') ->   out(c)   outml(": touche inconnue.")   traduire-cl�(l,l');encore-lire(c) -> block(e,next-char'(c)) dif(e,104) /;encore-lire(fin) ->;quoi-faire ->   line   une-phrase   encore   menu-faire   lirentier(i,8)   faire(i)   eq(i,0)   /;quoi-faire -> mise-�-jour-menu;menu-faire ->   il-reste   outml("(0) Quitter")   une-phrase-lue   outml("(1) Compl�ter le noyau � l'aide des exemples")   outml("(2) Sauvegarder les exemples dans un fichier")   non(grammaire-vide)   outml("(3) Etudier les exemples et proposer des substitutions")   outml("(4) Exemples --> contrexemples")   impasse;menu-faire ->   une-phrase-non   non(grammaire-vide)   outml("(5) Contrexemples --> exemples")   outml("(6) Corriger le noyau � l'aide des contrexemples")   impasse;menu-faire ->   une-phrase   outml("(7) Revoir un par un les exemples et contrexemples")   outml("(8) Effacer")   /;menu-faire ->;il-reste ->   derni�re(phrase-lue,m)   reste(phrase-lue,i,0,1,m)   out(i)   outml(" exemples")   derni�re(phrase-non,n)   reste(phrase-non,j,0,1,n)   out(j)   outml(" contrexemples")   line;reste(p,i',i,j,n) ->   <p,j,s>   val(add(i,1),i1)   val(add(j,1),j1)   reste(p,i',i1,j1,n)   /;reste(p,i',i,j,n) ->   val(inf(j,n),1)   val(add(j,1),j1)   reste(p,i',i,j1,n)   /;reste(p,i,i,j,n) ->;faire(0) ->;faire(1) -> une-phrase-lue tracer-derni�res /;faire(1) -> outml("Il n'y a pas d'exemple.") beep;faire(2) ->   titre("Sauvegarde d'un fichier de phrases")   close-output   output(n-om)   echo   derni�re(phrase-lue,n)   �num�rer(i,1,n)   phrase-lue(i,s)   encoder(s',s)   outm("[")   out(i)   outm("] ")   afficher(split,s')   line   impasse;faire(2) ->   close-output   output("console")   no-echo   /   quoi-faire   /;faire(3) -> �tudier /;faire(4) ->   annuler-non   transf�rer(phrase-lue,phrase-non)   /;faire(5) ->   annuler-lue   transf�rer(phrase-non,phrase-lue)   /;faire(6) ->   une-phrase-non   contrexemples   /;faire(6) ->   outml("Il n'y a pas de contrexemple.")   beep   /;faire(7) ->   line   outml("Exemples (phrases correctes):")   derni�re(phrase-lue,n)   examiner(n,phrase-lue);faire(7) ->   line   outml("Contrexemples:")   derni�re(phrase-non,n)   examiner(n,phrase-non);faire(7) -> / quoi-faire /;faire(8) -> annuler-lue annuler-non /;examiner(n,p) ->   �num�rer(i,1,n)   rule(<p,i,s>,nil)   afficher(format,num�ro,i,s)   outm("   Garder cette phrase ? O/N    (Q)uitter ")   in-char'(c)   interpr�ter(c,r)   d�cision-garder(r)   /;d�cision-garder(non) -> suppress(1) impasse;d�cision-garder(quitter) ->;transf�rer(p1,p2) ->   derni�re(p1,n)   �num�rer(i,1,n)   rule(<p1,i,s>,nil)   suppress(1)   ajouter-phrase(p2,s)   impasse;transf�rer(p1,p2) ->;contrexemples ->   une-phrase-non   line   outm("Modifier le noyau � l'aide des contrexemples ? O/N ")   in-char'(c)   interpr�ter(c,oui)   derni�re(phrase-non,n)   �num�rer(i,1,n)   rule(phrase-non(i,s),nil)   suppress(1)   line   afficher(format,num�ro,i,s)   effacer-phrase(s)   impasse;contrexemples ->;"--------- RECHERCHE DE GENERALISATIONS PAR SUBSTITUTION ---------"�tudier ->   effacer(en-cours)   effacer(sens)   ajouter(sens(1))   liste-g�n�(per)   liste-g�n�(sub)   impasse;�tudier ->   effacer(ajout�)   derni�re(phrase-lue,n)   �num�rer(i,1,n)   phrase-lue(i,s)   line   afficher(format,num�ro,i,s)   �tudier(s)   impasse;�tudier ->   ajout�   effacer(ajout�)   line   outm(   "Mettre � jour la grammaire avec les phrases non reconnues ? O/N ")   in-char'(c)   interpr�ter(c,oui)   tracer-derni�res   impasse;�tudier -> v�rifier-acc�s(T) impasse;�tudier ->   find-rule(en-cours)   outm("Etudier les g�n�ralisations propos�es ? O/N ")   in-char'(c)   interpr�ter(c,oui)   en-cours(g-�n�,E1.E2)   essai(g-�n�,E1.E2)   impasse;�tudier ->;�tudier(s) ->   d�rive-de(s,"S",nil,l)   outml("Phrase d�j� connue.")   effacer(phrase-lue(i,s))   /;�tudier(s) ->   g�n�-simple(g-�n�)   g�n�-possible(g-�n�,y1.y2.E1.E2)   outm(".")   obtenue-de(g-�n�,s,s',E1,E2)   ajouter(en-cours(g-�n�,E1.E2))   /   line   beep   g�n�ralisation(g-�n�,n-om)   outm("> ")   outml(n-om)   afficher-sub(y1,y2)   outm(" ==> ")   outm(E1)   outm(" = ")   outml(E2)   outm("Mod�le: ")   afficher(format,s');�tudier(s) ->   line   beep   outm("Est-ce un contrexemple ? O/N ")   in-char'(c)   interpr�ter(c,r)   lue-ou-non(r,s);g�n�-simple(per) -> outm("per");g�n�-simple(sub) -> line outm("sub");obtenue-de(g-�n�,s,s',E1,E2) ->   variation(g-�n�,s,s',E1,E2)   d�rive-de(s',"S",nil,l-iste)   /;obtenue-de(g-�n�,s,s',E1,E2) ->   variation(g-�n�,s,s',E2,E1)   d�rive-de(s',"S",nil,l-iste)   /;lue-ou-non(oui,s) ->   rule(phrase-lue(i,s),nil)   suppress(1)   outml("Je la place dans le fichier de contrexemples.")   ajouter-phrase(phrase-non,s);lue-ou-non(non,s) ->   outm("Effacer cette phrase ? O/N ")   in-char'(c)   interpr�ter(c,r)   effacer-phrase-entr�e(phrase-lue,s,r);effacer-phrase-entr�e(p,s,oui) ->   rule(<p,i,s>,nil)   suppress(1);effacer-phrase-entr�e(p,s,non) -> ajouter(ajout�);annuler-lue ->   une-phrase-lue   line   outm("Oublier les exemples r�cemment entr�s ? O/N ")   in-char'(c)   line   interpr�ter(c,oui)   effacer(phrase-lue)   /;annuler-lue ->;annuler-non ->   une-phrase-non   line   outm("Oublier les contrexemples ? O/N ")   in-char'(c)   line   interpr�ter(c,oui)   effacer(phrase-non)   /;annuler-non ->;"----------------- AFFICHAGE DE GRAMMAIRE -----------------------"affichage-grammaire ->   titre("Grammaire courante:")   parcourir("S",nil,l-iste-d-arcs)   impasse;"Parcours d'un graphe orient� sans boucle � un seul sommet"parcourir("S",nil,l) ->   eq(t-rait,"------------------------------------------------------")   outml(t-rait)   outml("GRAM#1")   parcourir'(1,"S",nil,l1)   outml(t-rait)   outml("GRAM#2")   /   fre(w,2,X,Y,Z)   afficher-production(X,Y,Z)   impasse;parcourir'(t,X1,l,l''') ->   fre(w,t,X1,X2,X3)   hors-de(X1.X2.X3,l)   afficher-production(X1,X2,X3)   parcourir'(t,X2,l,l')   parcourir'(t,X3,l',l'')   /   parcourir'(t,X1,(X1.X2.X3).l'',l''')   /;parcourir'(t,X,l,l) ->;"--------------------- GENERALISATION ---------------------------"g�n�ralisation ->   monde("Connaissance")   segment�   annuler-non   effacer(noeuds)   effacer(sens)   ajouter(sens(1))   titre("G�n�ralisations possibles:")   mise-�-jour-g�n�   afficher-g�n�ralisations(0,nil,n)   encore   lirentier(i,n)   g�n�ralisation'(i,g-�n�)   /   g�n�(g-�n�)   mise-�-jour-menu   /;g�n�ralisation(nil,"Quitter") ->;g�n�ralisation(has,"G�n�rer des variations au hasard") ->;g�n�ralisation(per,"Permutation (mots de longueurs �gales)") ->;g�n�ralisation(sub,"Substitution") ->;g�n�ralisation(rem1,"Fusion �vidente") ->;g�n�ralisation(rem2,"Fusion g�n�rale") ->;g�n�ralisation(ind,"Induction � partir du dernier exemple") ->;g�n�ralisation'(n,g-�n�) ->   val(add(n,1),n1)   g�n�ralisation'(n1,0,g-�n�,nil);g�n�ralisation'(n,n,g-�n�,g-�n�.L) ->;g�n�ralisation'(n,i,g-�n�,L) ->   dif(i,n)   g�n�ralisation(g-�n�',n-om')   hors-de(g-�n�',L)   possible(g-�n�')   val(add(i,1),i1)   /   g�n�ralisation'(n,i1,g-�n�,g-�n�'.L);mise-�-jour-g�n� ->   liste-g�n�(per)   liste-g�n�(sub)   liste-g�n�(rem1)   liste-g�n�(rem2)   liste-g�n�(ind)   /;liste-g�n�(g-�n�) -> g�n�-possible(g-�n�,l) /;liste-g�n�(ind) ->   non(nouveau(u,X))   assert(g�n�-possible(ind,nil),nil)   /;liste-g�n�(ind) ->   beep   outm("Induction � partir de la derni�re phrase entr�e ? O/N ")   in-char'(c)   interpr�ter(c,non)   line   assert(g�n�-possible(ind,nil),nil)   effacer(nouveau)   /;liste-g�n�(g-�n�) ->   g�n�ralisation(g-�n�,n-om)   outm("> ")   outml(n-om)   chercher-g�n�(g-�n�)   �liminer-anciennes-phrases-bis(g-�n�);afficher-g�n�ralisations(i,L,n) ->   g�n�ralisation(g-�n�,n-om)   possible(g-�n�)   hors-de(g-�n�,L)   outm("(")   out(i)   outm(") ")   outml(n-om)   val(add(i,1),i1)   /   afficher-g�n�ralisations(i1,g-�n�.L,n)   /;afficher-g�n�ralisations(i,L,i) ->;possible(nil) -> /;possible(has) -> /;possible(g-�n�) ->   g�n�-possible(g-�n�,L)   dif(L,nil)   /;g�n�(nil) -> /;g�n�(has) ->   titre("Improvisation")   encore   choix(g�n�-possible(g-�n�,y1.y2.E1.E2))   g�n�ralisation(g-�n�,n-om)   outml(n-om)   afficher-sub(y1,y2)   outm(" ==> ")   outm(E1)   outm(" = ")   outml(E2)   la-prochaine(g-�n�,s,s',E1,E2)   /;g�n�(g-�n�) ->   titre("Recherche de g�n�ralisation")   g�n�ralisation(g-�n�,n-om)   outm("   ")   outml(n-om)   g�n�-bis(g-�n�);la-prochaine(g-�n�,s,s',E1,E2) ->   oui(variation(g-�n�,s,s',E1,E2))   non(phrase-bis(g',s'))   non(phrase-non(g'',s'))   /   proposer(g-�n�,y1.y2.E1.E2,s,s');la-prochaine(g-�n�,nil,nil,E1,E2) ->   fin-essai(non,g-�n�.E1.E2);proposer(g-�n�,y1.y2.E1.E2,s,s') ->   dif(s',nil)   afficher(format,s)   outml("devient:")   afficher(format,s')   outml("(0) quitter  (1) accepter  (2) ?")   outml("(3) contrexemple  (4) changer sens")   lirentier(i,4)   changer-sens(i)   garder-phrase(i,g-�n�.E1.E2,s')   sortie(i);g�n�-bis(g-�n�) ->   g�n�-possible(g-�n�,nil)   /   line   outml("Aucune g�n�ralisation de ce type possible.")   line   outm("    <taper 'o'>")   in-char'(c)   impasse;g�n�-bis(g-�n�) ->   encore   mise-�-jour-g�n�   line   outml("Couples d'expressions � examiner:")   line   afficher-g�n�(g-�n�,1,nil,n)   outml("    (0 pour quitter)")   lirentier(i,n)   g�n�-num�ro(i,g-�n�,m)   remettre-�-z�ro(g-�n�.m)   essayer(g-�n�,m)   sortie(i)   /;essayer(g-�n�,m) ->   dif(m,nil)   outm("Valider imm�diatement ? O/N ")   in-char'(c)   interpr�ter(c,oui)   valider(g-�n�.m,2)   /;essayer(g-�n�,m) -> essai(g-�n�,m);g�n�-num�ro(0,g-�n�,nil) -> /;g�n�-num�ro(i,g-�n�,m) ->   r�gle-ordre(g�n�-possible(g-�n�,y1.y2.m),i);r�gle-ordre(p,n) -> r�gle-ordre(p,nil,1,n);r�gle-ordre(<p,x,y>,l,i,n) ->   rule(<p,x,y'>,nil)   hors-de(y',l)   r�gle-trouv�e(<p,x,y>,y'.l,i,n)   /;r�gle-trouv�e(<p,x,y>,y.l,i,i) ->;r�gle-trouv�e(<p,x,y>,y'.l,i,n) ->   dif(i,n)   val(add(i,1),i1)   r�gle-ordre(<p,x,y>,y'.l,i1,n);essai(g-�n�,nil) -> /;essai(ind,X1.X2) ->   dif(g-�n�,ind)   g�n�-possible(g-�n�,y1.y2.X1.X2)   essai(g-�n�,X1.X2)   /;essai(g-�n�,E1.E2) ->   variation(g-�n�,s,s',E1,E2)   non(phrase-bis(g',s'))   non(phrase-non(g'',s'))   non(v�rifier(s',oui))   line   afficher(format,s)   outml("devient:")   afficher(format,s')   conclure(j)   garder-phrase(j,g-�n�.E1.E2,s')   valider(g-�n�.E1.E2,j)   /;essai(g-�n�,E1.E2) ->   line   outml("Vous avez examin� toutes les variations.")   outm("Changer le sens des substitutions ? O/N ")   in-char'(c)   interpr�ter(c,r)   fin-essai(r,g-�n�.E1.E2);une-variation(g-�n�,s,s',X1,X2) ->   variation(g-�n�,s,s',X1,X2)   /;une-variation(g-�n�,s,s',X1,X2) ->   variation(g-�n�,s,s',X2,X1)   /;variation(per,s,s',T1,T2) ->   permuter(l,T1.T2,l')   d�rive-de(s,"S",nil,l)   phrase-d�riv�e(l',s');variation(rem1,s,s',E1,E2) ->   variation(rem,s,s',E1,E2);variation(rem2,s,s',E1,E2) ->   variation(rem,s,s',E1,E2);variation(rem,s,s',E1,E2) ->   sens(1)   d�rive-de(s2,E1,nil,l2)   /   d�rive-de(s1,"S",E1,l1)   d�rive-de(s3,E2,nil,l3)   concat�ner(s1,s3,s')   concat�ner(s1,s2,s);variation(rem,s,s',E2,E1) ->   sens(2)   d�rive-de(s2,E1,nil,l2)   /   d�rive-de(s1,"S",E1,l1)   d�rive-de(s3,E2,nil,l3)   concat�ner(s1,s3,s')   concat�ner(s1,s2,s);variation(sub,s,s',T1,T2) ->   dif(l,l')   changer(l,T1.T2,l')   d�rive-de(s,"S",nil,l)   phrase-d�riv�e(l',s');changer(nil,m,nil) ->;changer((X.T1).l,T1.T2,(X.T2).l') ->   sens(1)   freeze(l,changer(l,T1.T2,l'));changer((X.T2).l,T1.T2,(X.T1).l') ->   sens(2)   freeze(l,changer(l,T1.T2,l'));changer(g.l,m,g.l') ->   freeze(l,changer(l,m,l'));permuter((X.T1).l,T1.T2,(X.T2).l') ->   sens(1)   freeze(l,permuter'(l,T1.T2,l'));permuter((X.T2).l,T1.T2,(X.T1).l') ->   sens(2)   freeze(l,permuter'(l,T2.T1,l'));permuter(g.l,m,g.l') ->   freeze(l,permuter(l,m,l'));permuter'((X.T2).l,T1.T2,(X.T1).l) ->;permuter'(g.l,m,g.l') ->   freeze(l,permuter'(l,m,l'));fin-essai(non,g) ->   pas-toujours-vrai(g)   valider(g,1)   proposer-valid(g)   /;fin-essai(non,g) ->   proposer-valid(g)   /;fin-essai(non,g) ->;fin-essai(oui,g-�n�.E1.E2) -> changer-sens / essai(g-�n�,E1.E2);proposer-valid(g) ->   outm("Valider cette g�n�ralisation ? O/N ")   in-char'(c)   interpr�ter(c,oui)   valider(g,2)   /;proposer-valid(g) ->;conclure(i) ->   line   outml("(0) quitter  (1) accepter   (2) valider g�n�ralisation")   outml("(3) contrexemple        (4) changer sens substitutions")   lirentier(i,4);changer-sens(0) ->;changer-sens(4) ->   changer-sens   impasse;changer-sens ->   effacer(sens(i))   val(sub(3,i),i')   ajouter(sens(i'));garder-phrase(0,g,s) ->;garder-phrase(1,g,s) ->   assert(phrase-bis(g,s),nil)   /   impasse;garder-phrase(2,g,s) -> assert(phrase-bis(g,s),nil);garder-phrase(3,g,s) ->   ajouter-phrase(phrase-non,s)   ajouter(pas-toujours-vrai(g))   impasse;garder-phrase(4,g,s) ->;valider(g,i) ->   dif(i,2)   dif(i,4)   proposer-supp(g)   proposer-modif;valider(g,2) ->   outml("Attention: irr�versible.")   outml("Mais les contrexemples restent dans le buffer d'entr�e.")   outm("Accepter ? O/N ")   in-char'(c)   line   interpr�ter(c,oui)   supprimer-g�n�(g)   ajouter(segmentation-compl�te)   g�n�raliser(g)   effacer(nouveau-nom)   effacer(segmentation-compl�te)   contrexemples   /;valider(g,4) -> fin-essai(oui,g);g�n�raliser(sub.T1.T2) -> �galiser(T1,T2) �galiser(T2,T1) /;g�n�raliser(per.T1.T2) ->   ajouter(segmentation-compl�te)   �changer(T1,T2)   �changer(T2,T1)   effacer(segmentation-compl�te)   /;g�n�raliser(rem1.X1.X2) ->   non-d�t(X0,T,X1,X2)   superposer(X1,X2)   /;g�n�raliser(g-�n�.X1.X2) ->   fusionner(plus,X1,X2)   effacer(fusion-en-cours(X1))   segmenter-au-cas-o�;�galiser(T1,T2) ->   fre(w,1,X,T1,Y)   cr�er-production(1,X,T2,Y,i-nutile)   impasse;�galiser(T1,T2) ->;�changer(T1,T2) ->   variation(per,s,s',T1,T2)   tracer(s',"S",nil)   impasse;�changer(T1,T2) ->;�liminer-anciennes-phrases-bis(g-�n�) ->   rule(phrase-bis(g-�n�.E1.E2,s),nil)   non(g�n�-possible(g-�n�,y1.y2.E1.E2))   non(g�n�-possible(g-�n�,y1'.y2'.E2.E1))   suppress(1)   impasse;�liminer-anciennes-phrases-bis(g-�n�) ->;chercher-g�n�(g-�n�) ->   modif-possible(g-�n�,y1,y2,E1.E2)   non(g�n�-possible(g-�n�,y1'.y2'.E2.E1))   non(g�n�-possible(g-�n�,y1.y2.E1.E2))   ajouter(g�n�-possible(g-�n�,y1.y2.E1.E2))   outm(".")   impasse;chercher-g�n�(g-�n�) ->   non(g�n�-possible(g-�n�,m))   assert(g�n�-possible(g-�n�,nil),nil);chercher-g�n�(g-�n�) -> line;modif-possible(nil,nil,nil,E.E) ->;modif-possible(per,y1,y2,T1.T2) ->   fre(w1,2,T1,y1,nil)   arg(0,y1,n)   dif(T1,T2)   fre(w2,2,T2,y2,nil)   arg(0,y2,n)   oui(suite(X1,T1,Y1,X2,T2,Y2));modif-possible(sub,y1,y2,T1.T2) ->   fre(w1,2,T1,y1,nil)   dif(T1,T2)   arg(0,y1,n)   fre(w2,2,T2,y2,nil)   arg(0,y2,n);modif-possible(rem1,nil,nil,E1.E2) ->   non-d�t(E0,T,E1,E2);modif-possible(rem2,nil,nil,E1.E2) ->   liste-des-noeuds(L)   �l�ment-de(E1.n,L)   dif(E1,E2)   �l�ment-de(E2.n,L)   non(fusionnables(E1,E2))   noeud-valeur(n,E1,s1)   noeud-valeur(n,E2,s2);modif-possible(ind,y1,y2,T1.T2) ->   nouveau("T",T1)   dif(T1,T2)   fre(w1,2,T1,y1,nil)   arg(0,y1,n)   fre(w2,2,T2,y2,nil)   arg(0,y2,n)   non(fusionnables(T1,T2));modif-possible(ind,nil,nil,E1.E2) ->   nouveau("X",E1)   liste-des-noeuds(L)   noeud-valeur(n,E1,s1)   dif(E1,E2)   �l�ment-de(E2.n,L)   non(fusionnables(E1,E2))   noeud-valeur(n,E2,s2);fusionnables(E1,E2) ->   dif(g,sub)   g�n�-possible(g,y1.y2.E1.E2)   /;fusionnables(E1,E2) ->   dif(g,sub)   g�n�-possible(g,y1.y2.E2.E1)   /;afficher-g�n�(g-�n�,i,l,n) ->   g�n�-possible(g-�n�,y1.y2.E1.E2)   hors-de(y1.y2.E1.E2,l)   outm("[")   out(i)   outm("] ")   afficher-sub(y1,y2)   outm(" ==> fusion de ")   outm(E1)   outm(" avec ")   outml(E2)   val(add(i,1),i1)   afficher-g�n�(g-�n�,i1,(y1.y2.E1.E2).l,n)   /;afficher-g�n�(g-�n�,i,l,i) -> line;afficher-sub(nil,nil) -> /;afficher-sub(y1,y2) ->   outm("(")   sens(1)   afficher(y1)   outm(") --> (")   afficher(y2)   outm(")")   /;afficher-sub(y1,y2) ->   sens(2)   afficher(y2)   outm(") --> (")   afficher(y1)   outm(")")   /;liste-des-noeuds(L) ->   noeuds(L)   /;liste-des-noeuds(L) ->   liste-noeuds(L)   arg(0,L,n)   val(sub(n,1),n1)   val(mul(n,n1),n2)   val(div(n2,2),n3)   out(n3)   outml(" fusions possibles")   assert(noeuds(L),nil);liste-noeuds(l) -> liste-noeuds(nil,l);liste-noeuds(l,l') ->   fre(w,1,X,Y,Z)   dif(Z,nil)   hors-de(Z.n,l)   noeud-valeur(n,Z,s)   liste-noeuds((Z.n).l,l')   /;liste-noeuds(l,l) ->;noeud-valeur(n,E,s) ->   d�rive-de(s,E,nil,l)   arg(0,s,n)   /;remettre-�-z�ro(g) ->   line   oui(phrase-bis(g,s))   outm(   "Oublier toutes les phrases valid�es dans cette g�n�ralisation ? O"   )   in-char'(c)   interpr�ter(c,r)   effacer-phrase-bis(g,r)   effacer(pas-toujours-vrai(g));remettre-�-z�ro(g) ->;effacer-phrase-bis(g-�n�.E1.E2,oui) ->   rule(phrase-bis(g-�n�.E1.E2,s),nil)   suppress(1)   impasse;effacer-phrase-bis(g-�n�.E1.E2,oui) ->   rule(phrase-bis(g-�n�.E2.E1,s),nil)   suppress(1)   impasse;effacer-phrase-bis(g,r) ->;sortie(0) ->;sortie(i) ->   dif(i,0)   line   outm("D'autres essais ? O/N ")   in-char'(c)   interpr�ter(c,non);suite(X1,T1,Y1,X2,T2,Y2) ->   fre(w1,1,X1,T1,Y1)   fre(w2,1,X2,T2,Y2)   suivant(Y1,X2);suivant(X,X) ->;suivant(X1,X2) ->   dif(X1,X2)   fre(w,1,X1,T,X1')   suivant(X1',X2)   /;supprimer-g�n�(g-�n�.E1.E2) ->   effacer(g�n�-possible(g-�n�,y1.y2.E1.E2))   effacer(g�n�-possible(g-�n�,y1'.y2'.E2.E1))   effacer(pas-toujours-vrai(g-�n�.E1.E2))   effacer(en-cours(g-�n�,E1.E2))   effacer(en-cours(g-�n�,E2.E1))   /;supprimer-g�n�(g) ->;proposer-supp(g) ->   outml("Eliminer cette g�n�ralisation ?")   outm("(Les exemples valid�s seront conserv�s.)  O/N ")   in-char'(c)   interpr�ter(c,oui)   /   supprimer-g�n�(g);proposer-supp(g) ->;proposer-modif ->   oui(phrase-bis(g,s))   line   outml("Modifier la grammaire pour accepter")   outm("les exemples valid�s dans toutes les g�n�ralisations ? O/N ")   in-char'(c)   interpr�ter(c,oui)   modifier;proposer-modif ->;modifier ->   ajouter(segmentation-compl�te)   line   outml("Mise � jour de la grammaire")   line   rule(phrase-bis(g,s),nil)   suppress(1)   afficher(format,s)   tracer(s,"S",nil)   line   impasse;modifier ->   effacer(segmentation-compl�te)   effacer(g�n�-possible);effacer-r�gle(p,n) ->   r�gle-ordre(p,n)   suppress(1);"-------------------- EFFACER UNE PHRASE -------------------------"effacer-phrase(s) ->   effacer(nouveau)   non(v�rifier(s,oui))   outml("Cette phrase n'�tait pas reconnue.")   /;effacer-phrase(s) ->   outml("Je supprime cette phrase.")   effacer-tout(s)   effacer(segmentation-compl�te)   mise-�-jour-menu;ambiguit� ->   titre("Suppression des ambiguit�s")   d�rive-de(s,"S",nil,l)   r�duire(s)   impasse;ambiguit� ->;r�duire(s) ->   ambigu(s)   outm(".")   enlever(s)   r�duire(s) line   /;r�duire(s) ->;ambigu(s) ->   d�rive-de(s,"S",nil,l)   dif(l,l')   d�rive-de(s,"S",nil,l')   /;effacer-tout(s) ->   v�rifier(s,oui)   enlever(s)   effacer-tout(s)   /;effacer-tout(s) ->;enlever(s) ->   chemin-sp�cifique(s,X1,L,X2,s2)   d�lier(X1,L,X2)   joindre-peut-�tre(X1)   changer-nom(X2,X2')   joindre-peut-�tre(X2')   changer-nom(X2',X2'')   outml("Mise � jour de la grammaire.")   ajouter(segmentation-compl�te)   coupure(s,s1,s2)   mise-�-jour(s1,X2'',s2.nil,X2''')   effacer-suite(X2''')   changer-nom(X2''',X2'''')   superposer-si-n�cess(X2'''');mise-�-jour(s1,X2,l,X2'') ->   d�rive-de(s2',X2,nil,l')   hors-de(s2',l)   concat�ner(s1,s2',s')   outm(">>> ")   afficher(sans-format,s')   line   tracer(s',"S",nil)   changer-nom(X2,X2')   mise-�-jour(s1,X2',s2'.l,X2'')   /;mise-�-jour(s1,X2,l,X2) -> line;superposer-si-n�cess(X) ->   superposer(X,X')   /;superposer-si-n�cess(X2) ->;changer-acc�s(X2,X2') ->   effacer-production(t,X2,Y,Z)   cr�er-production(t,X2',Y,Z,i-nutile)   impasse;changer-acc�s(X2,X2') ->   effacer-production(t,X,Y,X2)   cr�er-production(t,X,Y,X2',i-nutile)   impasse;changer-acc�s(X2,X2') ->;chemin-sp�cifique(s,X1,L,X2,s2) ->   chemin-sp�cifique(s,X1,L,X2,"S",X1',L',s2)   /;chemin-sp�cifique(s,X1,L,X2,X,X1',L',s2) ->   fre(w1,1,X,T,X')   non(converge(X))   diverge(X)   fre(w2,2,T,y,nil)   coupure(s,y,s')   chemin-sp�cifique(s',X1,L,X2,X',X,(T.X').nil,s2)   /;chemin-sp�cifique(s,X1,L',X2,X,X1',L,s2) ->   fre(w1,1,X,T,X')   non(converge(X))   fre(w2,2,T,y,nil)   coupure(s,y,s')   chemin-sp�cifique(s',X1,L',X2,X',X1',(T.X').L,s2);chemin-sp�cifique(s,X1,L',X,X,X1,L,s) ->   converge(X)   d�rive-de(s,X,nil,l-iste-�tats)   renverser(L,L');d�lier(X2,nil,X2) ->;d�lier(X,(T.X').L,X2) ->   effacer-production(1,X,T,X')   v�rifier-acc�s(T)   d�lier(X',L,X2);"---------------- RENOMMER VARIABLES ---------------------------"renommer-variables ->   titre("Changement de variables")   encore   outml("Entrer pr�fixe: 1 caract�re sauf X ou T: ")   outm("Q)uitter ")   in-char'(p)   dif(p,"T")   dif(p,"X")   /   dif(p,"Q")   dif(p,"q")   effacer(nouveau-nom)   effacer(noeuds)   liste-des-noeuds(L)   renommer(L,L',p,L)   effacer(noeuds(L))   ajouter(noeuds(L'))   renommer-noeuds   effacer(nouveau-nom)   effacer-labels-variables(p);renommer(nil,nil,p,L) ->;renommer((X.n).L,(X'.n).L',p,L-iste) ->   outm(X)   outm(" --> ")   string-integer(N,n)   split(N,N')   concat�ner(p.nil,N',l)   nouvelle-variable(X',l)   hors-de(X'.n,L-iste)   outml(X')   ajouter(nouveau-nom(X,X'))   renommer(L,L',p,L-iste);renommer-noeuds ->   rule(fre(w,1,X,Y,Z),nil)   suppress(1)   changer-nom(X,X')   changer-nom(Z,Z')   assert(fre(w,1,X',Y,Z'),nil)   outm(".")   impasse;renommer-noeuds ->   rule(nouveau(u.v-al,X),nil)   dif(u,"T")   suppress(1)   changer-nom(X,X')   assert(nouveau(u.v-al,X'),nil)   impasse;renommer-noeuds ->   corriger-liste-g�n�   line;effacer-labels-variables(p) ->   rule(label(p.l,L),nil)   suppress(1)   impasse;effacer-labels-variables(p) -> line;"----------------  FORMAT AFFICHAGE -----------------------"format-affichage ->   monde("Connaissance")   encore   page   outml("Format d'affichage")   line   afficher("Laya: ",laya(l))   afficher("Divisions: ",divisions(d))   line   outml("(0) Quitter")   outml("(1) Laya")   outml("(2) Divisions")   lirentier(i,2)   changer-aff(i)   eq(i,0)   /;changer-aff(0) ->;changer-aff(1) ->   outml("Entrer laya ('0' si aucune division): ")   in-word(i',i)   integer(i)   effacer(laya)   dif(i,0)   ajouter(laya(i))   /;changer-aff(1) ->;changer-aff(2) ->   non(laya(i))   outml("Il faut d'abord entrer un laya.")   /;changer-aff(2) ->   outml("Entrer les divisions:")   outml("Pas de division: liste nulle.")   set-eol(".")   in-sentence(s,s')   set-eol(" ")   construire-liste(s,l)   effacer(divisions)   ajouter(divisions(l));"----------------- GENERATION DE PHRASES ------------------------"production ->   titre("Production de phrases")   traiter-entr�e   encore   line   outml("(0) Quitter")   outml("(1) Dans l'ordre")   outml("(2) Au hasard")   lirentier(i,2)   /   annuler-lue   production(i);production(0) ->;production(1) ->   titre("Phrases dans l'ordre")   outm("Montrer segmentation ? O/N ")   in-char'(c)   line   interpr�ter(c,r)   d�rive-de(s,"S",nil,l)   ajouter-phrase(phrase-lue,s)   montrer-phrase(s,r,l)   impasse;production(1) ->   line   outml("Phrases plac�es dans buffer d'entr�e.")   /   quoi-faire   /;production(2) ->   annuler-non   titre("Synth�se de phrases au hasard")   outm("Montrer segmentation ? O/N ")   in-char'(c)   line   interpr�ter(c,r)   encore   prod-hasard(s,"S",nil,l)   non(phrase-lue(i,s))   montrer-phrase(s,r,l)   outm("     Correct ? O/N ")   in-char'(c')   interpr�ter(c',r')   d�cision(s,r')   outm("   Une autre ? O/N ")   in-char'(c'')   interpr�ter(c'',non)   /   annuler-lue   contrexemples   /;montrer-phrase(s,non,l) -> afficher(format,s) /;montrer-phrase(s,oui,l) ->   mode(m-ode)   liste-terminaux(l,L)   afficher(sans-format,L)   /;liste-terminaux(nil,nil) ->;liste-terminaux((X.T).l,y.L) ->   fre(w,2,T,y,nil)   liste-terminaux(l,L);d�cision(s,non) ->   outml("Phrase copi�e dans le buffer d'entr�e.")   ajouter-phrase(phrase-non,s);d�cision(s,oui) ->   ajouter-phrase(phrase-lue,s);prod-hasard(nil,f,f,nil) ->;prod-hasard(s,X1,X2,(X1.T).l) ->   choix(fre(w1,1,X1,T,X1'))   choix(fre(w2,2,T,s1,nil))   coupure(s,s1,s2)   prod-hasard(s2,X1',X2,l)   /;choix(p) ->   unifiables(p,n)   dif(n,0)   encore   choix-entier(n,i)   r�gle-choisie(i,p)   /;r�gle-choisie(i,p) ->   assign(num�ro,0)   choisir-r�gle(i,p);choisir-r�gle(i,p) ->   p   eq(num�ro,n)   val(add(n,1),n1)   assign(num�ro,n1)   eq(n1,i)   /;choisir-r�gle(i,<p,nil>) ->;unifiables(p,n) ->   assign(num�ro,0)   tout-essayer(p)   eq(n,num�ro);unifiables(p,0) ->;tout-essayer(p) ->   p   eq(num�ro,n)   val(add(n,1),n1)   assign(num�ro,n1)   impasse;tout-essayer(p) ->;choix-entier(n,i) ->   cpu-time(x)   val(mod(x,n),i1)   val(add(i1,1),i);"------------------------ CLAVIER --------------------------------"clavier ->   titre("Codage du clavier")   statut-clavier   encore   menu-clavier   lirentier(i,4)   clavier(i)   eq(i,0)   /   statut-clavier;clavier(0) ->;clavier(1) ->   effacer-clavier   input(n-om)   insert   close-input   /;clavier(2) ->   afficher-codage   effacer-clavier   coder-clavier;clavier(3) ->   oui(key(i,x))   close-output   output(n-om)   lister-clavier   close-output   output("console")   /;clavier(4) ->   option-clavier;menu-clavier ->   line   outml("(0) Quitter")   outml("(1) Charger code clavier")   outml("(2) Cr�er / modifier un code")   oui(key(i,x))   outml("(3) Sauvegarder ce code")   outml("(4) Valider / d�valider ce code")   /;menu-clavier ->;lister-clavier ->   rule(key(c,s),nil)   list(1)   impasse;lister-clavier -> outml(";");un-code ->   key(c,s)   /;effacer-clavier ->   un-code   outm("    Effacer les codes en m�moire ? O/N ")   in-char'(c)   line   interpr�ter(c,oui)   effacer(key);effacer-clavier ->;option-clavier ->   non(cod�)   outm("    Utiliser le codage en entr�e ? O/N ")   in-char'(c)   interpr�ter(c,r)   option(r)   /;option-clavier ->   outm("    Supprimer le codage de l'entr�e ? O/N ")   in-char'(c)   interpr�ter(c,oui)   effacer(cod�)   /;option-clavier ->;option(oui) -> ajouter(cod�);option(non) ->;afficher-codage ->   oui(key(i,x))   outml("    Codage connu:")   key(c,s)   out(c)   outm(" --> ")   outl(s)   impasse;afficher-codage ->   manque-cl�   outml("    Cl�s � coder:")   code(i,s)   dif(i,0)   non(key(c,s))   outl(s)   impasse;afficher-codage ->;manque-cl� -> code(i,s) dif(i,0) non(key(c,s)) /;coder-clavier ->   encore   outm("touche ? <'.' pour quitter> ")   in-char'(c)   changer-touche(c)   eq(c,".")   /;changer-touche(".") -> /;changer-touche(c) ->   key(c,s)   /   outm(s)   outm(" est remplac� par: ")   entrer-bol(s')   effacer(key(c,s))   coder(c,s')   /;changer-touche(c) ->   entrer-bol(s)   coder(c,s);entrer-bol(s) ->   encore   outm("bol ? ")   in-word(s,s')   accepter-bol(s,oui)   /;accepter-bol(s,oui) -> code(i,s) /;accepter-bol(s,r) ->   beep   outm("Ce bol n'existe pas.  Accepter ? O/N ")   in-char'(c)   line   interpr�ter(c,r);coder(c,s) ->   key(c,s)   outml("D�j� connu.")   beep   /;coder(c,s) ->   key(c,s')   dif(s,s')   outm("Touche d�j� affect�e � ")   outl(s')   beep   /;coder(c,s) ->   key(c',s)   dif(c,c')   outm("D�j� cod� sur la touche ")   outl(c)   beep   /;coder(c,s) ->   ajouter(key(c,s));tihai(s) ->   coupure(s,s1,s2)   mot-connu(s1)   coupure-ter(s2,s3,s4)   mot-connu(s3)   coupure(s4,s1,s5)   coupure-ter(s5,s3,s6)   coupure(s6,s1,s7)   /;double(s) ->   coupure(s,s1,s2)   mot-connu(s1)   coupure(s2,s3,s4)   mot-connu(s3)   coupure(s4,s3,s5)   /;c�sures ->   titre("C�sures:")   c�sure(r,x,y)   out(r)   outm("  ")   afficher(x.y)   line   impasse;;End world: Suite�  5  ��  34  �