Même si nous n'en sommes pas encore arrivé là, une grande question se pose concernant la création de règles grammaticales visant à détecter les erreurs.
Vaut-il mieux écrire des règles d'erreurs, c'est-à-dire décrire toutes les erreurs possibles, ou vaut-il mieux décrire ce  qui est juste, c'est-à-dire faire des règles de la grammaire telle qu'elle devrait être (grammaire prescriptive)?
Si la phrase colle avec une règle, c'est qu'il y a une faute. Dans le deuxième, si la phrase ne colle avec aucune des règles, c'est qu'il y a une faute.

Cas 1: Règles d'erreurs:
Exemple: Nfem sing + Adj fem plur = erreur
La génération de règles d'erreurs serait infinie. Il semble impossible ou du moins bien limité de pouvoir décrire toutes les fautes imaginables dans la langue. Cette méthode à l'avantage  de ne créer que peu ou pas de bruit, mais laisse des silences, des fautes seront oubliées.
Le bruit est la génération de "fausses fautes", c'est-à-dire que des mots justes seront détectés comme étant faux. Le silence correspond à des fautes qui ne sont pas détectées.
Dans ce cas donc, on peut dire que lorsque l'on détecte une faute, on peut être sûr que c'est une "vraie faute", mais on ne peut pas toutes les détecter.

Cas 2: Règles prescriptives
La génération de règles dites préscriptives, qui décrivent la grammaire "correcte" serait peut être moins longue mais apporterait énormément de bruit puisque tout ce qui ne correspondra pas à ce qui a été décrit comme "juste", tout ce qui ne correspondra à aucune règle, sera faux.
Cette méthode pourrait donc proposer des mots faux alors qu'ils sont justes. Il faut penser à l'utilisateur, cela peut être gênant qu'on nous dise que l'on a fait une erreur alors que ce n'est pas le cas.

En résumé:
   - règles d'erreurs:
         règles infinies
         peu de bruit, mais du silence.
   - règles prescriptives:
        moins de règles
        mais beaucoup de bruit

Je ne sais pas si j'ai été claire, mais nous reviendrons sur cette question...

Gramadóir ( http://borel.slu.edu/gramadoir/ ) est un correcteur grammatical développé pour le gaélique, en Perl par Kevin P. Scannell. D'autres versions sont disponibles ou en cours d'élaboration pour d'autres langues "minoritaires" telles que le wallon, le gallois, le breton,  le norvégien, le tagalog, etc.
L'entrée de Gramadóir est une liste de mots étiquetés, avec une ligne par forme, même pour les mots ambigüs. Par exemple:
couvent: N masc sing
couvent: V 3ème pers plur ind présent

A partir de cette liste, après avoir découpé le texte à traiter en phrases et en mots, il tagge les mots. Puis il les désambiguïse à l'aide de règles. Puis, grâce à des règles grammaticales construites à partir de tags et d'expressions régulières, il détecte les erreurs grammaticales. Il retourne la phrase à l'utilisateur, avec la séquence fausse en rouge en suggérant par exemple:
forme non conforme, utilisez plutôt /scata/.

Le programme principal est gram-xx.pl (xx étant le code ISO 639-1 pour le pays).

Les trois fichiers de bases de règles sont:

• Comhshuite-xx.in : Chunking

• Aonchiall-xx.in : Désambiguïsation des POS tags à partir de règles.

• Rialacha-xx.in : Règles d'erreurs de grammaire, et exceptions.

Toutes les fonctions Perl utilisées sont décrites dans le programme Gramadoir.pm.

Afin de corriger des fautes de grammaire, un pré-traitement efficace du texte est indispensable. En effet, pour reconnaitre une faute d'accord entre un nom et son adjectif par exemple, il faut avoir détecté sans erreur que tel mot est un nom et tel mot est un adjectif. Ceci est la phase de tagging. Il s'agit de donner une étiquette morpho-syntaxique à chaque mot. Et il ne suffit pas seulement d'étiqueter avec "nom" ou "adjectif", mais il est nécesaire d'inclure des traits comme genre (féminin, masculin) et nombre (singulier, pluriel) qui permettront de détecter que si l'adjectif est au masculin et que le nom est au féminin, il y a une faute d'accord.
Cette étape de tagging est la base du traitement pour une analyse grammaticale. Elle est indispensable et de sa qualité et ses résultats dépendront la rédaction des règles de détection d'erreurs.
De plus, en français, de nombreux mots peuvent être ambigüs, il est donc important de bien les traiter pour ne pas fausser la détection d'erreurs.

Maxime Biais dévelloppe actuellement Grac, un correcteur grammatical indépendant d'une langue particulière et programmé en Python.

Grac nécessite une phase d'apprentissage, afin de créer une base de connaissances probabiliste et une base de règles de grammaire. Il faut donc un corpus étiqueté et un corpus ne contenant aucune erreur grammaticale.

On découpe le texte en phrases et en mots. On traite le texte avec un tagger afin d'étiqueter les mots non ambigus. Puis on utilise un système de probabilités basé sur des enchaînements de trois tags possibles pour étiqueter les mots ambigus. Les enchaînements possibles sont contenus dans une base.

Ensuite, on passe par deux phases de détection d'erreurs grammaticales (GDE). La première est la phase d'apprentissage qui se base sur un corpus étiqueté, sans erreur de grammaire pour créér des règles qui sont une liste de TAG probables. La deuxième phase se base sur ces règles pour déterminer les erreurs. Quand on applique ces règles au texte à traiter, si aucune ne correspond, c'est qu'il y a une faute.

Grac ne possède pas encore de documentation très détaillée car il est encore en cours de dévelloppement.

Les parties GED ne sont à l'heure actuelle pas encore développées.

Le programme de Languagetool se divise en plusieurs modules python: SentenceSplitter, Tag, tagger, chunk, Check, rules... TextChecker est le programme principal.  On peut télécharger la dernière version du package à l'adresse : http://sourceforge.net/cvs/?group_id=110216.
Les règles sont décrites en XML dans les fichiers grammar.xml, words.xml et false_friends.xml (tous trois précédés de en, hu, ou de selon qu'il s'agit de l'anglais, du hongrois ou de l'allemand). Les règles décrites pour l'anglais corrigent surtout des fautes de proximité orthographique ou phonétique telle que there au lieu de their, us/use, no/now, etc.
Ces règles sont précises et permettent de traiter beaucoup de fautes, mais nécessiteraient d'être affinées, notamment celles qui concernent les accords sujet/verbe qui ne sont pas toujours traités justement. Quoi qu'il en soit, elles pourront servir de modèle à l'écriture de règles propres à la grammaire française.

Nous n'avons pas encore décidé quel correcteur sera le mieux adaptable au français, mais une certitude selon moi est que pour faire un bon outil, il nous faut une analyse syntaxique complète : découpage en formes, tagging (c'est-à-dire étiquetage morphosyntaxique), chunking (découpage en syntagmes verbaux, nominaux etc.).
Des outils de tagging existent. Certains sont probalilistes, d'autres basés sur des règles (par exemple WinBrill) et d'autres, comme celui de languagetool combinent règles et probabilités.
Winbrill, créé par Eric Brill est un bon étiquetteur dont on pourra s'insirer.
Nous aurons également besoin d'un corpus étiqueté du français pour la phase d'apprentissage du tagger. De la finesse des tags dépendra la qualité du traitement et donc du correcteur.

Languagetool est un correcteur de style et de grammaire pour l'anglais créé par Daniel Naber. Il est écrit en Python.
C'est un système « rule-based », c'est-à-dire basé sur des règles syntaxiques écrites à la main.
Il procède à plusieurs étapes d'analyse grammaticale.
Il faut découper le texte en phrases, puis à chaque espace pour obtenir une liste de mots. Il étiquette ces mots (phase de tagging), puis il découpe en syntagmes (chunks) c'est-à-dire des groupes nominaux, verbaux etc. Ensuite, il applique des règles écrites en XML.
Le tagging est basé sur des probabilités et des règles. Il créé deux tableaux associatifs. Le premier expose le mot, son étiquette (c'est-à-dire sa catégorie grammaticale et des informations morphologiques) et la probabilité qui correspond au tag. Le deuxième montre une suite de deux tags avec la probabilité correspondant à cette séquence (par exemple sequence [(DET, AJ0)] = 0,1] signifie que la probabilité qu'un adjectif suive un déterminant est de 0,1).
Plusieurs mots peuvent être ambigus, on prend alors une suite une séquence de trois mots et on regarde les probabilités que ces trois mots se suivent (par exemple qu'un déterminant soit suivit d'un nom et d'un adjectif) et on sélectionne la plus haute probabilité. On avance d'un mot et on continue le traitement.
Daniel Naber ajoute une phase à son tagger probabiliste. Si le résultat du tagger n'est pas correct et des mots nécessites d'être désambiguïsés, des règles écrites manuellement sont appliquées.
Ensuite vient la phase de chunking qui est basée sur des règles. Par exemple, un NP (noun phrase c'est-à-dire un syntagme nominal) se compose d'un déterminant et d'un nom.
Enfin vient la phase de grammaire basée sur de règles XML. Ces règles sont dépendantes des étiquettes. Elles se composent de plusieurs éléments :
- id et name qui sont l'identifiant et le nom de la règle
- pattern qui décrit ce qui est incorrect,
- message qui est l'énonciation de la règle et qui est destiné à l'utilisateur, et
- example qui est l'exemple de l'erreur.
On a par exemple une règle d'accord sujet verbe.

Je suis nouvelle stagiaire chez Nuxeo/Indesko. J'ai commencé hier à travailler pour le projet qui vise à développer un correcteur grammatical pour la suite de OpenOffice.org. C'est un gros projet qui lorsqu'il sera mené à bien sera très utile et très utilisé je pense! Mais il n'en est qu'à son commencement, il ne faut pas prendre ce qui suit pour définitif.

Plusieurs correcteurs existent déjà dans différentes langues, nous en avons retenu trois pour nous servir de modèles : GRAC, languagetool et Gramadóir.

Grac, « GRAmmar Checker », (http://grac.sourceforge.net/) est développé en Python par Maxime Biais. Il est basé sur un algorithme d'apprentissage, et se veut indépendant d'un langage particulier. C'est un modèle probabiliste. Ce projet en est à son tout début.

Languagetool, de Daniel Naber (http://www.danielnaber.de/languagetool/), également programmé en Python, est un correcteur de grammaire et de style pour l'anglais, basé sur un système de règles (une quarantaine). Le traitement s'effectue en plusieurs phases:

• découpage en phrases

• tagging qui est l'étiquetage des mots (ex: N, V, ADJ, ...)

• découpage en chunks, c'est-à-dire en propositions (ex: syntagme nominal, syntagme verbal, ...)

• application de règles écrites à la main.

Gramadóir est un correcteur gaélique développé en Perl par Kevin P. Scannell (http://borel.slu.edu/gramadoir/). Il est basé sur des règles et sur le « pattern matching ». Il se compose de plusieurs « filtres » qui découpent en mots, les étiquettent, recherchent les erreurs grammaticales etc.

Une fois l'étude de ces trois correcteurs terminée, il nous faudra ensuite choisir celui qui sera le mieux adaptable au français pour l'étendre aux règles grammaticales françaises. L'objectif final reste son insertion dans OpenOffice.org (tout en restant disponible pour d'autres projets).