Je me dis souvent que j'aimerais avoir un tas de cobayes humains
pour faire toutes sortes d'expériences cognitives dessus (et pas que
des sciences cognitives, d'ailleurs : j'aimerais aussi faire toutes
sortes d'expériences sociales, ou simplement de sondages sur un
échantillon représentatif de la population française).
Malheureusement, je ne suis pas un savant fou qui aurait des centaines
de sujets d'expérience prisonniers dans sa cave, je n'ai pas non plus
les accréditations (ou encore moins la patience) pour demander les
financements permettant de monter des expériences dans des conditions
scientifiques, alors je ne peux que lancer les idées en l'air en
soupirant ce serait bien de faire ce genre d'expérience
et
spéculer de façon totalement gratuite sur le résultat (et me dire au
passage que l'avantage des mathématiques sur d'autres domaines
scientifiques, c'est quand même qu'on n'a pas besoin d'avoir des
objets d'expérience prisonniers dans sa cave, dans une boîte de Petri
ou dans un synchrotron à 10 giga-euros). Zut, je suis encore en train
de digresser.
Une expérience que j'aimerais bien mener, donc, c'est d'essayer de mesurer le temps que le cerveau prend pour évaluer des fonctions booléennes (je vais expliquer dans un instant ce dont il s'agit) et essayer de modéliser la manière dont il s'y prend. Notamment : est-ce que ce temps dépend fortement des individus, est-ce qu'il dépend fortement de la fonction évaluée, à quelle vitesse « apprend-on » une fonction booléenne (c'est-à-dire, à quelle vitesse en acquiert-on un automatisme) et cette acquisition est-elle dépendente de la manière dont les entrées de la fonction sont présentées. Et aussi : dans quelle mesure est-ce que les animaux peuvent apprendre des fonctions un peu complexes.
Je m'explique.
Voici un premier jeu d'expériences imaginables. Commençons par
l'expérience la plus triviale qui soit, et qui peut servir de mesure
de base à laquelle comparer les autres : le sujet a une lumière
devant lui et un bouton. Toutes les secondes (disons), la lumière va
aléatoirement passer dans l'état « éteint » ou « allumé » : le sujet a
pour mission d'appuyer sur le bouton si la lumière est allumée. Cette
tâche est extrêmement simple, et il est à prévoir qu'on y arrive très
rapidement (au niveau du temps de réflexe), et avec très peu
d'erreurs : il peut cependant être intéressant de faire varier
certains paramètres (lumière qui peut prendre deux couleurs au lieu
d'être éteinte/allumée, deux boutons entre lesquels il faut choisir,
cadencement choisi par le sujet au lieu d'être à vitesse fixe, que
sais-je encore). Maintenant, l'idée serait de mettre plus de lampes
et de demander au sujet de réagir selon des conditions plus complexes.
Une telle condition est appelée fonction booléenne
.
Par exemple : s'il y a deux lampes, on peut demander au sujet
d'apuyer sur le bouton si la lampe de gauche est allumée ; ou si les
deux le sont ; ou si l'une des deux l'est ; ou si la lampe de gauche
est éteinte ; ou encore : si la lampe de gauche est
allumée ou que celle de droite est éteinte. En tout, il y
aurait 16 fonctions booléennes à tester sur 2 lampes, même si
certaines n'ont aucun intérêt (demander d'appuyer à tous les coups sur
le bouton n'est pas franchement passionnant) et d'autres peuvent
certainement être regroupées pour des raisons de symétrie (je doute
qu'on réagisse plus rapidement ou plus fiablement à des conditions
portant sur la lampe de gauche qu'à celles sur la lampe de droite ou
vice versa). J'imagine qu'on aurait beaucoup plus de facilité à
exécuter rapidement et fiablement la tâche appuyer sur le bouton si
l'une ou l'autre lampe est allumée
que appuyer sur le bouton si
la lampe de gauche est allumée ou la lampe de droite éteinte
, mais
ce qui m'intéresse, entre autres, est de quantifier cette différence
et d'essayer de modéliser ce qui rend certaines tâches plus faciles
que d'autres. Il faudrait savoir, aussi, si le temps dépend de la
manière dont on a formulé la phrase (pour des fonctions booléennes
équivalentes) : est-il plus facile de appuyer sur le bouton si la
lampe de gauche est allumée et la lampe de droite éteinte
ou de appuyer sur le bouton si la lampe de gauche est
allumée sauf si la lampe de droite l'est aussi
? Et si
on donne les instructions sans mots mais avec autant d'exemples que
nécessaire ?
Sur un plus grand nombre de lampes, je suis tout à fait certain
qu'on irait beaucoup plus vite sur les tâches qui s'expriment très
simplement avec des nombres, par exemple appuyer sur le bouton si
au moins trois lampes sont allumées
, mais il serait intéressant de
comparer avec d'autres tâches d'assez basse complexité booléenne,
notamment des fonctions positives, du genre appuyer sur le bouton
si l'une des deux lampes de gauche est allumée et que l'une
des deux lampes de droite l'est
(mettons qu'il y en ait quatre au
total). Une fonction booléenne est dite positive lorsque
le fait de changer une de ses variables de fausse à vraie (i.e.,
allumer une lampe) ne peut pas rendre faux le résultat (i.e., faire
qu'on ne doive plus appuyer sur le bouton) : a-t-on globalement plus
de facilité à calculer de telles fonctions que pour des fonctions qui
peuvent comporter des négations ?
Mais bien sûr, il ne faut pas se contenter d'expérimenter avec des
lampes (allumées/éteintes) et des boutons. Je voudrais aussi savoir,
notamment, comment le temps de réponse est affecté si les entrées de
la fonction booléenne sont hétérogènes : si je demande au sujet
d'appuyer sur un bouton si on lui présente une forme qui est un
carré ou qui est rouge, est-ce que la différence de temps de
réaction par rapport à juste détecter un carré ou juste détecter du
rouge est comparable à celle qu'on aurait mesuré pour la fonction
booléenne ou
à deux lampes ? Et pour une tâche du
genre appuyer sur le bouton si la forme de gauche est un carré ou
qu'elle est rouge, et que la forme de droite est un triangle
ou qu'elle est bleue
, est-ce que le fait de s'être préalablement
entraîné à exécuter la tâche appuyer sur le bouton si l'une des
deux lampes de gauche est allumée et que l'une des deux
lampes de droite l'est
va fournir un avantage ? Autrement dit,
notre cerveau est-il capable de précompiler des fonctions booléennes
polymorphes ? ou bien chaque fonction est-elle apprise uniquement
pour une situation bien précise et non réutilisable ? Et si je fais
subir au même cobaye des mois et des mois de tâches différentes
toujours avec la même fonction booléenne ([x
ou y] et [u ou v]
),
va-t-il quand même finir par en acquérir un automatisme ?
Le nombre de questions que je me pose est très élevé, je ne vais pas toutes les écrire parce que ce serait assez fastidieux, d'autant que certaines dépendent de résultats des expériences antérieures, mais vous voyez le genre d'idées.
Pourquoi est-ce que je m'intéresse à ça ? Parce que j'ai l'impression que je me retrouve régulièrement à exécuter des tâches de ce genre : fouiller mentalement ou visuellement dans un ensemble d'items pour trouver ceux qui remplissent certains critères exprimés comme combinaisons booléennes d'autres critères, et je trouve qu'il y a décidément une certaine fatigue mentale spécifique associée à ce travail.
Mais je pense aussi à un type particulier de tâches : l'application des règles de grammaire. En écrivant cette entrée, j'ai commencé ici une longue digression sur l'inflexion des adjectifs dans les langues germaniques : finalement, je l'ai coupée et j'en ferai sans doute une entrée séparée qui n'intéressera personne, mais voici juste l'exemple de la règle (un peu simplifiée) permettant de savoir si on doit mettre la désinence -e (la seule possible) sur un adjectif en néerlandais : on ajoute cette désinence lorsque l'adjectif est épithète et que le nom qualifié est non-neutre ou pluriel ou précédé de l'article défini. (A contrario, ceci signifie qu'on ne met pas la désinence lorsque l'adjectif est attribut ou que le nom est neutre singulier précédé de [l'article indéfini ou d'une absence d'article].) Ce n'est pas une fonction booléenne terriblement compliquée (c'est en tout cas beaucoup plus simple que la multitude de cases à envisager en allemand ou en islandais, et c'est aussi un peu plus simple que la règle correspondante pour le danois ou le suédois), mais pour parler une langue à une vitesse raisonnable, il faut arriver à calculer ce genre de fonctions très efficacement et de façon complètement automatique (i.e., sans y réfléchir consciemment) : et avant que l'automatisme s'installe, ce qui demande énormément de pratique, on passe par une longue phase assez fastidieuse où chaque utilisation d'un adjectif implique une petite gymnastique mentale (est-ce que mon adjectif est épithète ? est-ce qu'il y a un article ? est-ce que cet article est défini ? est-ce que le nom est neutre ?). Je trouve qu'il serait intéressant de faire des expériences sur des gens n'ayant aucune connaissance préalable du néerlandais du temps nécessaire pour appliquer cette règle booléenne.
Bon, souvent, quand on considère les règles de grammaire, il ne s'agit plus tellement de fonctions booléennes au sens strict, c'est-à-dire que les entrées de la fonction ne sont plus obligatoirement de nature vrai/faux, mais peuvent être dans des ensembles de valeurs un petit peu plus gros, comme les trois genres — masculin, féminin et neutre — ou les quatre cas grammaticaux — nominatif, accusatif, datif et génitif — de l'allemand. Bien sûr, cette distinction est un peu byzantine, mais je pense en revanche qu'il y a une vraie distinction à faire, dans le processus mental, entre d'une part les fonctions booléennes ou « presque », avec des entrées qui prennent deux ou un petit nombre de valeurs possibles, et d'autre part des tableaux morphologiques comme des tables de conjugaison ou de déclinaison.
Si je m'écarte un peu des fonctions booléennes ou à petites entrées finies considérées ci-dessus, on pourrait aussi regarder les automates finis simples. Je pense par exemple à l'exercice mental que constitue la lecture d'une portée musicale avec beaucoup d'altérations (:= dièzes et bémols) et de changements d'altérations : la convention d'écriture est que la portée porte un certain nombre d'altérations « par défaut », et que chaque fois qu'une modification est faite, elle vaut pour la mesure en cours jusqu'à la fin de celle-ci : on peut voir ça comme l'application d'un automate fini, et il serait intéressant de mesurer la rapidité à laquelle on arrive à effectuer cette tâche sans entraînement préalable.
Bon, je devrais sans doute écrire des pages JavaScript qui proposent toutes sortes d'exercices dans ce genre et qui mesurent le temps et la fiabilité des réponses — comme ça, à défaut d'avoir des cobayes sur lesquels tester, je pourrais au moins me tester moi-même.