Révisions

Table of Contents

Composants d'une méta-grammaire

Composants d'une méta-grammaire

Une méta-grammaire est organisée en une hiérarchie de classes, les classes servant à exprimer des contraintes sur une phénomène syntaxique (ou une facette de celui-ci).

class adverb {          
  ...          
 }

Une classe peut <span style="color:#0000CD;">hériter</span> des propriétés de classes parentes, ce qui permet de raffiner progressivement la description des phénomènes.         
 
class adverb_as_modifier {          
   <: adverb; %% this class inherits from the adverb class          
   ...          
}          
class adverb_as_verb_modifier {          
   <: adverb_as_modifier;          
   ....          
}

Une classe peut aussi requérir une fonctionnalité fournie par une autre classe, au travers d'un mécanisme de consommateur/producteur de ressources.

class adverb_as_modifier {          
   <: adverb;          
   - x_modifier; # require the functionality "modifier_of_something"          
   ....          
}          
class X_modifier {          
   + x_modifier; # provide the foncionality "modifier_of_something"          
   ...          
}

Ce mécanisme de gestion de ressources, puissant, vient en complément de l'héritage. En particulier, une ressource peut être consommée plusieurs fois par une classe dans des espaces de noms différents, ce qui n'est pas possible de faire par simple héritage.

class superlative_as_adj_mod {         
    <: superlative_as_mod;         
    %% require agreemnt for the determiner (le|la) and the adjective          
    - det::agreement; det=det::N;         
    - adj::agreement; adj=adj::N;         
    ...         
}         
class agreement {         
    + agreement;         
    %% provide agreement constraint between a node and its father         
    father(N).bot.gender = node(N).bot.gender;         
    ....         
}

Héritage et ressources forme l'ossature de la méta-grammaire (son organisation en terme de classes). La "chair" est fournie par le contenu des classes, portant sur des nœuds des arbres d'analyse, leurs décorations et des contraintes topologiques entre ces nœuds.

class very_simple_intransitive_verb {         
  %% declaration of nodes S, v, and Subject, with some decorations         
   node S: [cat: S, type: std];         
   node v: [cat: v, type: anchor, id: v];         
   node Subject: [cat: N2, type: subst, id: subject];         
   %% The subject precedes the verb         
   Subject < v;         
   %% The sentence node dominates the subject node         
   S >> Subject;         
   %% the sentence node also dominates the verb node, but indirectly         
   %% (to allow other nodes in-between)          
   S >>+ v;         
   ....         
}

À coté des contraintes topologiques (précédence, dominance, égalité), il est également possible d'exprimer des contraintes très riches portant sur les décorations des nœuds, par utilisation de variables ou au travers d'équations entre chemins conduisant d'une source à une valeur. La source d'un chemin est en général un nœud.

class very_simple_intransitive_verb {         
   ...         
   %% use of variable $number to force number agreement        
   node Subject: [cat: N2, type: subst, id: subject, top: [number: $number]];         
   node v : [cat:v, type: anchor, id: v, top: [number: $number]];         
}

class very_simple_intransitive_verb {         
   ...         
   %% alternative use of a path equation to force number agreement       
   node(Subject).top.number = node(v).top.number;         
}

La classe elle-même est le support d'une décoration, ancrée sur le mot clé desc, en particulier pour préparer l'hypertag qui peut associé à un arbre, ou pour gérer des traits globaux plutôt que spécifique à un nœud. Ce mot-clé desc peut être la source d'un chemin.

class very_simple_intransitive_verb {      
   ...      
   %% a non transitive verb has only one subject argument      
   desc.ht.arg0.function=value(subject);      
   desc.ht.arg1.function=value(-);      
   desc.ht.arg2.function=value(-);      
}      
%% alternative, using a full feature structure as value      
class very_simple_intransitive_verb {      
   ...      
   %% a non transitive verb has only one subject argument      
   desc.ht = value([arg0: [function: subject],       
                    arg1: [function: -],      
                    arg2: [function: -]      
                    ]);      
}

Il est également possible d'utiliser une variable (comme $ht) comme source d'un chemin.

class very_simple_intransitive_verb {      
   desc.ht = $ht;      
   ...      
   %% a non transitive verb has only one subject argument      
   $ht.arg1 = value(subject);      
   ....      
}

Les équations sont aussi exploitables pour exprimer des contraintes sur la présence ou l'absence d'un nœud. Une garde, positive ou négative, sur un nœud est ainsi une formule logique à base d'équations.

class very_simple_verb {      
  ...      
  %% a subject is present       
  %% if and only if the verb mood is not imperative or infinitive      
   Subject =>      
         node(v).top.mood = value(~imperative|infinitive);      
   ~ Subject =>      
         node(v).top.mood = value(imperative|infinitive);      
}

Les formules construites sur des équations entre chemins sont aussi utilisables pour exprimer des contraintes complexes, incluant entre autres des disjonctions, sans avoir à multiplier les classes.

class subordonate {     
...     
SubS +     
        node(SubS).top.mode = value(participle|gerundive),     
        node(SubS).top.inv = value(-),     
        node(SubS).top.extraction = value(-),     
        ( node(SubS).top.sat = value(-),     
          ( node(Foot).cat = value(coo)     
            |     
            node(Foot).cat = value(~coo),     
            node(Foot).top.number = node(SubS).bot.number,     
            node(Foot).top.person = node(SubS).bot.person,     
            node(Foot).top.gender = node(SubS).bot.gender     
            )     
          |     
          node(SubS).top.sat = value(ppart)     
          )     
        |     
        node(SubS).top.mode = value(~participle|gerundive),     
        node(SubS).top.sat = value(-)     
        ;     
}

À coté de ces éléments de base, qui suffisent déjà largement, il existe un mécanisme de raccourcis (macro) sur les valeurs des traits et sur les chemins

%% macro on value, for default agreement     
template @defaultagr = [person: 3, number: sg, gender: masc]     
%% macro on path     
path @function0 = .ht.arg0.function     
 
class csu {     
   ...     
   node(CS).bot = value(@defaultagr);     
}     
 
class very_simple_verb {     
   ...     
   desc.@function0 = value(subject);     
}

Lors de la phase de mise au point, il est possible de désactiver une classe et ses descendants

disable verb_categorization_passive

Comme toujours, le formalisme offre son lot de petits "trucs", bons à savoir. Ainsi, les nœuds ont une propriété type, avec quelques types spéciaux:

alternative: pour un nœud dominant un ensemble de nœuds dont l'un seulement peut être utilisé lors d'une analyse
sequence: pour un nœud interne dominant une séquence de fils, mais pour lequel on n'a pas de propriétés linguistiques particulières (pas de catégorie syntaxique par exemple)

class subject {   
     + subject;   
     node SubjectAlt: [type: alternative];   
     SubjectAlt >> CliticSubj; node CliticSubj: [cat: cln, type: coanchor];   
     SubjectAlt >> NominalSubj; node NominalSubj: [cat: N2, type: subst];   
     SubjectAlt >> SentSubj; node SentSubj: [cat: S, type: subst];   
     ...   
}

Ces types spéciaux seront en particulier utilisés pour produire des arbres factorisés.

On peut également indiquer qu'un noeud est optionnel (sans passer par une garde)

class pnoun {   
   ...   
   %% a proper noun may be preceded by an optional title   
   node Monsieur : [cat: title, type: coanchor, optional: yes];   
}

Il est également possible de rendre répétable un noeud, à la manière de l'opérateur "*" dans les expressions régulières (étoile de Kleene). Ceci est en essentiellement utilisé pour représenter la répétition dans les coordinations.

class simple_coord {   
   ...   
   node MiddleCoordSeq: [type: sequence, star: *];   
   node coord: [cat: coo, type: anchor];   
   node EndCoord: [cat: $cat];    
   MiddleCordSeq < coord;   
   coord < EndCoord;   
   MiddleCoordSeq >> MiddleCoord;   
   MiddleCoordSeq >> coma;   
   MiddleCoord < coma;   
   node MiddleCoord: [cat: $cat];   
   node comma: [lex: ",", type: lex];   
}

Version imprimable
Connectez-vous ou inscrivez-vous pour publier un commentaire

Composants d'une méta-grammaire

Formulaire de recherche

Connexion utilisateur