Rappel: l'érgativité c'est une propriété d'une langue de marquer de la meme manière le sujet d'un verbe intransitif et l'objet d'un verbe transitif. C'est simple à dire, très complexe à comprendre, c'est pourquoi c'est fascinant.
Pour mieux fixer les idées, prenons un exemple simpliste en marquant A le sujet d'un verbe transitif et B le reste:
le chat-B mange
le chat-A mange la souris-B
Il existe différente manière de réaliser
Il existe plusieurs langues naturelles qui possèdent cette propriété à différents degrés. Qui réalisent ce marquage de différentes facon, le plus souvent pas l'usage de cas: changement de la terminaison d'un mot, dont un cas peut ou non etre marqué ou les deux. Mais cela peut également etre marqué par la position par rapport au verbe.
Bref, la question que j'aborde dans ce post est: qu'est ce que l'érgativité dans les languages informatique peut nous apporter sur le compréhension de cette notion.
Et plus particulièrement: quels seraient les equivalents en langage de programmation de la notion d'érgativité dans les langues naturelles? Et qu'est ce que cela peut nous apprendre sur celles-ci?
Pour mieux fixer les idées, prenons un exemple simpliste en marquant A le sujet d'un verbe transitif et B le reste:
le chat-B mange
le chat-A mange la souris-B
Il existe différente manière de réaliser
Il existe plusieurs langues naturelles qui possèdent cette propriété à différents degrés. Qui réalisent ce marquage de différentes facon, le plus souvent pas l'usage de cas: changement de la terminaison d'un mot, dont un cas peut ou non etre marqué ou les deux. Mais cela peut également etre marqué par la position par rapport au verbe.
Bref, la question que j'aborde dans ce post est: qu'est ce que l'érgativité dans les languages informatique peut nous apporter sur le compréhension de cette notion.
Et plus particulièrement: quels seraient les equivalents en langage de programmation de la notion d'érgativité dans les langues naturelles? Et qu'est ce que cela peut nous apprendre sur celles-ci?
Revoyons d'abord un peut plus en détails ce qui se passe dans les langues naturelles:
* quand le verbe se passe par défaut d'acteur, le complément précise celui qui controlle le processus
le plat cuit
le chef cuit le plat
ou il peut s'exprimer par tournure reflexive:
le plat se cuit
ou il peut s'exprimer de manière factitive
le chef fait cuire le plat
* quand le verbe se passe par défaut d'objet, le complément précise l'objet précise qui subit le processus
le chef cuisine
le chef cuisine le plat
la tournure reflexive ne marche pas:
le chef se cuisine (le sens est différent: le chef ne cuisine pas un plat, mais lui meme)
la tournure factitive ne marche pas:
le chef fait cuisiner le plat (le sens est different: ce n'est pas le chef qui cuisine, mais qqun d'autre)
Donc le "truc" de l'érgativité n'as pas avoir avec les marqueurs des cas, mais avec la nature des verbes.
Voyons à présent quels pourraient en etre les équivalent dans les langages informatiques:
= le verbe cuire
* en version predicative (logique), impérative (programmation) :
le numero ou le nom de la position sert à marquer le cas
cuire(quoi="plat") : predicat
cuire(quoi="plat", qui="chef") : le plus naturel, l'argument optionel est en deuxieme position
cuire(qui="chef", quoi="plat")
* en version objet:
. et () servent ici à marquer les cas
lequel est correct est une question d'interpretation:
- correct si avant le . est indiqué l'acteur:
chef.cuire() : le chef fait cuire qqchose
chef.cuire(plat)
- correct si avant le . est ce qui subit le processus de cuison
plat.cuire() : le plat cuit
plat.cuire(chef)
Une vrai transposition de la grammaire langue nat // marqueurs serait:
Langue nomitaive-accusative:
chef.cuit()
chef.cuit(plat)
[ ou, de manière extremement inhabituelle mais pas de manière inconcevable:
(plat)cuire
(plat)cuire.chef ]
langue érgative-absolutive:
plat.cuit()
chef.cuit(plat)
ou
(plat)cuire
(chef)cuire.plat
autre représentation:
cuire(x="plat", y="chef") : predicatif
y="chef".cuire(x="plat") : objet nominatif-accusatif
y="plat".cuire(x="chef") : objet ergatif-absolutif
= le verbe cuisiner
cuisine(chef) : prédicat
cuisine(chef, plat) : le plus naturel, l'argument optionel est en deuxième position
cuisine(plat, chef) : moins naturel, les arguments se rajoutent en file
chef.cuisine(plat) : objet
lequel est correct est une question d'interpretation:
chef.cuisine() : le chef cuisine
plat.cuisine() : le plat est cuisiné
"chef".cuisine(?) : le chef cuisine qqchose
?.cuisine("plat") : qqun cuisine le plat
Donc les acteurs et objets du verbe, comment on les marque en langue naturelle et comment on les exprime en langue logique ou informatique, dependent totallement du sens fondamental de ce verbe, pas que de sa transitivité, mais plutot du fait que celui-ci indique un acteur ou subisseur naturel, un changement d'état ou non.
C'est comme si certain verbe exprimaient natrellement un acteur ou un objet, et que donc naturellement le complement le plus direct du sens à ce verbe, sera d'exprimer respectivement l'objet ou l'acteur manquant par défaut.
x cuit => (Acteur=?, Objet=x)
x cuisine => (Acteur=x, Objet=?)
x cuit y => (Acteur=x, Objet=y)
x cuisine y => (Acteur=x, Objet=y)
de ce point de vue la on peut dire qu'un verbe ergatif dans une langue marquant le cas par position par rapport au verbe, inverse la position entre les cas intransitif/transitif, tandis qu'un verbe non ergatif (noté ici "nominatif") ne l'inverse pas.
noté de manière prédicative cela serait équivalent à:
predicat_ergatif(x)
predicat_ergatif(y, x)
predicat_nominatif(x)
predicat_nominatif(x, y)
* en mathématiques
"-" est un opérateur unaire et binaire, notons le "minus"
minus(x) : -x
minus(x,y) : x - y
ici le role de l'argument x est inversé dans la version binaire par rapport à la version unaire: en unaire, x est retiré à un 0 qui n'est pas représenté, tandis qu'en binaire on retire de x. Cela ressemble à un construction ergative du predicat "minus".
