Les
expérimentations que nous avons menées afin de valider notre modèle visaient
deux objectifs. Le premier était d’obtenir des comportements satisfaisants d’un
point de vue qualitatif, en vérifiant que notre modèle effectuait bien les
opérations dont nous prétendions qu’il était capable. Le second était de
vérifier que le comportement de notre modèle correspondait bien, selon des critères
quantitatifs, aux données expérimentales dont nous disposions. Trois
applications ont été développées à cet effet :
· Une application de résolution de la tour
de Hanoï.
· Une application vérifiant le
fonctionnement de la compilation logique des connaissances, que nous avons
baptisée ‘knowledge compiler’.
· Une application de résolution de
problèmes de trigonométrie (niveau 1ère S).
Les
expérimentations quantitatives ont été menées sur la tour de Hanoï. Le
‘knowledge compiler’ a été développé dans le seul but de vérifier que les
mécanismes de compilation que nous proposions fournissaient bien le résultat
attendu. Enfin, la résolution de problèmes trigonométriques avait pour double
objectif d’établir la portabilité de notre approche et de tester les mécanismes
de mémorisation pour la planification.
Nous avons testé notre modèle sur la résolution du problème
de la tour de Hanoï à cinq disques. Avant de présenter les résultats obtenus
lors de cette expérimentation, nous allons indiquer les choix que nous avons
effectués pour notre modélisation, puis nous proposerons une trace d’une
résolution par notre modélisation.
Avant de réaliser l’application que nous présentons ici,
nous avons construit une première application qui nous a servi de laboratoire
pour tester l’influence de la valeur de différents paramètres. Le principe de
cette première application était de tenter de coller au plus près d’un
protocole
particulier en fixant manuellement les profondeurs de l’opérateur et de
l’exploration libre. Les préférences étaient également choisies afin de coller
au mieux au protocole choisi. Nous avons essayé par la suite de trouver des
règles expliquant l’évolution des préférences en cours de résolution. Aucune des
hypothèses testées ne s’est montrée satisfaisante de ce point de vue. Notre
expérience avec ce premier laboratoire nous a conduit à fixer les profondeurs
de l’opérateur et de l’exploration libre à 2.
A partir des informations obtenues lors de cette première
phase d’expérimentation, nous avons pu réaliser une application permettant de
comparer le comportement de notre modèle à celui de sujets humains sur la
résolution du problème de la tour de Hanoï. Avant de présenter les modalités
choisies afin d’effectuer la comparaison, nous allons indiquer les choix que
nous avons effectués pour réaliser cette seconde application.
Nous avons utilisé deux types de règle d’incompatibilité
dans notre modélisation. La forme de ces règles, avec X un disque, Y et Z deux pitons distincts, était :
[[X
est en Y, X est en Z], []] Þ
Incompatible (1)
[[non X est
en A, non X est en B, non X est en C], []] Þ Incompatible (2)
Nous n’avons pas représenté les règles du jeu sous forme de
règle d’incompatibilité car l’opérateur ne proposant que des coups légaux, ces
règles se seraient révélées inutiles. La règle (1) exprime le fait qu’un disque ne peut pas se trouver sur deux
pitons en même temps, et la règle (2)
exprime le fait qu’un disque est toujours présent sur au moins un piton.
L’analyse de la trace des résolutions montre que la règle (2) n’intervient jamais au cours de la résolution. La règle (1) est quant à elle utilisée au moment
des productions contre-factuelles.
Le noyau des règles d’indésirabilité prend toujours la forme
(avec X un disque et Y un piton) :
[non X en Y]
Le
menu des règles d’indésirabilité peut contenir les éléments suivants :
[non
X en Y] et/ou
[X en Y]
Au
total, la forme générale des règles d’indésirabilité est donc :
[[non
X en Y], [X1 en Y1 | non X2 en Y2]] Þ
Indésirable
On
notera qu’il n’y a pas de limite théorique au nombre d’éléments (tant en
affirmation qu’en négation) présents dans le menu. Cependant, la structure
particulière du problème de la tour de Hanoï fait que la taille du menu ne
dépasse jamais trois éléments pour un problème à cinq disques. Pour la tour de
Hanoï, nous avons utilisé une structure de pile pour stocker les règles
d’indésirabilités. Cela peut paraître surprenant si l’on se rappelle la discussion
sur la pile du chapitre 6. Mais nous n’avons réalisé les problèmes que posait
la pile qu’au moment où nous nous sommes intéressés à la mémorisation de la
planification (la pile n’apparaît donc pas dans l’application consacrée à la
résolution de problème trigonométrique). Au début de la résolution, la pile
contient (sommet de la pile présenté en premier) :
[[non
5 en C], []] Þ
Indésirable
[[non
4 en C], []] Þ
Indésirable
[[non
3 en C], []] Þ
Indésirable
[[non
2 en C], []] Þ
Indésirable
[[non
1 en C], []] Þ
Indésirable
Enfin,
les faits stockés sont tous de la forme :
X
est en Y : vrai/faux (CF)
On
notera que tout couple (X,Y) est à tout moment représenté dans la
mémoire du modèle. Pour la tour de Hanoï à 5 disques, cela signifie qu’il y a
en permanence quinze faits stockés. Cela peut paraître beaucoup, mais on se
place dans l’hypothèse où le sujet modélisé a en permanence le dispositif
physique sous les yeux. Le nombre de faits effectivement utilisé pendant la
phase d’exploration est égal à la longueur totale (noyau + menu) de la règle
d’indésirabilité courante, et est donc inférieur ou égal à quatre. Le nombre de
faits utilisés au cours de la production contre-factuelle est de quatre (deux
pour la situation réelle et deux pour la situation contre-factuelle).
7.1.1.2 L’opérateur
L’opérateur prend la forme d’un triplet (Etat, Action, Etat). Un état
est représenté sous la forme de trois listes de disques, représentant les trois
pitons. Une action est un mouvement élémentaire d’un piton vers un autre piton.
L’opérateur n’est pas autorisé à déplacer deux fois de suite
le même disque, sauf à l’issue d’une production contre-factuelle. Compte tenu
de cela, il suffit d’indiquer comme préférence le piton cible préférentiel en
fonction du piton source, puisqu’il n’y aura en général qu’un seul disque
pouvant être déplacé. Dans les rares cas où deux disques peuvent être déplacés,
le déplacement du petit disque est toujours envisagé en premier.
Nos expérimentations quantitatives nous ont montré que les
performances humaines étaient mieux modélisées si nous prenions également en
compte dans le contexte des préférences le fait que le disque 5 (le plus gros) ait été ou non
déplacé. Les préférences de l’opérateur peuvent donc, à titre d’exemple,
prendre cette forme (le premier élément de la liste sera le piton cible
préféré, et le second élément de la liste sera évalué en second) :
Contexte Préférence
Piton
Source Déplacement 5 Piton Source
A Avant [C,
B]
A Après [C,
B]
B Avant [A,
C]
B Après [C,A]
C Avant [B,
A]
C Après [A,
B]
En production contre-factuelle l’opérateur est appelé avec
les situations :
Réelle Contre-factuelle
X est Y,
X n’est pas en Z X
est en Z, X n’est pas en Y
L’opérateur traduit cela dans sa représentation, ce qui
donne (pour X = 4, Y = A et Z = B) :
(4) () () : ? : () (4) ()
L’opérateur en déduit le coup à exécuter (‘4 de A en B’), normalement en
effectuant une recherche normale à partir de la situation réelle (compte tenu
de la simplicité de ce point, nous avons programmé cette recherche de manière
plus directe). L’opérateur cherche alors à déterminer quelle situation rend le
coup possible, en utilisant des contraintes simples (les disques plus petits ne
doivent se trouver ni sur le piton source ni sur le piton cible). Les disques n’intervenant
pas dans les contraintes ne sont pas présents dans la situation produite. Dans
l’exemple traité, le disque 5
n’apparaît pas dans la situation calculée qui est :
() () (1 2 3)
La situation calculée est retournée au module logique qui
ignorera les éventuels disques déjà en place, et qui retiendra comme nouveau
sous-but le plus grand des disques restants. On obtient alors (en
supposant que le menu de la règle d’indésirabilité ayant provoqué la production
contre-factuelle était [non 5 en C])
:
Situation Objectif
déduit
(4
5) (1 3) (2) [[non 3 en
C], [non 4 en B, non 5 en C]] Þ
Indésirable
(4
5) (1 2) (3) [[non 2 en
C], [non 4 en B, non 5 en C]] Þ
Indésirable
7.1.1.3 Le fonctionnement
Le fonctionnement général de notre application est de suivre
la boucle suivante :
· Exploration par l’opérateur du voisinage de la situation
courante. Si l’indésirabilité courante est levée, accepter l’action (ou la
suite d’actions) associée. Remplacer l’indésirabilité courante par
l’indésirabilité précédente s’il en existe une puis relancer le processus de
recherche. Arrêter le processus de recherche s’il n’existe plus
d’indésirabilité saturée.
· En cas d’échec,
effectuer le coup préféré de l’opérateur tant que la limite d’exploration libre
n’est pas atteinte, puis relancer le processus de recherche.
· Quand la limite d’exploration libre est atteinte, lancer une
production contre-factuelle. Une fois le sous-but mémorisé, réinitialiser le
compteur d’exploration libre, vider la mémoire du dernier disque déplacé et
relancer le processus de recherche.
La
comparaison entre la résolution du problème de la tour de Hanoï par notre
modèle et par des sujets humains nous a permis de vérifier deux points :
· Les performances de notre modèle, mesurées en
terme de pourcentage de coups joués par des sujets humains correctement
reconnus, et que nous avons comparées à celles d’autres modèles, sont
satisfaisantes.
· Les causes des différences entre les coups
joués par des sujets humains et ceux de notre modèle sont dans une grande
majorité les causes que nous attendions.
7.1.2.1 Principe de la comparaison
Afin
de pouvoir effectuer une comparaison au-delà de la première différence
constatée au cours d’un protocole entre la résolution du modèle est celle du
sujet humain, nous avons contraint notre application à se placer à chaque étape
dans la situation résultant du coup choisi par le sujet humain. Cela nous
permet de mesurer le pourcentage de coups correctement prévus par notre modèle.
En
l’absence de règle pour expliquer l’évolution des préférences en cours de
résolution, nous avons décidé de forcer les préférences à la valeur qui aurait
amené le coup du sujet, et ce à chaque fois qu’une erreur est détectée pendant
l’exploration libre. Chaque coup du modèle est calculé avec les préférences
qu’il a mémorisées, puis la comparaison au coup du sujet humain est effectuée.
Si une différence est constatée, et si le modèle était en situation
d’exploration libre, la préférence responsable du coup du modèle est inversée.
Au début de la première résolution d’un sujet donné, les préférences sont
choisies au hasard.
Précisons
que cette inversion de préférence n'a pas pour effet de faciliter la recherche
du coup en cours, puisque celui-ci est déjà calculé. Il s'agit plutôt de
prendre acte du fait que la valeur de la préférence de l'opérateur de calcul de
notre simulation n'est pas compatible avec le comportement du sujet, et d'en
tirer la conséquence. Le lecteur pourrait nous objecter que ce recadrage des
préférences sur le comportement du sujet aura pour conséquence d'améliorer les
performances globales de notre système. Nous répliquerions que c'est
précisément le point que nous cherchons à vérifier.
En
effet, si la notion de préférence est valide, le comportement de ce modèle
devrait être significativement meilleur que celui d'un modèle sans préférence.
Si notre simulation n'incluant pas les préférences s'avère être un
pronostiqueur du comportement du sujet aussi efficace que notre simulation les
incluant, notre hypothèse de l'existence de telles préférences sera invalidée.
Nous
avons effectué notre expérimentation sur une base de quarante protocoles
produits par sept novices adultes. Ces protocoles nous ont étés fournis par
Josiane Caron-Pargue [CAP 96],
ils ont été analysés par une équipe pluridisciplinaire [LAB 96]. Ces quarante protocoles totalisent 1462 coups.
Afin
de pouvoir étalonner les performances de notre modèle (noté M), nous avons également testé
quatre autres modèles :
· Hasard (M1)
(pas exactement un modèle, l’objectif était ici de vérifier que notre
application était correcte, en retournant une performance d’environ 33 %).
· Hasard sans déplacer deux fois de suite le même
disque (M2). Notre objectif était de
vérifier que, d’une part, les sujets respectaient cette contrainte (au moins
partiellement) et que, d’autre part, cette caractéristique de notre modèle
(i.e. respecter cette contrainte, sauf à l’issue d’une production
contre-factuelle) n’était pas suffisante pour expliquer ses performances.
· Notre modèle, en remplaçant les préférences par
le hasard (M3). Cela ne modifie ni
l’exploration guidée ni la génération contre-factuelle. Seule l’exploration
libre se trouve modifiée par la suppression des préférences. Notre objectif
était de vérifier l’apport des capacités logiques, et de démontrer que
celles-ci n’expliquaient pas la totalité des préférences.
· Un modèle inspiré du travail de Kurt VanLehn
sur l’apprentissage au cours d’une tâche de résolution de problème (MVL) [VAN 91], que nous détaillons plus bas. Notre objectif était ici
simplement de comparer les performances des deux modèles.
Les
résultats attendus de cette expérimentation étaient que d’une part, les
différences entre les performances des modèles M, M1, M2 et M3 soient significativement différentes, et que, d’autre part, les
performances des modèles testés soient classées dans l’ordre suivant :
Performance(M)
> Performance(M3) > Performance(M2) > Performance(M1)
Nous
n’avions pas d’attente particulière sur les performances de MVL, bien que nous espérions découvrir
que M serait significativement
meilleur.
Dans
le modèle MVL trois coups sur quatre
sont des coups forcés. A chaque fois que le disque 1 est déplacé, le coup suivant consiste à déplacer le seul autre
disque que l’on puisse légalement déplacer et de le placer sur le seul piton où
il peut légalement aller. A chaque fois que le disque 2 est déplacé, le coup suivant consiste à ramener le disque 1 sur le disque 2. Enfin, le coup optimal est choisi pour tous les autres coups.
Sans correction, ce modèle ne fournit que la solution optimale. On notera que
dans son travail, VanLehn ne cherche pas à reproduire les performances
humaines. Son objectif était d’étudier comment se déroule l’apprentissage au
cours d’une résolution de problème.
Nous
avons décidé d’utiliser son modèle comme référence car il était simple à
implanter, et parce que nous pensions qu’il fournirait de bonnes performances,
compte tenu de la qualité des résolutions humaines de la tour de Hanoï, qui
sont proches de la résolution optimale qu’implante MVL.
7.1.2.2 Analyse quantitative
Pour chaque modèle, nous avons calculé le rapport du nombre
de coups correctement prédits sur le nombre de coups total. Les résultats
obtenus sont :
Hasard
(M1) : 33.68
%
Hasard
sans retour arrière (M2) : 68.88
%
Notre
modèle sans préférences (M3) : 73.76
%
Inspiré
par VanLehn (MVL) : 78.66
%
Notre
modèle (M) : 81.60
%
Les résultats donnés par les modèles incluant une part de
hasard (M1, M2 et M3) peuvent varier
de 1 % sur une exécution. Les résultats présentés ici sont une moyenne sur
dix exécutions. La performance de M1
est très légèrement supérieure à 33,3 % car dans la situation initiale,
seuls deux coups sont autorisés. La performance de notre modèle (M) peut varier de 0.7 % (par le
fait du choix aléatoire des préférences initiales). La performance du modèle
inspiré par VanLehn ne varie pas, ce modèle étant déterministe.
Les différences entre les modèles sont toutes significatives
à 5 % (c²
= 15,49 soit P < 0,0005 (0,05 %), entre notre modèle et M3, à titre d’exemple), à l’exception
de la différence entre notre modèle et MVL
(c²
= 1,51 soit P < 0,25).
Les résultats obtenus sont conformes aux résultats attendus,
ce qui constitue une forte validation des hypothèses émises. Cependant, et même
si notre modèle est, en tendance, meilleur que celui inspiré par VanLehn, il
reste qu’il n’existe pas de différence significative entre ces deux modèles.
Nous allons maintenant essayer de déterminer pourquoi.
7.1.2.3 Analyse qualitative
Le modèle MVL ne
génère de lui-même que la résolution optimale, ce qui ne constitue pas
exactement une bonne modélisation du comportement humain. Notre modèle peut
générer des résolutions sous-optimales. En outre, le modèle MVL effectue des hypothèses fortes sur
ce que sait un sujet humain. Les règles qui déterminent les trois-quarts des
mouvements sont des règles spécialisées qu’un sujet expérimenté peut
éventuellement connaître, mais qu’un sujet novice ignore. Les bonnes performances
de MVL sont dues pour l’essentiel au
fait que les sujets humains résolvent la tour de Hanoï de manière efficace. Les
résolutions humaines sont proches de la résolution optimale, et donc proches de
celle de MVL. Ce modèle est en
l’état peu plausible. De fait, il serait plus convenable pour modéliser le
comportement d’un sujet expert.
Un autre point méritant l’attention est la cause des
différences entre les coups générés par notre modèle et les coups choisis par
les sujets humains. L’annexe B-1
présente la liste des différences (coup par coup) entre la prévision du modèle
et le coup effectivement joué par le sujet que l’on cherche à modéliser (sur
une exécution particulière, i.e. avec un choix de préférences initiales
particulier). Les différences dues à un mauvais choix de préférences sont
listées en annexe B-2. Ces
différences étaient attendues puisque notre modèle n’inclut pas de mécanisme
d’apprentissage pour l’opérateur. L’annexe B-3
présente la liste des différences autres que celles dues à des préférences. Il
ne reste plus que 91 différences entre notre modèle et le comportement humain,
soit 6,22 %, si les différences dues aux préférences sont ignorées.
Une deuxième cause de différence est le fait que notre
modèle ne change pas d’avis. A l’exception de deux coups séparés par une
production contre-factuelle, notre modèle n’envisage jamais de déplacer deux
fois de suite le même disque. Or l’étude des protocoles montre que les sujets
déplacent effectivement parfois plusieurs fois de suite le même disque. Ce type
de coup est accompagné d’un commentaire du type ‘je me suis trompé’.
On notera que cette cause de différence est valable pour MVL qui lui non plus n’envisage pas
deux déplacements successifs du même disque. Mais contrairement à MVL, qui définit la moitié des
mouvements de son modèle à partir de cette interdiction, nous pouvons envisager
une hypothèse s’intégrant dans notre modèle et expliquant ces déplacements
successifs d’un même disque.
Sans avoir le moyen de le vérifier, nous émettons l’hypothèse
que les sujets ont des attentes quant à la longueur du nombre de coups
nécessaires pour atteindre un sous-but qu’ils ont déjà su atteindre dans le
passé, une fois qu’ils ont acquis une certaine confiance dans leurs
préférences. Si cette longueur est supérieure à la profondeur de l’opérateur,
les premiers coups sont effectués en fonction des préférences. Quand la somme
entre le nombre de coups effectués et la profondeur de l’opérateur devient égal
à la longueur attendue, le sujet peut détecter une éventuelle erreur dans ses
derniers choix. Si tel est le cas, il revient alors en arrière, ce qui entraîne
plusieurs déplacements successifs pour le même disque : le sujet change
d’avis.
Cette capacité de détection d’erreur ne pouvant être simulée
sans une meilleure connaissance des mécanismes d’apprentissage des opérateurs,
nous n’avons pu la simuler dans notre modèle. Dans de telles situations, et
compte tenu de l’interdiction faite à notre modèle d’effectuer des déplacements
successifs pour un même disque, il apparaît systématiquement une différence
entre le comportement du modèle et le comportement observé.
L’annexe B-4
présente la liste des différences autres que celles dues aux préférences et
celles dues aux déplacements successifs d’un même disque. Il ne reste alors
plus que 20 différences entre notre modèle et le comportement observé, soit
1,37 % du nombre total de coups. Discuter des causes de différence sur ces
20 coups restants ne nous apparaît pas intéressant compte tenu de la faible
quantité de données disponibles.
Afin de vérifier la faisabilité de la
compilation logique des connaissances, nous avons développé une petite
application testant le comportement des mécanismes postulés. Cette application
permet de saisir rapidement une base de règles paradoxales. On peut alors
lancer le moteur de l’application. On saisit dans un premier temps les
valeurs de vérité que le moteur doit connaître avant la résolution. A partir
des faits en mémoire, le moteur cherche à montrer qu’il n’existe pas de jeu de
valeurs de vérité pour les termes dont la valeur est encore inconnue permettant
de rendre la base cohérente.
Pour réaliser cela, le moteur va produire
des hypothèses pour chacun des termes ne disposant pas encore de valeur de
vérité.
S’il arrive à générer un jeu d’hypothèses ne saturant aucune des règles de la
base, la compilation logique échoue (l’ensemble {base + faits connus} n’est pas
problématique, et il n’est donc pas possible de créer une nouvelle règle). Si
la génération d’un tel jeu d’hypothèses n’est pas possible, le moteur mémorise
une nouvelle règle constituée de l’ensemble des faits connus au début de la
compilation logique, de modalité paradoxale. Après avoir saisi les règles (les
termes sont représentés dans cette application par des entiers, un terme nié
est représenté par l’inverse de l’entier le représentant) :
[1, 2] Þ
Incompatible
[- 2] Þ
Incompatible
Le lancement du moteur donne :
génération : 1
génération : 2
paradoxe par [1,2]
génération : -2
paradoxe par [-2]
génération : -1
génération : 2
échec de la compilation
Après avoir saisi le fait 1 (comprendre (1 : vrai), -1
aurait signifié (1 : faux)),
une nouvelle tentative de compilation donne :
génération : 2
paradoxe par [1,2]
génération : -2
paradoxe par [-2]
nouvelle règle calculée : [1]
Notre objectif est ici de démontrer qu’il
était possible de définir un tel mécanisme de compilation au sein de notre
modèle. Nous ne cherchons pas à vérifier si ce mécanisme est effectivement mis
en œuvre par des sujets humains. En conséquence, nous n’avons pas poussé plus
avant le développement de cette application (il aurait notamment était possible
d’optimiser la génération contre-factuelle en utilisant les règles pour choisir
l’ordre dans lequel évaluer les valeurs de vérités des termes inconnus).
7.3 Résolution de problèmes trigonométriques
Afin d’établir la généralité de notre modèle, nous l’avons
appliqué à la résolution de problèmes de trigonométrie. Notre principal
objectif est de montrer que le modèle est capable de résoudre des problèmes
autres que des jeux utilisés en laboratoire. Nous avons également comparé les
modélisations avec et sans pile. Enfin, nous avons testé l’effet de
l’apprentissage dans le modèle sans pile, modèle que nous avons finalement
retenu.
L’objectif de chacun des exercices proposés est d’effectuer
des transformations (linéarisation, mise en facteur, identité remarquable…) sur
des expressions trigonométriques. Deux différences principales apparaissent par
rapport au problème de la tour de Hanoï. La première réside dans le fait
qu’aucune règle d’incompatibilité n’est nécessaire pour résoudre un problème.
En effet, aucune expression trigonométrique n’est paradoxale a priori.
La seconde différence réside dans la complexité de l’opérateur. Alors que dans
la tour de Hanoï la seule opération légale est le déplacement d’un disque, il
existe une multitude d’opérations possibles dans une résolution de problème
trigonométrique. Le développement de l’application nous a également appris que
la résolution d’un problème trigonométrique nécessite de nombreuses
connaissances préalables. Au sens littéral du terme, notre modèle ignore a priori que deux et deux font quatre.
Modéliser la connaissance nécessaire pour résoudre
un problème particulier n’est donc en rien une tâche aisée. Il faut remarquer
qu’il ne saurait en être autrement, si l’on considère le temps passé par un
sujet humain pour acquérir les connaissances mathématiques préalables
nécessaires à la résolution de problèmes trigonométriques.
Nous avons également été surpris par la difficulté
d’exprimer les objectifs d’un problème trigonométrique, notamment à cause du
manque de précision des énoncés.
L’énoncé «Développer l’expression cos(a + b + c) en une somme algébrique de produits» n’exprime pas à
proprement parler un objectif mais indique plutôt la direction des opérations à
entreprendre. En particulier, la condition d’arrêt de la recherche n’est pas
précisée dans cet énoncé. L’expression cos(a)cos(b
+ c) – sin(a)sin(b + c) est une somme algébrique de produits, et peut être
considérée comme une solution au problème posé. Cette réponse n’est pourtant
pas acceptable.
L’énoncé (considéré comme équivalent) «exprimer cos(a + b + c) en fonction de cos(a), cos(b), sin(a) et sin(b)» peut apparaître plus explicite,
mais l’expression cos(a)cos(b)cos(c) –
cos(a)sin(b)sin(c) – sin(a)sin(b + c) peut alors être considérée comme une
solution acceptable. De fait, un énoncé correct pour ce problème serait
«exprimer cos(a + b + c) en
fonction des termes cos(a), cos(b), sin(a) et sin(b) et
uniquement de ceux-là». Ce type d’énoncé n’est jamais utilisé dans un recueil
d’exercice.
Ce point crée une difficulté pour les étudiants cherchant à
résoudre de tels exercices : ils ne savent pas quand considérer le
problème comme résolu. Il serait apparemment facile d’adopter un énoncé complet
afin d’exprimer correctement le but à résoudre, ce qui n’est pourtant jamais
fait.
La raison expliquant ce manque de rigueur apparent des
enseignants de mathématique apparaît clairement dans notre modèle :
l’expression «et uniquement de ceux là» n’a pas de sens pour le module logique.
Il est aisé d’exprimer sous forme d’indésirabilité la présence ou l’absence
d’un terme, comme cosinus(x) :
[[non l’expression contient cosinus(x)], []] Þ
Indésirable
[[l’expression contient cosinus(x)], []] Þ
Indésirable
La lecture de l’expression concernée suffit à déterminer si
oui ou non la règle est saturée. Mais la simple lecture d’une expression
mathématique ne nous permet pas de vérifier directement la valeur de vérité
d’un terme comme :
[[non
l’expr. contient seulement des termes de {cos(a), cos(b), sin(a), sin(b)}], []]
Þ Indésirable
Dans cette situation, il n’est également pas possible
d’exprimer l’ensemble des termes qui ne doivent pas apparaître, car cette liste
n’est pas finie. La condition d’arrêt n’est donc vérifiable que par le biais du
calcul, ce qui suppose un opérateur.
Ce point semblerait prendre en défaut notre hypothèse
fondamentale selon laquelle seul le module logique est impliqué dans
l’évaluation d’une situation. Nous maintenons cette hypothèse, en considérant
que la réussite (l’opérateur fournit au moins une opération valide) et l’échec
(l’opérateur ne fournit aucune opération valide) d’un opérateur peuvent être
exprimés au niveau logique, sous la forme :
[[…, Opérateur bloqué, …], []] Þ Modalité
[[…, non Opérateur bloqué, …], []] Þ Modalité
Le jeu d’échecs fournit un exemple de cette situation.
L’objectif est de placer son adversaire en situation de mat. Etre en situation
de mat revient à être en situation d’échec sans avoir de coup légalement
jouable.
L’expression de l’objectif de notre exemple devient alors
(en notant Développe l’opérateur de
développement des formules trigonométriques et Factorise l’opération de mise en facteur) :
[[non Développe bloqué], []] Þ Indésirable
[[non Factorise bloqué], [Développe bloqué]] Þ
Indésirable
L’objectif n’est plus d’obtenir une situation particulière,
mais d’effectuer toutes les opérations possibles de développement, puis de
factorisation. Préciser en fonction de quoi doit s’exprimer le résultat final
de l’exercice n’est donc pas nécessaire, ce que ne faisait effectivement pas
l’énoncé original.
Notre modélisation des objectifs ignore le problème que nous
venons d’évoquer. Notre objectif étant de modéliser un novice, nous avons
décidé d’exprimer les objectifs sous la forme générale :
[[non l’expression contient terme], []] Þ
Indésirable
De fait, notre modèle s’arrête trop tôt dans la résolution
de l’exercice que nous venons d’analyser, en retenant la solution :
cos(a)cos(b)cos(c) – cos(a)sin(b)sin(c) – sin(a)sin(b + c)
Les exercices que nous avons proposés à notre modèle ont
pour énoncé : «exprimer Expression
sous la forme de Liste d’Expressions
Elementaires». Ces exercices sont
issus de [PIC 94], pp. 103-109. Les
expressions peuvent être constituées à partir de :
cosinus(Expression)
sinus(Expression)
produit(Expression, Expression)
somme(Expression, Expression)
différence(Expression, Expression)
carré(Expression)
variable(identifiant)
constante
Nous avons par ailleurs réalisé deux modélisations, une
incluant une pile (les règles s’expriment alors sans menu) et une n’en
utilisant pas. Ainsi, l’énoncé «démontrer que ("x) sin(2x) + 1 =
(cos(x) + sin(x))2» nous donnera deux exercices. Le premier est
«exprimer (cos(x) + sin(x)) 2
en fonction de sin(2x) et d’une
constante», ce qui donne comme situation initiale (var(11) désigne x et i(2) désigne la constante 2):
plus(sinus(produit(i(2),var(11))),i(1))
On obtient comme unique règle d’indésirabilité :
[non l’expression contient carré(somme(sin(x), cos(x))] Þ
Indésirable
La formulation de l’objectif peut paraître étrange, mais
elle est bien équivalente à l’énoncé initial du problème. La règle présentée
ici ne contient pas de menu puisqu’il s’agit du modèle avec pile. La règle du
même exercice dans le modèle sans pile est de menu vide.
L’opérateur utilisé dans cette modélisation est relativement
complexe (toujours présenté sous
la forme (état, action, état)) :
cos(X + Y), développer, cos(X)cos(Y) – sin(X)sin(Y)
cos(X - Y), développer, cos(X)cos(Y) + sin(X)sin(Y)
cos(2X), développer, cos2(X) - sin2(X)
sin(X + Y), développer, sin(X)cos(Y) + sin(Y)cos(X)
sin(X - Y), développer, sin(X)cos(Y) - sin(Y)cos(X)
sin(2X), développer, 2cos(X)sin(X)
(X + Y) 2, développer, X2 + Y2
+ 2XY
cos(X)cos(Y) – sin(X)sin(Y), réduire, cos(X + Y)
cos(X)cos(Y) + sin(X)sin(Y), réduire, cos(X - Y)
cos2(X) - sin2(X), réduire, cos(2X)
sin(X)cos(Y) + sin(Y)cos(X), réduire, sin(X + Y)
sin(X)cos(Y) - sin(Y)cos(X), réduire, sin(X - Y)
2sin(X)cos(X), réduire, sin(2X)
X2 + Y2 + 2XY, réduire, (X + Y) 2
cos2(X) + sin2(X), somme de carré, 1
1 - sin2(X), somme de carré, cos2(X)
1 - cos2(X), somme de carré, sin2(X)
1, somme de carré, sin2(X) + cos2(X)
cos2(X), somme de carré, 1 - sin2(X)
sin2(X), somme de carré, 1 - cos2(X)
X(YZ), associativité, (XY)Z
X + (Y + Z), associativité, (X + Y) + Z
XY, commutativité, YX
X + Y, commutativité, Y + X
On notera la présence d’opérations de très bas niveau, comme
la commutativité ou l’associativité de l’addition et de la multiplication.
Notre modèle n’ayant aucune notion d’arithmétique, nous sommes obligés de lui
indiquer toutes les opérations dont il peut avoir besoin.
Une autre difficulté est apparue au cours de nos
expérimentations. L’ordre des termes passés en entrée de l’opérateur a une
importance. Un sujet humain fait aisément abstraction des inversions entre deux
termes reliés par un opérateur commutatif. Ainsi, dans l’expression (X2 + Y2) + (2Y)X,
l’humain reconnaîtra un développement de (X
+ Y) 2 alors que la formule apprise permettant d’effectuer la
mise en facteur est X2 + (Y2
+ 2(XY)). Notre modèle ne dispose pas de connaissances lui permettant
d’effectuer cette reconnaissance. Il n’est donc pas a priori capable
d’effectuer la transformation de (X2
+ Y2) + (2Y)X vers (X + Y)
2.
Nous pensions que l’introduction de la commutativité et de
l’associativité dans l’opérateur serait suffisant pour résoudre ce problème.
Mais remettre dans un ordre adéquat une telle expression, en appliquant dans un
ordre correct les transformations d’associativité et de commutativité
nécessaires, constitue une suite d’opérations souvent plus longue que la limite
de profondeur de l’opérateur, rendant impossible à notre modèle la sélection de
l’opération à effectuer.
Nous avons ensuite essayé de saisir l’ensemble des
transformations de la formule initiale, mais nous avons également dû renoncer,
car l’augmentation du nombre de définitions élémentaires pour l’opérateur
entraîne une augmentation en puissance du nombre d’opérations à tester pour
détecter qu’aucune combinaison d’opérations élémentaires ne fournit de
situation intéressante. Ce qui était gagné d’un côté (reconnaissance immédiate
d’une mise en facteur) était perdu de l’autre (temps de calcul déraisonnable en
cas d’exploration libre). Finalement, nous avons ignoré ce problème en
présentant les énoncés dans l’ordre permettant une reconnaissance immédiate.
Un dernier problème est enfin apparu, à savoir l’application
d’une transformation à une sous-expression. Ainsi, la transformation de (sin(2x))2 en (2sin(x)cos(x))2 n’est pas
réalisable par le système. Nous avons ajouté les pseudo-opérations suivantes
afin de contourner ce problème :
(X 2, Op, Xtr2) si (X, Op, Xtr)
(XY, Op, XtrY) si (X, Op, Xtr)
(XY, Op, XYtr) si (Y, Op, Ytr)
Ces pseudo-opérations ne sont bien sûr pas décomptées vis à
vis des différentes limites d’exploration.
Le fonctionnement du modèle avec pile est identique au
fonctionnement de l’application de résolution de la tour de Hanoï. Nous allons
maintenant examiner le fonctionnement du modèle sans pile.
Nous ne prenons pas en compte dans notre modélisation la
valeur de l’information conversationnelle pour les règles d’indésirabilité.
Afin d’assurer que la production contre-factuelle s’effectue quand même sur
l’indésirabilité courante, le module logique choisit la dernière règle
mémorisée pour effectuer cette production. La structure de pile se trouve alors
reconstituée, ce que nous désirions au départ éviter. Cependant, ce point ne
pose en fait pas de problème.
Ignorer l’information conversationnelle revient à ne pas
disposer de règle d’indésirabilité courante. La condition de validation d’une
situation proposée par l’opérateur est alors de diminuer strictement le nombre
de règles d’indésirabilités saturées. Une situation proposée par l’opérateur au
cours de l’exploration libre sera validée si cette nouvelle situation ne sature
pas plus de règles que la situation précédente. Dans ces conditions, l’ordre
des règles ne joue pas de rôle dans la phase exploratoire de la résolution, et
comme nous l’avons vu au chapitre 6, la dernière règle mémorisée est
nécessairement celle de plus forte valeur d’information conversationnelle.
Nous verrons au paragraphe suivant, consacré à la
mémorisation, que notre choix n’a pas non plus d’influence sur les résolutions
suivantes du même exercice, compte tenu de la relative facilité avec laquelle
les problèmes choisis pour effectuer notre expérimentation se résolvent.
7.3.2.1 Exemple de résolution
A titre d’exemple de résolution, nous allons considérer
l’exercice «exprimer sin(2x) + 1
sous la forme d’un carré d’une somme de sinus x et de cosinus x» (énoncé
original : «montrer que, pour tout x, sin(2x)
+ 1 = (sin(x) + cos(x))2»). L’objectif se traduit sous la
forme :
[[non l’expression est un carré de somme de sinus de x et de
cosinus de x], []] Þ Ind.
(1)
La situation initiale est :
plus(sin(mult(i(2),v(11))),i(1))
soit sin(2x) +1
La résolution donne (EG (exploration guidée)
désigne un coup (ou une suite de coups) validé par le module logique ; EL désigne
un coup choisi par exploration libre ; PCF désigne une
production contre-factuelle) :
plus(sin(mult(i(2),v(11))),i(1)) soit
sin(2x) +1
EL :
sin(2a) = 2cos(a)sin(a)
plus(mult(i(2),mult(cos(v(11)),sin(v(11)))),i(1)) 2(cos(x)sin(x)) + 1
EL :
(xy)z = x(yz)
plus(mult(mult(i(2),cos(v(11))),sin(v(11))),i(1)) (2cos(x))sin(x) + 1
EL : xy
= yx
plus(mult(sin(v(11)),
mult(i(2),cos(v(11)))),i(1)) sin(x)(2cos(x))
+ 1
PCF : (l’expression contient un carré de somme de
sinus x et de cosinus x, vrai)
Opération :
x2 + y2
+ 2xy = (x + y) 2
Sous-but : sin2(x) (on
se limite au premier élément non encore atteint)
Nouvelle règle :
[[non l’expression contient un carré de sinus x], [(1)]] Þ Ind.
EG : cos2(a)
+ sin2(a) = 1
plus(mult(sin(v(11)),
mult(i(2),cos(v(11)))),plus(carre(sin(v(11))),carre(cos(v(11)))))
sin(x)(2cos(x))
+ sin2(x) + cos2(x)
EL :
(xy)z = x(yz)
plus(mult(mult(sin(v(11)), i(2)),
cos(v(11))),plus(carre(sin(v(11))),carre(cos(v(11)))))
(sin(x)*2)cos(x)
+ sin2(x) + cos2(x)
EL : xy
= yx
plus(mult(cos(v(11)), mult(sin(v(11)),
i(2))),plus(carre(sin(v(11))),carre(cos(v(11)))))
cos(x)(sin(x)*2)
+ sin2(x) + cos2(x)
EL :
(xy)z = x(yz)
plus(mult(mult(cos(v(11)),
sin(v(11))), i(2)),plus(carre(sin(v(11))),carre(cos(v(11)))))
(cos(x)sin(x))*2
+ sin2(x) + cos2(x)
PCF : (l’expression contient un carré de somme de
sinus x et de cosinus x, vrai)
Opération :
x2 + y2
+ 2xy = (x + y) 2
Sous-but : 2sin(x)cos(x) (1er élt non atteint, sin2x et cos2x
déjà dans l’expr)
Nouvelle règle :
[[non l’expr. contient un produit de constante et de
produit de sinus x et de cosinus x], [(1)]] Þ Ind.
EL : xy
= yx
plus(mult(i(2),mult(cos(v(11)),sin(v(11)))),
plus(carre(sin(v(11))),carre(cos(v(11)))))
2(cos(x)sin(x))
+ sin2(x) + cos2(x)
EG : xy
= yx puis (x + y)2 = x2 + y2 + 2xy
plus(mult(i(2),mult(sin(v(11)),cos(v(11)))),
plus(carre(sin(v(11))),carre(cos(v(11)))))
2(sin(x)cos(x))
+ sin2(x) + cos2(x)
carre(plus(sin(v(11)),cos(v(11)))) (sin(x) +
cos(x)) 2
Chaque production contre-factuelle donne lieu à la création
d’une règle d’indésirabilité. L’ensemble des règles d’indésirabilités est
mémorisé en fin de résolution en vue de résolutions ultérieures. Les règles
d’indésirabilité mémorisées sont donc :
[[non l’expression est un carré de somme de sinus de x et de
cosinus de x], []] Þ Ind.
(1)
[[non l’expression contient un carré de sinus x], [(1)]] Þ Ind.
[[non l’expr. contient un produit de cste et de produit de sin
x et de cos x], [(1)]] Þ
Ind.
Nous allons maintenant examiner l’influence de la
mémorisation sur une résolution ultérieure.
7.3.2.2 La mémorisation
Les règles d’indésirabilité apprises à la première
résolution d’un exercice sont fournies en entrée à notre modèle lors des
résolutions suivantes. Notre hypothèse, défendue au chapitre 6, est que cela
est suffisant pour obtenir une résolution plus aisée par le biais d’une
planification partielle. Sur l’exemple que nous venons de traiter, les règles
d’indésirabilité sont :
[[non l’expression est un carré de somme de sinus de x et de
cosinus de x], []] Þ Ind.
(1)
[[non l’expression contient un carré de sinus x], [(1)]] Þ Ind. (2)
[[non l’exp. contient un produit de cte et de produit de sin x
et de cos x],[(1)]]Þ Ind.
(3)
La situation initiale est :
plus(sin(mult(i(2),v(11))),i(1)) soit sin(2x) +1
La résolution donne (EG (exploration guidée)
désigne un coup (ou une suite de coups) validé par le module logique) :
EG : cos2(a)
+ sin2(a) = 1 (résolution de (2))
plus(sin(mult(i(2),v(11))),plus(carre(sin(v(11))),carre(cos(v(11)))))
sin(2x) + sin2(x) + cos2(x)
EG :
sin(2a) = 2sin(a)cos(a) puis xy = yx (résolution de (3))
plus(mult(i(2),mult(cos(v(11)),sin(v(11)))), plus(carre(sin(v(11))),carre(cos(v(11)))))
2(cos(x)sin(x)) + sin2(x) + cos2(x)
plus(mult(i(2),mult(sin(v(11)),cos(v(11)))),
plus(carre(sin(v(11))),carre(cos(v(11)))))
2(sin(x)cos(x)) + sin2(x) + cos2(x)
EG : (x
+ y)2 = x2 + y2 + 2xy (résolution de (1))
carre(plus(sin(v(11)),cos(v(11)))) (sin(x) + cos(x)) 2
On note que la résolution ne comporte plus ni exploration
libre ni production contre-factuelle : la résolution devient déterministe
dès la seconde résolution. Il faut toutefois reconnaître que l’exercice se
résout facilement (trois opérations si on ignore la commutativité de la
multiplication).
On vérifie également que dans l’exemple traité, le choix
d’ignorer la valeur de l’information conversationnelle ne modifie pas la
résolution de l’exercice d’un point de vue qualitatif. Seul l’ordre entre les
applications de cos2(a) + sin2(a) = 1 et de
sin(2a) = 2sin(a)cos(a) puis
xy = yx sera éventuellement modifié.
Dans la version que nous utilisons, les règles ayant toutes
la même valeur d’information conversationnelle, c’est l’opérateur qui va
déterminer laquelle sera résolue en premier. Comme (2) ne nécessite qu’une
opération pour être résolue, c’est elle qui est traitée en premier.
Dans une modélisation où la valeur d’information
conversationnelle serait prise en compte, c’est la règle de plus forte valeur
d’information conversationnelle qui serait traitée en premier. Cela peut
inverser l’ordre de traitement de (2) et de (3). Dans les deux modélisations,
(1) est traité en dernier, puisque (2) et (3) sont des prérequis à sa
réalisation. En outre, la valeur d’information conversationnelle de (1) est
supérieure à celles de (2) et de (3), comme nous l’avons montré au chapitre 6.
Enfin, les résolutions de (2) et de (3) sont indépendantes
l’une de l’autre puisqu’elles ne font pas appel à la même partie de l’état
initial du problème. La résolution globale de l’exercice ne dépend pas de
l’ordre dans lequel on résout (2) et (3).
Nous noterons cependant que la simplification introduite
dans notre modèle ne perturbe pas la résolution uniquement parce que l’exercice
à résoudre est simple. Si l’exercice nécessitait une profondeur de
sous-objectif de deux ou plus, il ne serait plus possible d’obtenir une
modélisation correcte sans utiliser l’information conversationnelle. Une
modélisation correcte de l’évolution de cette valeur, et donc un travail de
recherche supplémentaire, est nécessaire avant de pouvoir modéliser
correctement le comportement de sujets humains en situation de résolution de
problème.
Des applications utilisant notre modèle sont cependant
immédiatement réalisables en utilisant le modèle avec pile, erroné mais
fonctionnel. On trouvera les énoncés des exercices de trigonométries utilisés
dans cette étude en Annexe C.
