data/marqueurs_UIMA.txt

PACKAGE lm.cristal.ruta;

IMPORT lm.cristal.ts.TextElement;
IMPORT lm.cristal.ts.Sentence;
IMPORT lm.cristal.ts.NominalPhrase;
IMPORT lm.cristal.ts.Token;
IMPORT lm.cristal.ts.Variable;
IMPORT lm.cristal.ts.Hyperonym;
IMPORT lm.cristal.ts.Hyponym;
IMPORT lm.cristal.ts.Hyperonymy;
IMPORT lm.cristal.ts.Part;
IMPORT lm.cristal.ts.Whole;
IMPORT lm.cristal.ts.Meronymy;
IMPORT lm.cristal.ts.Cause;
IMPORT lm.cristal.ts.Effect;
IMPORT lm.cristal.ts.Causality;
IMPORT lm.cristal.ts.KnowledgeRichContext;

// ==========================================================================
// FIXME:
// * Y �tre DET X + caract�ristiques
// * Y pour DET X (dans la construction <participe pass� + pour ...>
// TODO:
// * Assigner les operandes de la relations
//   Remplacer MARK par CREATE
// NOTES:
// * Reference: Rapport d'avancement, novembre 2014
// ==========================================================================

//
// 2. Listes des marqueurs candidats pour le fran�ais
// **************************************************
//

//
// 2.1 Relation d'hyperonymie
// ==========================
//

// X : hyperonyme
// Y : hyponyme

//
// A. Structures attributives
// --------------------------
//

// TODO: caract�ristiques ?
// Y �tre DET X + caract�ristiques
// Les caract�ristiques peuvent prendre la forme d'un compl�ment de nom, 
// d'un adjectif, d'une relative etc.
//

//H01
// Y �tre DET X
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = "Structures attributives")};

//H02
// Y �tre DET ind�fini {sorte/esp�ce/vari�t�/type} de DET X
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]?
Token.partOfSpeech == "Indef"
(Token.lemma == "sorte" | Token.lemma == "esp�ce" | Token.lemma == "vari�t�"
                        | Token.lemma == "type")                        
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = "Structures attributives")};

//H03
// Y �tre DET X tr�s Adj
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "tr�s"
Token.partOfSpeech == "Adj"){-> CREATE(Hyperonymy, "category" = "Structures attributives")};

//H04
// Y �tre DET d�fini X DET d�fini {plus/moins} Adj
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]?
Token.partOfSpeech == "Def"
NominalPhrase{-> MARK(Hyperonym)}
Token{INLIST({"plus", "moins"}, Token.lemma)}
Token.partOfSpeech == "Adj"){-> CREATE(Hyperonymy, "category" = "Structures attributives")};

//H05
// Y �tre DET d�fini {plus/moins} Adj de tous DET d�fini X
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]?
Token.partOfSpeech == "Def"
Token{INLIST({"plus", "moins"}, Token.lemma)}
Token.partOfSpeech == "Adj"
Token.lemma == "de"
Token.lemma == "tous"
Token.partOfSpeech == "Def"
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = "Structures attributives")};

//
// B. Structure coordonn�es
// ------------------------
//

//H06
// Y et {autres|tout autre|tout autre type de} X
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "et"
(Token.lemma == "autre" |
 (Token.lemma == "tout" Token.lemma == "autre") |
 (Token.lemma == "tout" Token.lemma == "autre" Token.lemma == "type" Token.lemma == "de"))
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = " Structures coordon�es")};

//H07
// Y {et/ou} DET autres X
//

(NominalPhrase{-> MARK(Hyponym)}
Token{INLIST({"plus", "moins"}, Token.lemma)}
Token.partOfSpeech == "Det"
Token.coveredText == "autres"
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = "Structures coordon�es")};

//H08
// X et {notamment|en particulier|sp�cialement|particuli�rement|surtout|avant tout} DET Y
//

(NominalPhrase{-> MARK(Hyperonymy)}
Token.lemma == "et"
((Token.lemma == "en" Token.lemma == "particulier") |
 (Token.lemma == "avant" | Token.lemma == "tout") |
 Token{INLIST({"notamment", "sp�cialement", "particuli�rement", "surtout"},
              Token.lemma)})
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}){-> CREATE(Hyperonymy, "category" = "Structures coordon�es")};

//
// C. Structures appositives
// -------------------------
//

//H09
// Y, DET d�fini X DET d�fini {plus | mois} Adj
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == ","
Token.partOfSpeech == "Def"
NominalPhrase{-> MARK(Hyperonym)}
Token.partOfSpeech == "Def"
Token{INLIST({"plus", "moins"}, Token.lemma)}
Token.partOfSpeech == "Adj"
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//H10
// Y, DET d�fini {plus | moins} Adj {des | de tous les} X
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == ","
Token.partOfSpeech == "Det"
Token{INLIST({"plus", "moins"})}
Token.partOfSpeech == "Adj"
(Token{INLIST({"de", "de=le"}, Token.lemma)} |
 (Token.lemma == "de" Token.lemma == "tous" Token.lemma == "le"))
NominalPhrase{-> MARK(Hyperonym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//H11
// DET d�fini {plus | moins} Adj {des | de tous les}
// X, {soit | c'est-�-dire | � savoir} DET d�fini Y
//

(Token.partOfSpeech == "Def"
Token{INLIST({"plus", "moins"}, Token.lemma)}
Token.partOfSpeech == "Adj"
(Token.lemma == "de=le" |
 (Token.lemma == "de" Token.lemma == "tout" Token.lemma == "le"))
NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == ","
(Token{INLIST({"soit", "c'est-�-dire"}, Token.lemma)}
 (Token.lemma == "�" Token.lemma == "savoir"))
Token.partOfSpeech == "Def"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//H12
// X,
// {notamment | en particulier | sp�cialement | particuli�rement | surtout | avant tout}
// (DET)
// Y
//

(NominalPhrase{-> MARK(Hyperonym)}
(Token{INLIST({"notamment", "sp�cialement", "particuli�rement", "surtout"}, Token.lemma)} |
 (Token.lemma == "en" Token.lemma == "particulier") |
 (Token.lemma == "avant" Token.lemma == "tout"))
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//H13
// X
// ({notamment | en particulier | sp�cialement | particuli�rement | surtout | avant tout}
//  (DET)
//  Y
// )
//

(NominalPhrase{-> MARK(Hyperonymy)}
Token.lemma == "("
(Token{INLIST({"notamment", "en particulier", "sp�cialement", "particuli�rement", "surtout"}, Token.lemma)} |
 (Token.lemma == "avant" Token.lemma == "tout"))
Token.lemma == ")"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//H14
// X,
// (DET)
// Y
// {notamment | en particulier | sp�cialement | particuli�rement | surtout | avant tout}
//

(NominalPhrase{-> MARK(Hyperonym)}
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Hyponym)}
(Token{INLIST({"notamment", "sp�cialement", "particuli�rement", "surtout"}, Token.lemma)} |
 (Token.lemma == "en" Token.lemma == "particulier") |
 (Token.lemma == "avant" Token.lemma == "tout"))
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//H15
// X,
// {y compris | tout en comptant}
// (DET) Y
//

(NominalPhrase{-> MARK(Hyperonym)}
(Token.lemma == "y compris" | // NOTE: yes, "y compris" is atomic with Xelda
 (Token.lemma == "tout" Token.lemma == "en" Token.lemma == "compter"))
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

// NOTE:
// This one is splitted
//H16
// X,
// {hormis | sauf | exception faite | � l'exception de | except�}
// DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == ","
Token{INLIST({"hormis", "sauf", "excepter"}, Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == ","
Token.lemma == "exception faite de=le"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == ","
Token.lemma == "�"
Token.lemma == "le"
Token.lemma == "exception"
Token{INLIST({"de", "de=le"}, Token.lemma)}
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};


// H17
// X ((DET) Y)
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "("
(Token.lemma == "Det")?
NominalPhrase{-> MARK(Hyponym)}
Token.lemma == ")"
){-> CREATE(Hyperonymy, "category" = "Structures appositives")};

//
// D. Structures d'inclusion
// -------------------------
//

//H18
// {DET d�fini | diff�rents | plusieurs | de nombreux  | divers | quelques |
//  un certain nombre | un grand nombre | beaucoup de}
// X
// {notamment | en particulier | sp�cialement | particuli�rement | surtout | avant tout}
// DET Y
//

((Token.partOfSpeech == "Def" |
 Token{INLIST({"diff�rent", "plusieurs", "divers", "quelque"}, Token.lemma)} |
 (Token.lemma == "de" Token.lemma == "nombreux") |
 (Token.lemma == "un" Token.lemma == "certain" Token.lemma == "nombre") |
 (Token.lemma == "beaucoup" Token.lemma == "de"))
NominalPhrase{-> MARK(Hyperonym)}
((Token.lemma == "en" Token.lemma == "particulier") |
 (Token.lemma == "avant" Token.lemma == "tout") |
 Token{INLIST({"notamment", "sp�cialement", "particuli�rement", "surtout"}, Token.lemma)})
Token.lemma == "Det"
NominalPhrase{-> MARK(Hyponym)}){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H19
// {DET d�fini | diff�rents | plusieurs | de nombreux | divers | quelques |
// un certain nombre | un grand nombre | beaucoup de}
// X
// {dont | tel que | tel}
// DET Y
//

((Token.partOfSpeech == "Def" |
  Token{INLIST({"diff�rent", "plusieur", "divers", "quelque"}, Token.lemma)} |
  (Token.lemma == "de" Token.lemma == "nombreux") |
  (Token.lemma == "un" Token.lemma == "certain" Token.lemma == "nombre") |
  (Token.lemma == "un" Token.lemma == "grand" Token.lemma == "nombre") |
  (Token.lemma == "beaucoup" Token.lemma == "de"))
NominalPhrase{-> MARK(Hyperonym)}
((Token.lemma == "tel" Token.lemma == "que") |
 Token{INLIST({"dont", "tel"}, Token.lemma)})
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H20
// {Parmi | parmi tous les | dans l'ensemble des | au nombre des} X, DET Y
//

((Token.lemma == "parmi" |
 (Token.lemma == "parmi" Token.lemma == "tous" Token.lemma == "les") |
 (Token.lemma == "dans" Token.lemma == "le" Token.lemma == "ensemble" Token.lemma == "des") |
 (Token.lemma == "au" Token.lemma == "nombre" Token.lemma == "de"))
NominalPhrase{-> MARK(Hyperonymy)}
Token.partOfSpeech == "Det"
NominalPhrase{-> Hyponym}){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H21
// X
// {parmi lesquels | au premier rang desquels | au nombre desquels}
// DET Y
//


(NominalPhrase{-> MARK (Hyperonymy)}
((Token.lemma == "parmi" Token.lemma == "lequel") |
 (Token.lemma == "au" Token.lemma == "premier" Token.lemma == "rang" Token.lemma == "de=lequel") |
 (Token.lemma == "au" Token.lemma == "nombre" Token.lemma == "de=lequel"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H21
// X
// {parmi lesquels | au premier rang desquels | au nombre desquels}
// DET Y
//

(NominalPhrase{-> MARK(Hyperonymy)}
((Token.lemma == "parmi" Token.lemma == "lequel") |
 (Token.lemma == "au" Token.lemma == "premier" Token.lemma == "rang" Token.lemma == "de=lequel") |
 (Token.lemma == "au" Token.lemma == "nombre" Token.lemma == "de=lequel"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H22
// {tout | tous}
// Y �tre DET ind�fini X
//

(Token{INLIST({"tout", "tous"}, Token.lemma)}
NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]
Token.partOfSpeech == "Indef"
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H23
// Y �tre DET ind�fini {sp�cialisation | sp�cification | pr�cision |
// d�termination} de DET X
//

(NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "�tre"
Token[0, 3]
Token.partOfSpeech == "Indef"
(Token.lemma == "sp�cialisation" | Token.lemma == "sp�cification" |
 Token.lemma == "pr�cision" | Token.lemma == "d�termination")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyperonym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H24
// Y {former | repr�senter | constituer | consister en}
// DET ind�fini
// {sp�ciatisation | sp�cification | pr�cision | d�termination}
// de DET X
//

(NominalPhrase{-> MARK(Hyponym)}
(Token{INLIST({"former", "repr�senter", "constituer"}, Token.lemma)} |
 (Token.lemma == "consister" Token.lemma == "en"))
Token[0, 3]?
Token.partOfSpeech == "Indef"
Token{INLIST({"sp�cialisation", "sp�cification", "pr�cision", "d�termination"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyperonym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H25
// {appeler | nommer | qualifier de | d�signer par | repr�senter (avec|par)
//  | symboliser par | d�nommer par} DET Y DET ind�fini X
//

((Token{INLIST({"appeler", "nommer"}, Token.lemma)} |
 (Token.lemma == "qualifier" Token.lemma == "de") |
 (Token.lemma == "d�signer" Token.lemma == "par") |
 (Token.lemma == "repr�senter" Token{INLIST({"avec", "par"}, Token.lemma)}) |
 (Token.lemma == "symboliser" Token.lemma == "par") |
 (Token.lemma == "d�nommer" Token.lemma == "par"))
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}
Token.lemma == "Indef"
NominalPhrase{-> MARK(Hyperonym)}){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H26
// DET X
// �tre {appel�/nomm�/qualifi� de/d�sign� par/ repr�sent� {avec/par}/symbolis� par/d�nomm� par}
//DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "�tre"
((Token{INLIST({"appeler", "nommer"}, Token.lemma)} |
 (Token.lemma == "qualifier" Token.lemma == "de") |
 (Token.lemma == "d�signer" Token.lemma == "par") |
 (Token.lemma == "repr�senter" Token{INLIST({"avec", "par"}, Token.lemma)}) |
 (Token.lemma == "symboliser" Token.lemma == "par") |
 (Token.lemma == "d�nommer" Token.lemma == "par"))
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};


//H27
// X se
// {pr�senter | trouver | montrer } 
// {sous | comme}
// DET
// {forme | �tat | disposition | consistance | apparence | aspect | modalit� |
//  configuration | conformation | style | structure | nature}
// de DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "se"
(Token.lemma == "pr�senter" | Token.lemma == "trouver" | Token.lemma == "montrer")
Token[0, 3]?
(Token.lemma == "sous" | Token.lemma == "comme")
Token.partOfSpeech == "Det"
(Token.lemma == "forme" | Token.lemma == "�tat" | Token.lemma == "disposition" |
 Token.lemma == "consistance" | Token.lemma == "apparence" |
 Token.lemma == "aspect" | Token.lemma == "modalit�")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H28
// X se
// { diviser | subdiviser | dissocier | morceler |
//  fragmenter | fractionner | d�composer | partager | s�parer | offrir}
// {sous | comme}
// DET
// {forme | �tat | disposition | consistance | modalit� |
//  configuration | conformation | style | structure }
// de DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "se"
(Token.lemma == "diviser" | Token.lemma == "subdiviser" |     Token.lemma == "dissocier" | Token.lemma == "morceler" |
Token.lemma == "fragmenter"  | Token.lemma == "fractionner" | Token.lemma == "d�composer" | Token.lemma == "partager" | Token.lemma == "s�parer" | Token.lemma == "offrir")
Token[0, 3]?
(Token.lemma == "sous" | Token.lemma == "comme")
Token.partOfSpeech == "Det"
(Token.lemma == "forme" | Token.lemma == "�tat" | Token.lemma == "disposition" | Token.lemma == "consistance" | 
Token.lemma == "modalit�" | Token.lemma == "configuration " |
Token.lemma == "conformation" | Token.lemma == "style" |
Token.lemma == "structure" )
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};


//H29
// X se
// { pr�senter | trouver | montrer }
// {sous | comme}
// DET
// {sous-}
// {classe | cat�gorie | caste | groupe | division | esp�ce | ensemble | division | vari�t� |
// race | sorte | type | mod�le | famille | genre | collection | concept | partie | parition}
// de DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "se"
Token{INLIST({"pr�senter", "trouver", "montrer"},
             Token.lemma)}
Token[0, 3]?
Token{INLIST({"sous", "en"}, Token.lemma)}
Token.partOfSpeech == "Det"
Token{INLIST({"sous-classe", "sous-cat�gorie", "sous-caste", "sous-groupe",
              "sous-division", "sous-esp�ce", "sous-ensemble", "sous-division",
              "sous-vari�ter", "sous-race", "sous-sorte", "sous-type",
              "sous-mod�le", "sous-famille", "sous-genre", "sous-collection",
              "sous-concept", "sous-partie", "sous-parition", "classe",
              "cat�gorie", "caste", "groupe", "division", "esp�ce",
              "ensemble", "division", "vari�t�", "race", "sorte", "type",
              "mod�le", "famille", "genre", "collection", "concept", "partie",
              "partition"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H30
// X �tre
// {pr�sent� | divis� | trouv� | montr� | subdivis� | dissoci� | morcel� |
//  fragment� | fractionn� | d�compos� | partag� | s�par�}
// {sous | en |comme}
// DET
// {forme | �tat | disposition | consistance | modalit� |
//  configuration | conformation | style | structure }
// de DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "�tre"
Token{INLIST({"pr�senter", "diviser", "trouver", "montrer", "subdiviser",
              "dissocier", "morceler", "fragmenter", "fractionner",
              "d�composer", "partager", "s�parer"},
             Token.lemma)}
Token[0, 3]?
Token{INLIST({"sous", "en", "comme"}, Token.lemma)}
Token.partOfSpeech == "Det"
(Token.lemma == "forme" | Token.lemma == "�tat" | Token.lemma == "disposition" |
 Token.lemma == "consistance" | Token.lemma == "apparence" |
 Token.lemma == "aspect" | Token.lemma == "modalit�")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures d'inclusion")};

//H31
// {d�signation | d�nomination | appellation} de DET X par DET Y
//

((Token.lemma == "d�signation" | Token.lemma == "d�nomination" | Token.lemma == "appellation")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Nominalisations")};

//
// E. Structures d'exemplifications
// --------------------------------
//

//H32
// X {comme | comme par exemple | du type | de type | tel | tel que | pareil �}
// (DET) Y
//

(NominalPhrase{-> MARK(Hyperonym)}
(Token{INLIST({"comme", "tel"}, Token.lemma)} |
 (Token.lemma == "comme" Token.lemma == "par" Token.lemma == "exemple") |
 (Token.lemma == "du" Token.lemma == "type") |
 (Token.lemma == "de" Token.lemma == "type") |
 (Token.lemma == "tel" Token.lemma == "que") |
 (Token.lemma == "pareil" Token.lemma == "�"))
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures exemplifications")};

//H33
// X {c'est-�-dire | � savoir} DET Y
//

(NominalPhrase{-> MARK(Hyperonym)}
(Token.lemma == "c'est-�-dire" | (Token.lemma == "�" Token.lemma == "savoir"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures exemplifications")};


//H34
// X : (DET) Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == ":"
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "Structures exemplifications")};

//
// F. Structures avec Utiliser
// ------------------
//

//H35
// Utiliser Y {comme | en tant que | pour } (DET) X
//

(Token.lemma == "utiliser"
Token[0, 3]?
NominalPhrase{-> MARK(Hyponym)}
(Token.lemma == "comme" |Token.lemma == "pour" |
 (Token.lemma == "en" Token.lemma == "tant" Token.lemma == "que"))
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Hyperonym)}
){-> CREATE(Hyperonymy, "category" = "structure avec Utiliser ")};

//H36
//DET X �tre utilis� {comme/en tant que/pour}(DET) Y
//

(NominalPhrase{-> MARK(Hyperonym)}
Token.lemma == "�tre"
Token.lemma == "utiliser""
(Token.lemma == "comme" | token.lemma = "pour" |
 (Token.lemma == "en" Token.lemma == "tant" Token.lemma == "que"))
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Hyperonym)}
){-> CREATE(Hyperonymy, "category" = "structure avec Utiliser ")};




//H37
// Utilisation de DET X {comme | en tant que | pour} (DET) Y
//

(Token.lemma == "utilisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Hyperonym)}
(Token.lemma == "comme" | Token.lemma == "pour" | (Token.lemma == "en" Token.lemma == "tant" Token.lemma == "que"))
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Hyponym)}
){-> CREATE(Hyperonymy, "category" = "structure avec Utiliser ")};

//
// 2.2 Relation de m�ronymie
// =========================
//

//
// A. Genre des parties
// --------------------
//

//
// i. parties de m�me genre
//

//M01
// X {r�unir | unir | rassembler | grouper | regrouper | collecter} DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "r�unir" | Token.lemma == "unir" |
 Token.lemma == "rassembler" | Token.lemma == "grouper" |
 Token.lemma == "regrouper" | Token.lemma == "collecter")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M02
// {r�unir | unir | rassembler | grouper | regrouper | collecter}
// DET
// Y
// {en | dans | sur}
// DET
// X
//

(Token{INLIST({"r�unir", "unir", "rassembler", "grouper", "regrouper", "collecter"}, Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
(Token{INLIST({"en", "dans", "sur"}, Token.lemma)} Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M03
// {r�unir | unir | rassembler | grouper | regrouper | collecter}
// {en | dans | sur } DET X DET Y
//

(Token{INLIST({"r�unir", "unir", "rassembler", "grouper", "regrouper", "collecter"}, Token.lemma)}
Token[0, 3]?
 (Token{INLIST({"en", "dans", "sur"}, Token.lemma)} Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M04
// Y se
// {r�unir | unir | rassembler | grouper | regrouper | collecter}
// {en | pour former | pour donner}
// DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "se"
(Token.lemma == "r�unir" | Token.lemma == "unir" |
 Token.lemma == "rassembler" | Token.lemma == "grouper" |
 Token.lemma  == "regrouper" | Token.lemma == "collecter")
Token[0, 3]?
(Token.lemma == "en" |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "donner"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

// FIXME: how to limit ?
//M05
// Y (�tre) {uni | r�uni | group� | regroup� | rassembl� | collect�}
// {en | dans | sur }
// DET X
//

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre") ??
Token{INLIST({"unir", "r�unir", "grouper", "regrouper", "rassembler", "collecter"}, Token.lemma)}
Token.partOfSpeech == "Det"
(Token{INLIST({"en", "dans", "sur"}, Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M06
// X {�tre | r�sulter de | issu de} DET defini
// {ensemble | groupe | classe | r�union | famille | collection|rassemblement|regroupement}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token[0, 3]? Token.partOfSpeech == "Def") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Def"))))
Token{INLIST({"ensemble", "groupe", "classe", "r�union", "famille", "collection", "rassemblement", "regroupement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Def"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M07
// X : (DET) {ensemble | groupe | classe | r�union | famille | collection|union|rassemblement|regroupement}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
(Token.partOfSpeech == "Det")??
(Token.lemma == "ensemble" | Token.lemma == "groupe" | 
 Token.lemma == "classe" | Token.lemma == "r�union" |
 Token.lemma == "famille" | Token.lemma == "collection" |
Token.lemma == "union" | Token.lemma == "rassemblement")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Def"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M08
// DET d�fini {ensemble | groupe | classe | r�union | famille | collection | union|rassemblement|regroupement}
// de DET Y donner DET X
//

(Token.partOfSpeech == "Def"
(Token.lemma == "ensemble" | Token.lemma == "groupe" |
 Token.lemma == "classe" | Token.lemma == "r�union" |
 Token.lemma == "famille" | Token.lemma == "collection" |
Token.lemma == "union" | Token.lemma == "rassemblement")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Def"))
NominalPhrase{-> MARK(Part)}
Token.lemma == "donner"
Token[0,3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//M09
// {union | r�union | intersection | rassemblement | regroupement}
// de DET Y {�tre|former|repr�senter|constituer|consister en} DET X
//

((Token.lemma == "union" | Token.lemma == "r�union" |
  Token.lemma == "intersection" | Token.lemma == "rassemblement" |
  Token.lemma == "regroupement")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Def"))
NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre" | Token.lemma == "former" |
Token.lemma == "repr�senter" | Token.lemma == "constituer" | (Token.lemma == "consister" Token[0, 3]? Token.lemma == "en"))
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};


//M10
// Missing: pour former, pour donner
// {r�union | rassemblement | union | regroupement} de DET Y
// {en | pour former| pour donner} DET X
//

((Token.lemma == "r�union" | Token.lemma == "rassemblement" |
  Token.lemma == "union" | Token.lemma == "regroupement")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
(Token.lemma == "en" |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "donner"))
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};


//M11
// X {comme | en tant que} DET
// {r�union | rassemblement | union | regroupement | groupe | classe | famille | collection}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "comme" |
 (Token.lemma == "en" Token.lemma == "tant" Token.lemma == "que"))
Token.partOfSpeech == "Det"
(Token.lemma == "r�union" | Token.lemma == "rassemblement" |
 Token.lemma == "union" | Token.lemma == "regroupement" |
 Token.lemma == "groupe" | Token.lemma == "classe" |
 Token.lemma == "famille" | Token.lemma == "collection")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / M�me genre")};

//
// ii. parties de genre different
//

//M12
// X {amalgamer | m�langer | agr�ger | f�d�rer|accumuler|agglom�rer|amonceler|empiler|entasser} DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "amalgamer" | Token.lemma == "m�langer" |
 Token.lemma == "agr�ger" | Token.lemma == "f�d�rer" |
Token.lemma == "accumuler" | Token.lemma == "agglom�rer" | Token.lemma == "amonceler" | Token.lemma == "empiler" |
Token.lemma == "entasser")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M13
// {amalgamer | m�langer | agr�ger | f�d�rer|accumuler|agglom�rer|amonceler|empiler|entasser}
// DET Y{en|dans} DET X
//

((Token.lemma == "amalgamer" | Token.lemma == "m�langer" |
  Token.lemma == "agr�ger" | Token.lemma == "f�d�rer"|
Token.lemma == "accumuler" | Token.lemma == "agglom�rer" | Token.lemma == "amonceler" | Token.lemma == "empiler" |
Token.lemma == "entasser")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
(Token.lemma == "dans" |Token.lemma == "en" )
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M14
// {amalgamer | m�langer | agr�ger | f�d�rer | accumuler | agglom�rer | amonceler | empiler | entasser} dans DET X DET Y
//

((Token.lemma == "amalgamer" | Token.lemma == "m�langer" |
  Token.lemma == "agr�ger" | Token.lemma == "f�d�rer" |
Token.lemma == "accumuler" | Token.lemma == "agglom�rer" | Token.lemma == "amonceler" | Token.lemma == "empiler" |
Token.lemma == "entasser")
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M15
// FIXME: participes ?
// Y �tre {amalgam� | m�lang� | agr�g� | f�d�r� | accumul� | agglom�r� | amoncel� | empil� | entass�} {dans | en} DET X
//
(NominalPhrase{-> MARK(Part)}
Token.lemma == "�tre"
Token[0, 3]?
Token{INLIST({"amalgamer", "m�langer", "agr�ger", "f�d�rer", "accumuler", "agglom�rer", "amonceler", "emplier", "entasser"})}
(Token.lemma == "dans" | Token.lemma == "en")
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M16
// Y se {amalgamer | m�langer | agr�ger | f�d�rer | accumuler | agglom�rer | amonceler | empiler | entasser} {en | dans} DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "se"
(Token.lemma == "amalgamer" | Token.lemma == "m�langer" |
 Token.lemma == "agr�ger" | Token.lemma == "f�d�rer" |
Token.lemma == "accumuler" | Token.lemma == "agglom�rer" | Token.lemma == "amonceler" | Token.lemma == "empiler" |
Token.lemma == "entasser")
Token[0, 3]?
(Token.lemma == "dans" | Token.lemma == "en" )
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M17
// X
// {�tre | r�sulter de | issu de} DET {amalgame | m�lange | agr�gat | complexe | f�d�ration | concentration}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token[0, 3]? Token.partOfSpeech == "Det") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))))
Token{INLIST({"amalgame", "m�lange", "agr�gat", "complexe", "f�d�ration", "concentration"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M18
// X : {amalgame | m�lange | agr�gat | complexe | f�d�ration | concentration} de DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
(Token.lemma == "amalgame" | Token.lemma == "m�lange" |
 Token.lemma == "agr�gat" | Token.lemma == "complexe" |
 Token.lemma == "f�d�ration" | Token.lemma == "concentration")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//M19
// {amalgame | m�lange | agr�gat | agr�gation | complexe | f�d�ration | concentration}
// de DET Y
// {dans | en | pour former | pour constituer | donner}
// DET X
//

((Token.lemma == "amalgame" | Token.lemma == "m�lange" |
 Token.lemma == "agr�gat" | Token.lemma == "agr�gation" |
 Token.lemma == "complexe" | Token.lemma == "f�d�ration" | Token.lemma == "concentration")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Genre des parties / Genre diff�rent")};

//
// B. Type de liaisons entre parties
// ---------------------------------
//

//
// i. rapprochement
//

//M20
// X {rapprocher | recueillir} DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "rapprocher" | Token.lemma == "recueillir")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//M21
// {rapprocher | recueillir} DET Y {sur | en | dans | vers} DET X
//

((Token.lemma == "rapprocher" | Token.lemma == "recueillir")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
(Token.lemma == "sur" | Token.lemma == "en" | Token.lemma == "dans" | Token.lemma == "vers")
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//M22
// {rapprocher | recueillir}
// {sur | en | dans | vers}
// DET X DET Y
//

((Token.lemma == "rapprocher" | Token.lemma == "recueillir")
Token[0, 3]?
(Token.lemma == "sur" | Token.lemma == "en" | Token.lemma == "dans" |
 Token.lemma == "vers")
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

// M23
//FIXME: participes/adjs
// Y (�tre) {rapproch� | recueilli} {sur | en | dans | vers} DET X
//

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre") ??
Token{INLIST({"rapprocher", "recueillir"}, Token.lemma)}
Token{INLIST({"sur", "en", "dans", "vers"}, Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//M24
// X
// {�tre | r�sulter de | issu de} DET {recueil | collection | rassemblement}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre" |
 (Token.lemma == "r�sulter" Token.lemma == "de") |
 (Token.lemma == "issu" Token.lemma == "de"))
Token[0, 3]?
Token.partOfSpeech == "Det"
(Token.lemma == "recueil" | Token.lemma == "collection" | Token.lemma == "rassemblement")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//M25
// {recueil | collection | rassemblement}
// {dans | sur | des | de | du}
// DET X de DET Y
//

((Token.lemma == "recueil" | Token.lemma == "collection" | Token.lemma == "rassemblement")
(Token.lemma == "dans" | Token.lemma == "sur" | Token{INLIST({"de", "de=le"}, Token.lemma)})
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//M26
// {recueil | collection | rassemblement}
// de DET Y
// {dans | en | pour former | pour constituer | donner}
// DET X

((Token.lemma == "recueil" | Token.lemma == "collection" | Token.lemma == "collection")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//M27
// X : (DET) {recueil | collection | rassemblement} de DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
(Token.partOfSpeech == "Det")??
(Token.lemma == "recueil" | Token.lemma == "collection" | Token.lemma == "rassemblement")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Rapprochement")};

//
// ii. r�union compacte
//

//M28
// X {agglom�rer | agglutiner | conglom�rer} DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "agglom�rer" | Token.lemma == "agglutiner" | Token.lemma == "conglom�rer")
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / R�union compacte")};

//M29
// Y se {agglom�rer | agglutiner | conglom�rer}
// {dans | en | pour former | pour constituer | donner}
// DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "se"
Token{INLIST({"agglom�rer", "agglutiner", "conglom�rer"}, Token.lemma)}
Token[0, 3]?
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / R�union compacte")};

//M30
// X {�tre | r�sulter de, issu de} DET {agglom�rat | agglutination} de DET Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token.partOfSpeech == "Det") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))))
Token{INLIST({"agglom�rat", "agglutination"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / R�union compacte")};

//M31
// X : {agglom�rat | agglutination} de DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
(Token.lemma == "agglom�rat" | Token.lemma == "agglutination")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / R�union compacte")};

//M32
// {agglom�rat | agglutination} de DET 
// {dans | en | pour former | pour constituer | donner} DET X
//

((Token.lemma == "agglom�rat" | Token.lemma == "agglutination")
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
((Token{INLIST({"dans", "en", "donner"}, Token.lemma)}) |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token[0, 3]?
Token.partOfSpeech == "Det"
){-> CREATE(Meronymy, "category" = "Type de laisons / R�union compacte")};

//
// iii. jonction
//

//M33
// X {attacher | joindre | lier | relier | monter} DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "attacher" | Token.lemma == "joindre" |
 Token.lemma == "lier" | Token.lemma == "relier" | Token.lemma == "monter")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Jonction")};

//M34
// {attacher | joindre | lier | relier | monter} DET Y {� | au | aux | avec} DET X
//

(Token{INLIST({"attacher", "joindre", "lier", "relier", "monter"},
              Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
Token{INLIST({"�", "au", "aux", "�=le", "avec"})}
Token.lemma == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Jonction")};

//M35
// {attacher | joindre | lier | relier | monter}
// {� | au | aux | avec}
// X DET Y
//

(Token{INLIST({"attacher", "joindre", "lier", "relier", "monter"},
              Token.lemma)}
Token[0, 3]?
Token{INLIST({"�", "au", "aux", "�=le", "avec"}, Token.lemma)}
NominalPhrase{-> MARK(Whole)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Jonction")};

// M36
//FIXME: participes/adjs
// Y (�tre) {attach� | joint | li� | reli� | mont�}
// {� | au | aux | avec}
// DET X

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre") ??
Token{INLIST({"attacher", "joint", "li�", "reli�", "mont�"}, Token.lemma)}
Token{INLIST({"�", "au", "aux", "�=le", "avec"}, Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Jonction")};

//M37
// X
// {�tre | r�sulter de | issu de}
// DET
// {jonction | liaison | montage | construction | assemblage}
// {entre | de} DET Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token[0, 3]? Token.lemma == "Det") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" | Token.partOfSpeech == "Det"))))
Token{INLIST({"jonction", "liaison", "montage", "construction", "assemblage"}, Token.lemma)}
((Token.lemma == "entre" Token.partOfSpeech == "Det") | (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det")))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Jonction")};



//M38
//{jonction | liaison | montage | construction | assemblage} de DET Y (et DET Z) {dans|en|pour former|pour //constituer|donner} DET X
//
Token{INLIST({"jonction", "liaison", "montage", "construction", "assemblage"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
(Token.lemma == "et" Token.partOfSpeech == "Det" NominalPhrase{-> MARK(Part)})??
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};

// iv. fusion
//

//M39
// X {fondre | fusionner | incorporer} DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token{INLIST({"fondre", "fusionner", "incorporer"}, Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};


//M40
//Y (�tre) {fondu|fusionn�|incorpor�} dans DET X
//

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre")??
Token{INLIST({"fondre", "fusionner", "incorporer"}, Token.lemma)}
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};


//M41
// Y se {fondre | fusionner | incorporer} en DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "se"
Token{INLIST({"fondre", "fusionner", "incorporer"}, Token.lemma)}
Token[0, 3]?
Token.lemma == "en"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};

//M42
// X
// {�tre | r�sulter de | issu de}
// DET
// {fusion | alliage | assimilation | incorporation}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token[0, 3]? Token.partOfSpeech == "Det") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))))
Token{INLIST({"fusion", "alliage", "assimilation", "incorporation"}, Token.lemma)}
(Token.lemma == "de" Token.partOfSpeech == "Det")
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};

//M43
// X : {fusion | alliage | assimilation | incorporation} de DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
Token{INLIST({"fusion", "alliage", "assimilation", "incorporation"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};

//M44
// {fusion | alliage | assimilation | incorporation} de DET Y
// {dans | en | pour former | pour constituer | donner}
// DET X
//

(Token{INLIST({"fusion", "alliage", "assimilation", "incorporation"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Fusion")};

//
// v. inclusion
//

//M45
// {classification | cat�gorisation | groupement | rangement | classement |
//  inclusion | appartenance | assemblage}
// de DET Y dans DET X
//

(Token{INLIST({"classification", "cat�gorisation", "groupement",
               "rangement", "classement", "inclusion", "appartenance",
               "assemblage"},
               Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M46
// {classification | cat�gorisation | groupement | rangement | classement |
//  inclusion | appartenance | assemblage}
// dans DET X de DET Y
//

(Token{INLIST({"classification", "cat�gorisation", "groupement",
               "rangement", "classement", "inclusion", "appartenance",
               "assemblage"},
               Token.lemma)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


// M47
//FIXME: adj/participe
// Y (�tre)
// {class� | classifi� | catalogu� | rang� | plac� | inclus | �tiquet� |
//  cat�goris� | group�}
// dans DET X
//
(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"classer", "classifier", "cataloguer", "ranger", "placer",
              "inclure", "�tiquetter", "cat�goriser", "grouper"},
             Token.lemma)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M48
// Y appartenir � DET X
//
 
(NominalPhrase{-> MARK(Part)}
Token.lemma == "appartenir" Token.lemma == "�"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};



//M49
//TODO: {sous} ?
//
// Y
// {�tre | former | repr�senter | constituer | consister en}
// DET
// {�l�ment | repr�sentant | instance | exemplaire | sp�cimen | �chantillon |
//  individu | objet}
// de DET {sous} {cat�gorie | division | esp�ce | sorte | race | ensemble |
// vari�t� | type | genre | collection | concepts | partie | partition}
// (DET) X
//

(NominalPhrase{-> MARK(Part)}
(Token{INLIST({"�tre", "former", "repr�senter", "constituer"}, Token.lemma)} |
 (Token.lemma == "consister" Token.lemma == "en"))
Token[0, 3]?
Token.partOfSpeech == "Det"
Token{INLIST({"�l�ment", "repr�sentant", "instance", "exemplaire", "sp�cimen",
              "�chantillon"},
             Token.lemma)}
Token.lemma == "de"
Token.partOfSpeech == "Det"
(Token.lemma == "sous")??
Token{INLIST({"cat�gorie", "division", "esp�ce", "sorte", "race", 
              "ensemble", "vari�t�", "type", "genre", "collection",
              "concepts", "partie", "partition"},
             Token.lemma)}
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M50
// TODO: {sous} ?
// Y (�tre) (DET) (sous) {cat�gorie | division | esp�ce | sorte | race | ensemble |
// vari�t� | type | genre | collection | concepts | partie | partition}
// de DET X
//

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre")??
(Token.partOfSpeech == "Det")??
(Token.lemma == "sous")??
Token{INLIST({"cat�gorie", "division", "esp�ce", "sorte", "race", "ensemble",
              "vari�t�", "type", "genre", "collection", "concepts", "partie",
              "partition"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};

//M51
// X (�tre DET)
// {classfification | cat�gorisation | groupement | rangement | classement |
//  inclusion | appartenance | assemblage}
// de DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre")??
(Token.partOfSpeech == "Det")??
Token{INLIST({"classification", "cat�gorisation", "groupement", "rangement",
              "classement", "inclusion", "appartenance", "assemblage"})}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M52
// X {comprendre | abriter | comporter | compter | inclure | int�grer}
// DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token{INLIST({"comprendre", "abriter", "comporter", "compter", "inclure",
              "int�grer"}, Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M53
// X  (�tre) {comprendre | abriter | comporter | compter | inclure | int�grer}
// dans DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre")??
Token{INLIST({"comprendre", "abriter", "comporter", "compter", "inclure",
              "int�grer"}, Token.lemma)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


// M54
//TODO: adj/participe
// X (�tre) {form� | constitu�} de DET Y
//
(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"former", "constituer"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M55
// {formation | constituion | composition/int�gration} de DET Y par DET X
//

(Token{INLIST({"formation", "constitution", "composition", "int�gration"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> Whole}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//M56
// {formation | constituion | composition/int�gration} par DET X de DET Y 
//

(Token{INLIST({"formation", "constitution", "composition", "int�gration"}, Token.lemma)}
Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> Whole}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Type de laisons / Inclusion")};


//
// C. Organisation des parties
// ---------------------------
//

//
// i. non organisation
//

//M57
// Y se {accumuler | amasser | entasser} dans DET X
//

(NominalPhrase{-> MARK(Part)}
Token{INLIST({"accumuler", "amasser", "entasser"}, Token.lemma)}
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


// M58
// TODO: adj/participe ?
// Y (�tre) {accumul� | amass� |entass�} dans DET X
//

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre") ??
Token{INLIST({"accumuler", "amasser", "entasser"}, Token.lemma)}
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};



//M59
// {accumuler | amasser |entasser } DET Y dans DET X
//

(Token{INLIST({"accumuler", "amasser", "entasser"}, Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M60
// {accumuler | amasser |entasser} dans DET X DET Y
//

(Token{INLIST({"accumuler", "amasser", "entasser"}, Token.lemma)}
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M61
// Y se {accumuler | amasser | entasser}
// {dans | en | pour former | pour constituer | donner}
// DET X

(NominalPhrase{-> MARK(Part)}
Token.lemma == "se"
Token{INLIST({"accumuler", "amasser", "entasser"}, Token.lemma)}
Token[0, 3]?
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M62
// X {�tre | r�sulter de | (�tre) issu de}
// DET
// {tas | amas | ramassis | masse | accumulation | entassement}
// de (DET)
// Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token[0, 3]? Token.partOfSpeech == "Det") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))))
Token{INLIST({"tas", "amas", "ramassis", "masse", "accumulation", "entassement"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M63
// X : (DET) {tas| amas | ramassis | masse | accumulation | entassement}
// de (DET) Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
(Token.partOfSpeech == "Det")
Token{INLIST({"tas", "amas", "ramassis", "masse", "accumulation", "entassement"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M64
//{tas | amas | ramassis | masse | accumulation | entassement} de (DET) Y
//// {dans | en | pour former | pour constituer | donner}
// DET X

Token{INLIST({"tas", "amas", "ramassis", "masse", "accumulation", "entassement"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M65
// {tas | amas | ramassis | masse | accumulation | entassement}
// dans DET X de (DET) Y
//

(Token{INLIST({"tas", "amas", "ramassis", "masse", "accumulation", "entassement"},
              Token.lemma)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};


//M66
// {tas | amas | ramassis | masse | accumulation | entassement} de (DET) Y
// dans DET X
//

(Token{INLIST({"tas", "amas", "ramassis", "masse", "accumulation", "entassement"},
              Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Non organisation")};

//
// ii. organisation
//

//M67
// Y {configurer | construire | organiser | composer} DET X
//

(NominalPhrase{-> MARK(Part)}
Token{INLIST({"configurer", "construire", "organiser", "composer"},
             Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M68
// FIXME: adj/participe
// Y (�tre) {configu� | construit | organis� | compos�} dans DET X
//

(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"configurer", "construire", "organiser", "composer"}, Token.lemma)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M69
// {configurer | construire | organiser | composer} DET Y dans DET X
// 

(Token{INLIST({"configurer", "construire", "organiser", "composer"},
              Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M70
// {configurer | construire | organiser | composer} dans DET X DET Y
// 

(Token{INLIST({"configurer", "construire", "organiser", "composer"},
              Token.lemma)}
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M71
// Y se
// {configurer | construire | encha�ner | organiser | composer | succ�der | suivre}
// {dans | en | pour former | pour constituer | donner}
// DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "se"
Token{INLIST({"configurer", "construire", "encha�ner", "organiser",
              "composer", "succ�der", "suivre"},
             Token.lemma)}
Token[0, 3]?
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M72
// X {�tre | r�sulter de | issu de}
// DET
// {configuration | construction | organisation | succession | cha�ne |
//  s�rie | liste | suite | enchainement}
// de (DET) Y
//

(NominalPhrase{-> MARK(Whole)}
((Token.lemma == "�tre" Token[0, 3]? Token.partOfSpeech == "Det") |
 (Token{INLIST({"r�sulter", "issu"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))))
Token{INLIST({"configuration", "construction", "organisation", "succession",
              "cha�ne", "s�rie", "liste", "suite", "enchainement"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M73
// X : (DET)
// {configuration | constructino | organisation | succession | cha�ne |
//  s�rie | liste | suite | enchainement}
// de (DET) Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == ":"
(Token.partOfSpeech == "Det")?
Token{INLIST({"configuration", "construction", "organisation", "succession",
              "cha�ne", "s�rie", "liste", "suite", "enchainement"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};


//M74
// {configuration | construction | organisation | succession | cha�ne |
//  s�rie | liste | suite | enchainement}
// de DET Y
// {dans | en | pour former | pour constituer | donner}
// DET X

(Token{INLIST({"configuration", "construction", "organisation",
               "succession", "cha�ne", "s�rie", "liste", "suite", "enchainement"},
              Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Part)}
(Token{INLIST({"dans", "en", "donner"}, Token.lemma)} |
 (Token.lemma == "pour" Token.lemma == "former") |
 (Token.lemma == "pour" Token.lemma == "constituer"))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Organisation / Organisation")};

//
// D. Action de d�composition d'objets
// -----------------------------------
//

// M75
//Missing: en donnant
// X se
// {analyser | d�composer | d�member | d�sassembler | disjoindre
//  dissocier | d�sagr�ger | s�parer | d�couper | couper | partager |
//  trancher | diviser | fractionner | fragmenter}
// {en | en donnant|pour donner}
// DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == "se"
Token{INLIST({"analyser", "d�composer", "d�membrer", "d�sassembler",
              "disjoindre", "dissocier", "d�sagr�ger", "s�parer", "d�couper",
              "couper", "partager", "trancher", "diviser", "fractionner",
              "fragmenter"},
             Token.lemma)}
Token[0, 3]?
(Token.lemma == "en" |
(Token.lemma == "en" Token.lemma == "donner") |
(Token.lemma == "pour" Token.lemma == "donner")) 
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M76
// {analyser | d�composer | d�membrer | d�sassembler | disjoindre | dissocier
//  d�sagr�ger | s�parer | d�couper | couper | partager | trancher |  
//  diviser | fractionner | fragmenter}
// DET X {en | de} (DET) Y
//

(Token{INLIST({"analyser", "d�composer", "d�membrer", "d�sassembler",
               "disjoindre", "dissocier", "d�sagr�ger", "s�parer",
               "d�couper", "couper", "partager", "trancher",
               "diviser", "fractionner", "fragmenter"},
              Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token{INLIST({"en", "de", "de=le"}, Token.lemma)}
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M77
//{d�membrer/d�sassembler/disjoindre/dissocier/d�sagr�ger/
// s�parer/d�couper/couper/partager/trancher/diviser}
// DET X en (DET) Y 

(Token{INLIST({"d�membrer", "d�sassembler", "disjoindre", "dissocier",
               "d�sagr�ger", "s�parer", "d�couper", "couper",
               "partager", "trancher", "diviser"},
              Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token{INLIST({"en", "de", "de=le"}, Token.lemma)}
(Token.partOfSpeech == "Det")??
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M78
// FIXME: adj/participe
// X (�tre)
// {analys� | d�compos� | d�membr� | d�sassembl� | disjoint |
//  dissoci� | | d�sagr�b� | s�par� | doucp� | coup� | partag� | tranch� |
//  divis� [ fractionn� | fragment�}
// en DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"analyser", "d�composer", "d�membrer", "d�sassembler",
              "disjoint", "dissocier", "d�sagr�ger", "s�parer",
              "d�couper", "couper", "partager", "trancher", "diviser",
              "fractionner", "fragmenter"},
             Token.lemma)}
Token.lemma == "en"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M79
// FIXME: adj/participe
// En
// {analysant | d�composant | d�membrant | d�sassemblant | disjoignant |
//  dissociant | d�sagr�geant | s�parant | d�coupant | coupant | partageant |
//  tranchant | divisant | fractionnant | fragmentant}
// DET X (,) Z {arriver | obtenir} DET Y
// 

(Token.lemma == "en"
Token{INLIST({"analyser", "d�composer", "d�membrer", "d�sassembler",
              "disjoindre", "dissocier", "d�sagr�ger", "s�parer",
              "d�couper", "couper", "partager", "trancher", "diviser",
              "fractionner", "fragmenter"},
             Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.lemma == ","
NominalPhrase {-> MARK(Agent)}
((Token.lemma == "arriver" Token.lemma == "�") | Token.lemma == "obtenir")
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M80
// {d�composition | analyse | d�membrement | d�sint�gration |
//  disjonction | d�coupage | division | fragmentation | �clatement}
// de DET X
// {jusqu'� | afin de | pour} {donner | produire | constituer}
// DET Y
//

(Token{INLIST({"d�composition", "analyse", "d�membrement", "d�sint�gration",
               "disjonction", "d�coupage", "division", "fragmentation",
               "�clatement"},
              Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
((Token.lemma == "jusqu'" Token{INLIST({"�", "�=le"}, Token.lemma)}) |
 (Token.lemma == "afin" Token.lemma == "de") |
 Token.lemma == "pour")
Token{INLIST({"donner", "produire", "constituer"}, Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M81
// {d�composition | analyse | d�membrement | d�sint�gration |
//  disjonction | d�coupage | division | fragmentation | �clatement}
// {jusqu'� | afin de | pour} {donner | produire | constituer}
// DET Y
// � partir de DET X

(Token{INLIST({"d�composition", "analyse", "d�membrement", "d�sint�gration",
               "disjonction", "d�coupage", "division", "fragmentation",
               "�clatement"},
              Token.lemma)}
((Token.lemma == "jusqu'" Token{INLIST({"�", "�=le"}, Token.lemma)}) |
 (Token.lemma == "afin" Token.lemma == "de") |
 Token.lemma == "pour")
Token{INLIST({"donner", "produire", "constituer"}, Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
Token.lemma == "�"
Token.lemma == "partir"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M82
// {d�composition | analyse | d�membrement | d�sint�gration | disjonction |
//  d�coupage | division | fragmentation | �clatement}
// de DET X en DET Y 
//

(Token{INLIST({"d�composition", "analyse", "d�membrement", "d�sint�gration",
               "disjonction", "d�coupage", "division", "fragmention",
               "�clatement"}, 
              Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
Token.lemma == "en"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M83
// {d�composition | analyse | d�membrement | d�sint�gration | disjonction |
//  d�coupage | division | fragmentation | �clatement}
// en DET Y de DET X
//

(Token{INLIST({"d�composition", "analyse", "d�membrement", "d�sint�gration",
               "disjonction", "d�coupage", "division", "fragmention",
               "�clatement"}, 
              Token.lemma)}
Token.lemma == "en"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M84
// Y {r�sulter de | �tre obtenu par | provenir de | venir de} DET
// {d�composition | analyse | d�membrement | d�sint�gration | disjonction |
//  d�coupage | division | fragmentation | �clatement}
// de DET X
//

(NominalPhrase{-> MARK(Part)}
((Token{INLIST({"r�sulter", "provenir", "venir"}, Token.lemma)} Token[0, 3]? (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))))) |
(Token.lemma == "�tre" Token.lemma == "obtenir" Token.lemma == "par"))
Token[0, 3]?
Token.lemma == "de"
Token.partOfSpeech == "Det"
Token{INLIST({"d�composition", "analyse", "d�membrement", "d�sint�gration",
              "disjonction", "d�coupage", "division", "fragmentation",
              "�clament"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


//M85
//DET Y (�tre) DET {r�sultat/produit} de DET {d�composition | analyse | d�membrement | d�sint�gration //disjonction | d�coupage | division | fragmentation | �clatement} de DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "�tre" ??
Token.partOfSpeech == "Det"
Token{INLIST({"d�composition", "analyse", "d�membrement", "d�sint�gration",
              "disjonction", "d�coupage", "division", "fragmentation",
              "�clament"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "D�composition d'objets")};


// E. Types de parties
// -------------------
//

//M86
// Y
// �tre
// DET
// {constituant | composant | composante | ingr�dient | membre | organe |
//  �l�ment | partie | bout | cause | division | fragment | morceau |
//  parcelle | part | pi�ce | portion | �tape | p�riode | phase | stade}
// de (DET) X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "�tre"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
Token{INLIST({"constituer", "constituant", "composer", "composant",
              "ingr�dient", "membre", "organe", "�l�ment", "partie", "bout",
              "cause", "division", "fragment", "morceau", "parcelle", "part",
              "pi�ce", "portion", "�tape", "p�riode", "phase", "stade"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Types de parties")};


//M87
// FIXME: participes
// {constituant | composant | composante | ingr�dient | membre |
//  organe | �l�ment | partie | bout | cause | division | fraction |
//  fragment | morceau | parcelle | part | pi�ce | portion | �tape |
//  p�riode | phase | stade}
// se {trouvant | situant} {dans | de} DET X �tre DET Y
//

(Token{INLIST({"constituer", "constituant", "composer", "composant",
               "ingr�dient", "membre", "organe", "�l�ment", "partie", "bout",
               "cause", "division", "fraction", "fragment", "morceau", "parcelle",
               "part", "pi�ce", "portion", "�tape", "p�riode", "phase", "stade"},
              Token.lemma)}
Token.lemma == "se"
Token{INLIST({"trouver", "situer"}, Token.lemma)}
(Token.lemma == "dans" |
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det")))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
Token.lemma == "�tre"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Types de parties")};


//M88
// Y faire partie de DET X
//
(NominalPhrase{-> MARK(Part)}
Token.lemma == "faire"
Token[0, 3]?
Token.lemma == "partie"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> Whole}
){-> CREATE(Meronymy, "category" = "Types de parties")};

//M89
// Y
// {�tre | former | repr�senter | constituer | consister en}
// DET {sous}
// {cat�gorie | division | esp�ce | sorte | race | ensemble | vari�t� |
//  type | genre | collection | concept | partie | parition}
// de (DET) X
//

(NominalPhrase{-> MARK(Part)}
(Token{INLIST({"�tre", "former", "repr�senter", "constituer"})} |
 (Token.lemma == "consister" Token.lemma == "en"))
Token[0, 3]?
Token.partOfSpeech == "Det"
(Token.lemma == "sous")?
Token{INLIST({"cat�gorie", "division", "esp�ce", "sorte", "race",
              "ensemble", "vari�t�", "type", "genre", "collection",
              "concept", "partie", "paritition"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Types de parties")};


//M90
//X (�tre) {form� | repr�sent� | constitu�} par DET (sous) {cat�gorie | division | esp�ce | sorte | race | ensemble | vari�t� | type | genre | collection | concept | partie | parition} de (DET) Y

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"former", "repr�senter", "constituer"})}
Token.lemma == "par"
Token.partOfSpeech == "Det"
(Token.lemma == "sous")?
Token{INLIST({"cat�gorie", "division", "esp�ce", "sorte", "race",
              "ensemble", "vari�t�", "type", "genre", "collection",
              "concept", "partie", "paritition"},
             Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" (Token.partOfSpeech == "Det")?))
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Types de parties")};


//M91
// X avoir
// {pour | comme}
// {cat�gorie | division | esp�ce | sorte | race | ensemble | vari�t� |
//  type | genre | collection | concept | partie | partition}
// DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token.lemma == "avoir"
Token[0, 3]?
Token{INLIST({"pour", "comme"},
              Token.lemma)}
Token{INLIST({"cat�gorie", "division", "esp�ce", "sorte", "race",
              "ensemble", "vari�t�", "type", "genre", "collection",
              "concept", "partie", "partition"},
             Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Types de parties")};

//
// F. Expression du lieu (r�gion/endroit) et du temps
// --------------------------------------
//

// M92
//Missing: � l'int�rieur de, interne �
//
// Y �tre {� l'int�rieur de | interne �} DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "�tre"
Token[0, 3]?
((Token.lemma == "�" Token.lemma == "le" Token.lemma == "int�rieur" (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))) |
 (Token.lemma == "interne" Token{INLIST({"�", "�=le"}, Token.lemma)}))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/Temps")};

//M93
// X
// {renfermer | contenir | englober | emprisonner | loger | incorporer | abriter}
// DET Y
//

(NominalPhrase{-> MARK(Whole)}
Token{INLIST({"renfermer", "contenir", "englober", "emprisonner", "loger",
              "incorporer", "abriter"},
             Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};


//M94
// Y {entourer | d�limiter | circonscrire} DET X
//

(NominalPhrase{-> MARK(Part)}
Token{INLIST({"entourer", "d�limiter", "circonscrire"},
             Token.lemma)}
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};


//M95
// X (�tre) {entour� | d�limit� | circonscrit} par DET Y
//

(NominalPhrase{-> MARK(Whole)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"entourer", "d�limiter", "circonscrire"},
             Token.lemma)}
Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Part)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};


//M96
// Y
// {former | repr�senter | constituer | consister en}
// DET
// {membrane | enveloppe | peau | �corce | limite | gaine | bord | bordure | fronti�re}
// (autour) de DET X
//

(NominalPhrase{-> MARK(Part)}
(Token{INLIST({"former", "repr�senter", "constituer"}, Token.lemma)} |
 (Token.lemma == "consister" Token.lemma == "en"))
Token[0, 3]?
Token.partOfSpeech == "Det"
Token{INLIST({"membrane", "enveloppe", "peau", "�corce", "limite", "gaine",
              "bord", "bordure", "fonti�re"},
              Token.lemma)}
(Token.lemma == "autour")??
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};


//M97
// FIXME: participes
// Y (�tre)
// {situ� | localis� | plac� | positionn� | ins�r� | install� | pos� |
//  accroch� | dispos� | fix� | scell� | attach� | log�}
// {dans | � l'interieur de}
// DET X
//
(NominalPhrase{-> MARK(Part)}
(Token.lemma == "�tre")??
Token[0, 3]?
Token{INLIST({"situer", "localiser", "placer", "positionner", "ins�rer",
              "installer", "poser", "accrocher", "disposer", "fixer",
              "sceller", "attacher", "loger"},
             Token.lemma)}
(Token.lemma == "dans" |
 (Token.lemma == "�" Token.lemma == "le" Token.lemma == "interieur"
  Token{INLIST({"de", "de=le"}, Token.lemma)}))
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};

//M98
// Y
// {stationner | baigner | figurer | rester | stagner}
// dans DET X
//

(NominalPhrase{-> MARK(Part)}
Token{INLIST({"stationner", "baigner", "figurer", "rester",
              "stagner"},
             Token.lemma)}
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};


//M99
// Y �tre dans DET X
//

(NominalPhrase{-> MARK(Part)}
Token.lemma == "�tre"
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Whole)}
){-> CREATE(Meronymy, "category" = "Expression du lieu/temps")};

//
// 2.3 Relation de cause
// =====================
//

//
// A. Verbes-candidats et nominalisation d�verbales
// ------------------------------------------------
//

//
// i. Pr�cision sur l'intervention de la cause
//

//
// /contribuer �/
//

//
// DET X avoir pour r�le DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "avoir"
Token[0, 3]?
Token.lemma == "pour"
Token.lemma == "r�le"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
  Causality,
  "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};

//C001
// DET X concourir � DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "concourir"
Token[0, 3]?
Token{INLIST({"�", "�=le"}, Token.lemma)}
Token.lemma == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};

//C002
// DET X contribuer � (DET) Y
//

(Token.lemma == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "contribuer"
Token[0, 3]?
Token{INLIST({"�", "�=le"}, Token.lemma)}
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};

//C003
// DET X intervenir dans DET Y
//

(Token.lemma == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "intervenir"
Token[0, 3]?
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};

// C004
//FIXE: participe
//
// DET X �tre impliqu� dans DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "�tre"
Token[0, 3]?
Token.lemma == "impliquer"
Token.lemma == "dans"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};


//C005
// DET X participer {�, dans} (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "participer"
Token[0, 3]?
Token{INLIST({"�", "�=le", "dans"}, Token.lemma)}
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};

//Nm001
// Concours de DET X (� DET Y)
//

(Token.lemma == "concours"
Token.lemma == "de"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
(Token{INLIST({"�", "�=le"}, Token.lemma)}
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
 ){-> CREATE(
     Causality,
     "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
 )};
 
//Nm002
// Contribution de DET X (� DET Y)
//

(Token.lemma == "contribution"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
(Token.lemma == "�"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
 ){-> CREATE(
     Causality,
     "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
 )}
 
 //Nm003
 // Intervention de DET X (dans DET Y)
 //
 
(Token.lemma == "intervention"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
Token.partOfSpeech == "Det"
(Token.lemma == "dans"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
 ){-> CREATE(
     Causality,
     "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
 )}

//Nm004
// {implication | implicature | impliquement}
// de DET X (dans DET Y)
//

(Token{INLIST({"implication", "implicature", "impliquement"},
              Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
(Token.lemma == "dans"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)}

//Nm005
// participation de DET X ({� | dans} DET Y)
//

(Token.lemma == "participation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
(Token{INLIST({"�", "dans"}, Token.lemma)}
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Intervention de la cause / contribuer"
)};


//
// ii. Pr�cision sur la nature de l'effet
//
 
//
// Cr�ation d'une situation nouvelle
//
 
//
// /pousser �/
//

//C006
// DET X encourager (�) (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "encourager"
Token[0, 3]?
(Token.lemma == "�")?
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / pousser"
)};

//C007
// DET X engager � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "engager"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / pousser"
)};

//C008
// DET X pousser � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "pousser"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> Effect}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / pousser"
)};

//C009
// DET X porter � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "porter"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / pousser"
)};

//C010
// DET X inciter � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "inciter"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / pousser"
)};

//Nm010
// incitation � DET Y ({par | de} DET X)
//

(Token.lemma == "incitation"
 Token.lemma == "�"
 Token.partOfSpeech == "Det"
 ((Token.lemma == "par" Token.partOfSpeech == "Det") |
  (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det")))
 NominalPhrase{-> MARK(Effect)}
 (NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / pousser"
)};

//
// /cr�er/
//
 
//C011
// DET X aboutir � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "aboutir"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};
 
//C012
// DET X amener � (DET) Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "amener"
Token[0, 3]?
    Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C013
// DET X assurer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "assurer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C014
// DET X causer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "causer"
Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};


//C015
// DET X conduire � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "conduire"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C016
// DET X contraindre � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "contraindre"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C017
// DET X cr�er DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "cr�er"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C018
// DET X d�boucher sur DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "d�boucher"
Token[0, 3]?
Token.lemma == "sur"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C019
// DET X d�cha�ner DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "d�cha�ner"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C020
// DET X d�clencher DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "d�clencher"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C021
// DET X engendrer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "engendrer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C022
// DET X g�n�rer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "g�n�rer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C023
// DET X entrainer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "entrainer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};


//C024
// DET Y h�riter de DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "h�riter"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C025
// DET X impliquer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "impliquer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C026
// DET X induire DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "induire"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C027
// DET X mener � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "mener"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C028
// DET X obliger � (DET) Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "obliger"
Token[0, 3]?
Token.lemma == "�"
(Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C029
// DET X occasionner DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "occasionner"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};


//C030
// DET X procurer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "procurer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C031
// DET X produire DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "produire"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C032
// DET X provoquer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "provoquer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C033
// DET X relancer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "relancer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C034
// DET Y reposer sur DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
Token.lemma == "reposer"
Token[0, 3]?
Token.lemma == "sur"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C035
// DET X soulever DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "soulever"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C036
// DET X susciter DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "susciter"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C037
// DET Y �maner de DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
Token.lemma == "�maner"
Token[0, 3]?
Token.lemma == "de"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C038
// DET Y proc�der de DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
Token.lemma == "proc�der"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C039
// DET Y provenir de DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
Token.lemma == "provenir"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C040
// DET Y venir de DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
Token.lemma == "venir"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C041
// DET Y d�couler de DET X
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
Token.lemma == "d�couler"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C042
// DET Y r�sulter de DET X
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Effect)}
    Token.lemma == "r�sulter"
    Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//C043
// DET Y se traduire par DET X
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Effect)}
    Token.lemma == "se"
    Token.lemma == "traduire"
    Token[0, 3]?
     Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm011
// aboutissement � DET Y ({par | de} DET X)
//

(Token.lemma == "aboutissement"
Token.lemma == "�"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
((Token.lemma == "par" Token.partOfSpeech == "Det") |
 (Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det")))
(NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm017
// cr�ation de DET Y (par DET X)
//

(Token.lemma == "cr�ation"
Token.lemma == "de"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm018
// d�bouchage de DET Y (sur DET X)
//

(Token.lemma == "d�bouchage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "sur"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//
// d�cha�nement de DET Y (par DET X)
//

(Token.lemma == "d�cha�nement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm020
// d�clenchement de DET Y (par DET X)
//

(Token.lemma == "d�clenchement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm021
// engendrement de DET Y (par DET X)
//

(Token.lemma == "engendrement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm023
// g�n�ration de DET Y (par DET X)
//

(Token.lemma == "g�n�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm024
// h�ritage de DET Y (par DET X)
//

(Token.lemma == "h�ritage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};


//Nm025
// {implication | implicature | impliquement}
// de DET Y (par DET X)
//

(Token{INLIST({"implication", "implicateur", "impliquement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm026
// induction de DET Y (par DET X)
//

(Token.lemma == "induction"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm031
// production de DET Y (par DET X)
//

(Token.lemma == "production"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm033
// relance de DET Y (par DET X)
//

(Token.lemma == "relance"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//
// repos de DET Y (sur DET X)
//

(Token.lemma == "repos"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "sur"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm035
// soul�vement de DET Y (par DET X)
//

(Token.lemma == "soul�vement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm036
// {suscitation | suscitement}
// de Y (par DET X)
//

(Token{INLIST({"suscitation", "suscitement"}, Token.lemma)}
Token.lemma == "de"
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm041
// d�coulement de DET Y ({de | par} DET X)
//

(Token.lemma == "d�coulement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token{INLIST({"de", "par"}, Token.lemma)}
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//Nm043
// traduction de DET Y (par DET X)
//

(Token.lemma == "traduction"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / cr�er"
)};

//
// /entretenir/
//

//C044
// DET X conserver DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "converver"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C045
// DET X contenir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "contenir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C046
// DET X contr�ler DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "contr�ler"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C047
// DET X entretenir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "entretenir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C048
// DET X �quilibrer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "�quilibrer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C049
// DET X garder DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "garder"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C050
// DET X maintenir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "maintenir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C051
// DET X ma�triser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "ma�triser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C052
// DET X m�nager DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "m�nager"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C053
// DET X perp�tuer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "perp�tuer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C054
// DET X pr�server DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "pr�server"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C055
// DET X prolonger DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "prolonger"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}){-> MARK(Causality)};

//C056
// DET X prot�ger DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "prot�ger"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C057
// DET X sauvegarder DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "sauvegarder"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//C058
// DET X stabiliser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "stabiliser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//Nm044
// {conservation | conserve} de DET Y (par DET X)
//

(Token{INLIST({"conservation", "conserve"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
 
 //Nm046
 // contr�le de DET Y (par DET X)
 //
 
(Token.lemma == "contr�le"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//Nm047
// entretien de DET Y (par DET X)
//

(Token.lemma == "entretien"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
 //Nm048
 // {�quilibrage | �quilibration} de DET Y (par DET X)
 //
 
 (Token{INLIST({"�quilibrage", "�quilibration"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
 NominalPhrase{-> MARK(Effect)}
 (Token.lemma == "par"
     Token.partOfSpeech == "Det"
     NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//
// Garde de DET Y (par DET X)
//

(Token.lemma == "garde"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//Nm050
// {maintenance | maintien} de DET Y (par DET X)
//
 
(Token{INLIST({"maintenance", "maintien"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//Nm051
// ma�trise de DET Y (par DET X)
//

(Token.lemma == "ma�trise"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//
// m�nagement de DET Y (par DET X)
//

(Token.lemma == "m�nagement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//Nm053
// {perp�tuation | perp�tuement} de DET Y (par DET X)
//
 
(Token{INLIST({"perp�tuation", "perp�tuement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//Nm054
// pr�servation de DET Y (par DET X)
//

(Token.lemma == "pr�servation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//Nm055
// {prolongation | prolongement} de DET Y (par DET X)
//
 
(Token{INLIST({"prolongation", "prolongement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//Nm056
// {protection | prot�gement} de DET Y (par DET X)
//
 
(Token{INLIST({"protection", "prot�gement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//Nm057
// sauvegarde de DET Y (par DET X)
//

(Token.lemma == "sauvegarde"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};
    
//Nm058
// stabilisation de DET Y (par DET X)
//

(Token.lemma == "stabilisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / entretenir"
)};

//
// /arr�ter d'entretenir/
//

//C059
// DET X arr�ter DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "arr�ter"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//C060
// DET X cesser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "cesser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//C061
// DET X d�livrer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�livrer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//C062
// DET X lib�rer de DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "lib�rer"
    Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//
// DET X terminer de DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "terminer"
    Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//Nm059
// arr�t de DET Y (par DET X)
//

(Token.lemma == "arr�t"
Token[0, 3]?
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//Nm060
// {cessation, cesse} de DET Y (par DET X)
//

(Token{INLIST({"cessation", "cesse"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//Nm061
// {d�livrement} de DET Y (par DET X)
//

(Token.Lemma == "d�livrement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//Nm062
// lib�ration de DET Y (par DET X)
//

(Token.lemma == "lib�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//
// terminaison de DET Y (par DET X)
//

(Token.lemma == "terminaison"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / arr�ter d'entretenir"
)};

//
// ANNIHILATION D'UNE SITUATION PREALABLEMENT REALISEE
//

//
// /s'opposer �/
//

//C063
// Det X contrarier DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "contrarier"
Token[0, 3]?
Token.partOfSpeech == "Det"
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};

//C064
// Det X contrecarrer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "contrecarrer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};

//C065
// Det X s'opposer DET Y
//
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    (Token.lemma == "se")?
    Token.lemma == "opposer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};

//
// Det X (se) confronter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    (Token.lemma == "se")?
    Token.lemma == "confronter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};

//C066
// Det X se heurter � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "se"
    Token.lemma == "heurter"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};

//Nm065
// Opposition de DET X (� DET Y)
//

(Token.lemma == "opposition"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
(Token.lemma == "�"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};

//
// confrontation de DET X (� DET Y)
//

(Token.lemma == "confrontation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
(Token.lemma == "�"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Effect)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / s'opposer �"
)};
 
//
// /annihiler/
//

//C067
// DET X abolir DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "abolir"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//C068
// DET X annuler DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "annuler"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//C069
// DET X arr�ter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "arr�ter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//C070
// DET X couper DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "couper"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//C071
// DET X �liminer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "�liminer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//C072
// DET X stopper DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "stopper"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//Nm067
// {abolissement } de DET Y (par DET X)
//

(Token.lemma == "abolissement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//Nm068
// annulation de DET Y (par DET X)
//

(Token.lemma == "annulation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//Nm069
// arr�t de DET Y (par DET X)
//

(Token.lemma == "arr�t"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//Nm070
// {coupe | coupure} de DET Y (par DET X)
//

(Token{INLIST({"coupe", "coupure"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};

//Nm071
// �limination de DET Y (par DET X)
//

(Token.lemma == "�limination"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};


//Nm072
// stoppage de DET Y (par DET X)
//

(Token.lemma == "stoppage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / annihiler"
)};
 
//
// /bloquer/
//

//C073
// DET X apaiser DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "apaiser"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
)};

//C074
// DET X barrer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "barrer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
)};

//C075
// DET X bloquer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "bloquer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C076
// DET X brider DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "brider"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C077
// DET X calmer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "calmer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C078
// DET X coincer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "coincer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C079
// DET X contenir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "contenir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C080
// DET X endiguer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "endiguer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C081
// DET X �touffer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "�touffer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C082
// DET X figer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "figer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C083
// DET X fixer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "fixer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C084
// DET X geler DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "geler"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C085
// DET X immobiliser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "immobiliser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C086
// DET X ob�rer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "ob�rer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C087
// DET X paralyser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "paralyser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C088
// DET X supprimer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "supprimer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//C089
// DET X suspendre DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "suspendre"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm073
// apaisement de DET Y (par DET X)
//

(Token.lemma == "apaisement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm074
// barrage de DET Y (par DET X)
//

(Token.lemma == "barrage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm075
// {blocage | bloc | bloquage} de DET Y (par DET X)
//

(Token{INLIST({"blocage", "bloc", "bloquage"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm076
// bridage de DET Y (par DET X)
//

(Token.lemma == "bridage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm080
// {endigage | endiguage | endiguement} de DET Y (par DET X)
//

(Token{INLIST({"endigage", "endiguage", "endiguement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm081
// �touffement de DET Y (par DET X)
//

(Token.lemma == "�touffement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm082
// figement de DET Y (par DET X)
//

(Token.lemma == "figement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm083
// fixation de DET Y (par DET X)
//

(Token.lemma == "fixation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm084
// gel de DET Y (par DET X)
//

(Token.lemma == "gel"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm085
// immobilisation de DET Y (par DET X)
//

(Token.lemma == "immobilisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm087
// {paralysation | paralysie} de DET Y (par DET X)
//

(Token{INLIST({"paralysation", "paralysie"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm088
// suppression de DET Y (par DET X)
//

(Token.lemma == "suppression"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//Nm089
// suspension de DET Y (par DET X)
//

(Token.lemma == "suspension"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / bloquer"
    )};

//
// /d�bloquer/
//

//C090
// Det X abandonner DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "abandonner"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//C091
// Det X arr�ter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "arr�ter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//C092
// Det X d�bloquer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�bloquer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//C093
// Det X d�gager DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�gager"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//C094
// Det X lib�rer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "lib�rer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//C095
// Det X renoncer � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "renoncer"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//Nm090
// abandon de DET Y (par DET X)
//

(Token.lemma == "abandon"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//Nm091
// arr�t de DET Y (par DET X)
//

(Token.lemma == "arr�t"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//Nm092
// {d�blocage | d�bloquage} de DET Y (par DET X)
//

(Token{INLIST({"d�blocage", "d�bloquage"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//Nm093
// d�gagement de DET Y (par DET X)
//

(Token.lemma == "d�gagement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//Nm094
// lib�ration de DET Y (par DET X)
//

(Token.lemma == "lib�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};

//Nm095
// {renoncement, renonciation} {de | �} DET Y (par DET X)
//

(Token{INLIST({"renoncement", "renonciation"}, Token.lemma)}
((Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det")) |
 (Token.lemma == "�" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / d�bloquer"
)};
    
//
// POSSIBILITE DE REALISATION D'UNE SITUATION
//
 
//
// /emp�cher/
//

//C096
// Det X d�jouer � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�jouer"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//C097
// Det X emp�cher � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "emp�cher"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//C098
// Det X �viter � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "�viter"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//C099
// Det X interdire � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "interdire"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//C100
// Det X pr�venir � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "pr�venir"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//Nm098
// �vitement de DET Y (par DET X)
//

(Token.lemma == "�vitement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//Nm099
// {interdiction | interdit} de DET Y (par DET X)
//

(Token{INLIST({"interdiction", "interdit"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};

//Nm100
// pr�vention de DET Y (par DET X)
//

(Token.lemma == "pr�vention"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / emp�cher"
)};
 
//
// /g�ner/
//

//C101
// DET X affecter DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "affecter"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
)};

//C102
// DET X affaiblir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "affaiblir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C103
// DET X alt�rer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "alt�rer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C104
// DET X amenuiser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "amenuiser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C105
// DET X amortir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "amortir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C106
// DET X att�nuer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "att�nuer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C107
// DET X bouleverser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "bouleverser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C108
// DET X brouiller DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "brouiller"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C109
// DET X crisper DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "crisper"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C110
// DET X d�grader DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�grader"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C111
// DET X d�ranger DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�ranger"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C112
// DET X d�sorganiser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�sorganiser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C113
// DET X d�structurer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�structurer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C114
// DET X diminuer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "diminuer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C115
// DET X enrayer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "enrayer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C116
// DET X entraver DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "entraver"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C117
// DET X estomper DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "estomper"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C118
// DET X freiner DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "freiner"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C119
// DET X g�ner DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "g�ner"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C120
// DET X limiter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "limiter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C121
// DET X parasiter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "parasiter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C121
// DET X p�naliser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "p�naliser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C122
// DET X perturber DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "perturber"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C123
// DET X ralentir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "ralentir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C124
// DET X r�duire DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "r�duire"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C125
// DET X retarder DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "retarder"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C126
// DET X troubler DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "troubler"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C127
// DET X mettre � mal DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "mettre"
    Token[0, 3]?
    Token.lemma == "�"
    Token.lemma == "mal"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//C129
// DET X nuire � DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "nuire"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//Nm101
// affection de DET Y (par DET X)
//

(Token.lemma == "affection"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
 
//Nm102
// affaiblissement de DET Y (par DET X)
//
 
(Token.lemma == "affaiblissement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//Nm103
// alt�ration de DET Y (par DET X)
//
 
(Token.lemma == "alt�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm104
// amenuisement de DET Y (par DET X)
//
 
(Token.lemma == "amenuisement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};


//Nm105
// {amortissage | amortissement} de DET Y (par DET X)
//
 
(Token{INLIST({"amortissage", "amortissement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm106
// {att�nuance | att�nuation} de DET Y (par DET X)
//
 
(Token{INLIST({"att�nuance", "att�nuation"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//Nm107
// bouleversement de DET Y (par DET X)
//
 
(Token.lemma == "bouleversement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm108
// {brouillage | brouillement} de DET Y (par DET X)
//
 
(Token{INLIST({"brouillage", "brouillement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm109
// crispation de DET Y (par DET X)
//
 
(Token.lemma == "crispation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm110
// {d�gradement | d�gradation} de DET Y (par DET X)
//
 
(Token{INLIST({"d�gradement", "d�gradation"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm111
// d�rangement de DET Y (par DET X)
//
 
(Token.lemma == "d�rangement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm112
// d�sorganisation de DET Y (par DET X)
//
 
(Token.lemma == "d�sorganisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm113
// d�structuration de DET Y (par DET X)
//
 
(Token.lemma == "d�structuration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm114
// diminution de DET Y (par DET X)
//
 
(Token.lemma == "diminution"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};

//Nm115
// {enraiement | enrayement | enrayage} de DET Y (par DET X)
//
 
(Token{INLIST({"enraiement", "enrayement", "enrayage"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )}; 
    
//Nm116
// entravement de DET Y (par DET X)
//
 
(Token.lemma == "diminution"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm117
// estompage de DET Y (par DET X)
//
 
(Token.lemma == "estompage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm118
// freinage de DET Y (par DET X)
//
 
(Token.lemma == "freinage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm120
// limitation de DET Y (par DET X)
//
 
(Token.lemma == "limitation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm121
// parasitage de DET Y (par DET X)
//
 
(Token.lemma == "parasitage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm122
// p�nalisation de DET Y (par DET X)
//
 
(Token.lemma == "parasitage"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm123
// perturbation de DET Y (par DET X)
//
 
(Token.lemma == "perturbation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm124
// {ralenti | ralentissement} de DET Y (par DET X)
//
 
(Token{INLIST({"ralenti", "ralentissement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm125
// r�duction de DET Y (par DET X)
//
 
(Token.lemma == "r�duction"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm126
// {retardation | retardement | retard} de DET Y (par DET X)
//
 
(Token{INLIST({"retardation", "retardement", "retard"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm127
// troublement de DET Y (par DET X)
//
 
(Token.lemma == "troublement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//Nm129
// nuisance de DET Y (par DET X)
//
 
(Token.lemma == "nuisance"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / g�ner"
    )};
    
//
// /laisser faire/
//
 
//C130
// DET X autoriser (�) DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "autoriser"
Token[0, 3]?
(Token.lemma == "�")?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//C131
// DET X laisser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "laisser"
    Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//C132
// DET X laisser subsister DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "laisser"
    Token[0, 3]?
    Token.lemma == "subsister"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//C133
// DET X permettre DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "permettre"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//C134
// DET X respecter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "respecter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//C135
// DET X tol�rer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "tol�rer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//Nm130
// autorisation (de DET X) � DET Y
//

(Token.lemma == "autorisation"
((Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)})?
Token.lemma == "�"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//Nm133
// permission de DET Y (par DET X)
//

(Token.lemma == "permission"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Cause)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Effect)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//Nm135
// tol�rance de DET Y (par DET X)
//

(Token.lemma == "tol�rance"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
(Token.lemma == "par"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / laisser faire"
    )};

//
// /faciliter/
//

//C136
// DET X acc�l�rer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "acc�l�rer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C137
// DET X accentuer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "accentuer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C138
// DET X accro�tre DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "accro�tre"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C139
// DET X aggraver DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "aggraver"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C140
// DET X aider DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "aider"
    Token[0, 3]?
    Token.lemma == "�"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C141
// DET X alimenter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "alimenter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C142
// DET X am�liorer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "am�liorer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C143
// DET X amplifier DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "amplifier"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C144
// DET X appuyer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "appuyer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C145
// DET X assister DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "assister"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C146
// DET X augmenter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "augmenter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C147
// DET X avantager DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "avantager"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C148
// DET X aviver DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "aviver"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C149
// DET X b�n�ficier � (DET) Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "b�n�ficier"
    Token[0, 3]?
    Token.lemma == "�"
    (Token.partOfSpeech == "Det")?
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C150
// DET X catalyser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "catalyser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C151
// DET X consolider DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "consolider"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C152
// DET X d�velopper DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "d�velopper"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C153
// DET X dynamiser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "dynamiser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C154
// DET X �toffer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "�toffer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C155
// DET X exacerber DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "exacerber"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C156
// DET X faciliter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "faciliter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C157
// DET X favoriser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "favoriser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C158
// DET X fortifier DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "fortifier"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C159
// DET X intensifier DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "intensifier"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C160
// DET X motiver DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "motiver"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C161
// DET X pr�cipiter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "pr�cipiter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C162
// DET X privil�gier DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "privil�gier"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C163
// DET X profiter DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "profiter"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C164
// DET X promouvoir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "promouvoir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C165
// DET X rehausser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "rehausser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C166
// DET X servir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "servir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C167
// DET X soulager DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "soulager"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C168
// DET X soutenir DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "soutenir"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C169
// DET X stimuler DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "stimuler"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//C170
// DET X valoriser DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "valoriser"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//Nm136
// acc�l�ration de DET Y (par DET X)
//

(Token.lemma == "acc�l�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
 
//Nm137
// accentuation de DET Y (par DET X)
//

(Token.lemma == "acc�l�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm138
// accroissement de DET Y (par DET X)
//

(Token.lemma == "accroissement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm139
// {aggravation | aggravement} de DET Y (par DET X)
//

(Token{INLIST({"aggravation", "aggravement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm140
// Aide (de DET X) � DET Y
//

(Token.lemma == "aide"
((Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)})?
Token.lemma == "�"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//Nm141
// alimentation de DET Y (par DET X)
//

(Token.lemma == "alimentation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};

//Nm142
// am�lioration de DET Y (par DET X)
//

(Token.lemma == "am�lioration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm143
// amplification de DET Y (par DET X)
//

(Token.lemma == "amplification"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm144
// {appuiement | appui} de DET Y (par DET X)
//

(Token{INLIST({"appuiement", "appui"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm146
// augmentation de DET Y (par DET X)
//

(Token.lemma == "augmentation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm148
// {avivage | avivement} de DET Y (par DET X)
//

(Token{INLIST({"avivage", "avivement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm150
// catalyse de DET Y (par DET X)
//

(Token.lemma == "catalyse"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm151
// {consolidation | consolidement} de DET Y (par DET X)
//

(Token{INLIST({"consolidation", "consolidement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm152
// d�veloppement de DET Y (par DET X)
//

(Token.lemma == "d�veloppement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm153
// dynamisation de DET Y (par DET X)
//

(Token.lemma == "dynamisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm154
// �toffement de DET Y (par DET X)
//

(Token.lemma == "�toffement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm155
// exacerbation de DET Y (par DET X)
//

(Token.lemma == "exacerbation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm156
// facilitation de DET Y (par DET X)
//

(Token.lemma == "facilitation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm157
// favorisation de DET Y (par DET X)
//

(Token.lemma == "favorisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm158
// fortification de DET Y (par DET X)
//

(Token.lemma == "fortification"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm159
// intensification de DET Y (par DET X)
//

(Token.lemma == "intensification"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm160
// motivation de DET Y (par DET X)
//

(Token.lemma == "motivation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm161
// {pr�cipitation | pr�cipitement} de DET Y (par DET X)
//

(Token{INLIST({"pr�cipitation", "pr�cipitement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm164
// promotion de DET Y (par DET X)
//

(Token.lemma == "promotion"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm165
// {r�haussement | r�hausse} de DET Y (par DET X)
//

(Token{INLIST({"r�haussement", "r�hausse"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm166
// service de DET Y (par DET X)
//

(Token.lemma == "service"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm167
// soulagement de DET Y (par DET X)
//

(Token.lemma == "soulagement"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm168
// {soutenance | soutien} de DET Y (par DET X)
//

(Token{INLIST({"soutenance", "soutien"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm169
// stimulation de DET Y (par DET X)
//

(Token.lemma == "stimulation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//Nm170
// valorisation de DET Y (par DET X)
//

(Token.lemma == "valorisation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Effect)}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / faciliter"
)};
    
//
// INFLUENCE SUR UNE SITUATION
//

//
// /influencer/
//

//C171
// DET X changer DET Y
//

(Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
Token.lemma == "changer"
Token[0, 3]?
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};

//C172
// DET X corriger DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "corriger"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C173
// DET X influencer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "influencer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C174
// DET X influer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "influer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C175
// DET X mod�rer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "mod�rer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C176
// DET X modifier DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "modifier"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C177
// DET X moduler DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "moduler"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C178
// DET X peser sur DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "peser"
    Token[0, 3]?
    Token.lemma == "sur"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C179
// DET X r�volutionner DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "r�volutionner"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//C180
// DET X transformer DET Y
//

(Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
    Token.lemma == "transformer"
    Token[0, 3]?
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Effect)}
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm171
// {changement | change} de DET Y (par DET X)
//

(Token{INLIST({"changement", "change"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> Effect}
(Token.lemma == "par"
 Token.partOfSpeech == "Det"
 NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm172
// correction de DET Y (par DET X)
//

(Token.lemma == "correction"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm173
//Nm174
// influence de DET Y (par DET X)
//

(Token.lemma == "influence"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm175
// mod�ration de DET Y (par DET X)
//

(Token.lemma == "mod�ration"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm176
// modification de DET Y (par DET X)
//

(Token.lemma == "modification"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm177
// {modulage | modulation} de DET Y (par DET X)
//

(Token{INLIST({"modulage", "modulation"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm178
// pes�e de DET Y (par DET X)
//

(Token.lemma == "peser"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm179
// {r�volution | r�volutionnement} de DET Y (par DET X)
//

(Token{INLIST({"r�volution", "r�volutionnement"}, Token.lemma)}
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};


//Nm180
// transformation de DET Y (par DET X)
//

(Token.lemma == "transformation"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> Effect}
(Token.lemma == "par"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)})?
){-> CREATE(
    Causality,
    "category" = "Verbes et nominalisation d�verbale / Nature de l'effet / influencer"
)};

//
// B. Pr�positions
// ---------------
//

//
// Y du fait de DET X
//

(NominalPhrase{-> MARK(Effect)}
Token.lemma == "de=le"
Token.lemma == "fait"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
)};


//
// Y � cause de DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "�"
    Token.lemma == "cause"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
    )};

//
// Y gr�ce � DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "gr�ce"
    Token.lemma == "�"
Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
    )};

//
// Y en raison de DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "en"
    Token.lemma == "raison"
    Token.lemma == "de"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
    )};

//
// Y par DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "par"
    Token.partOfSpeech == "Det"
NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
    )};

// TODO:
// Y pour DET X (dans la construction <participe pass� + pour ...>
//

//
// Y avec DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "avec"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
    )};

//
// Y au moment de DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "au"
    Token.lemma == "moment"
(Token.lemma == "de=le" | (Token.lemma == "de" Token.partOfSpeech == "Det"))
    NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
    )};
    
//
// Y pendant DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "pendant"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
)};

//
// Y apr�s DET X
//

(NominalPhrase{-> MARK(Effect)}
    Token.lemma == "apr�s"
    Token.partOfSpeech == "Det"
    NominalPhrase{-> MARK(Cause)}
){-> CREATE(
    Causality,
    "category" = "Pr�positions"
)};