1. Il faut donc prendre un mot quelconque du langage des expressions arithmétique et montrer qu'il ne peut pas y avoir deux arbres de dérivation différents menant à α. Plus précisément on considère un mot α, tel que Σ ⇒*α où Σ est un non-terminal et on montre qu'il n'existe pas d'autre arbre de racine Σ et dont les feuilles lues de gauche à droite forment α.

    Le resultat est immédiat pour Σ = F, car il n'y qu'une seule production.

    Considérons P. Une ambiguïté éventuelle porte d'abord sur le choix d'une des trois production. Soit :
    Ou encore :
    Mais ces deux cas sont impossibles, car un mot dérivé de F ne saurait contenir le symbole *, et l'avant dernier terminal de α impose la production.

    En toute complétude il faut aussi considérer le cas ou l'application d'une production peut se faire de deux manières différentes. Ici c'est impossible car F ne peut être qu'un int et donc l'avant dernier symbole de α determine non seulement une production unique, mais aussi une façon unique de l'utiliser.

    Pour bien comprendre le problème, on peut caractériser l'ambiguïté dite d'associativité de la première gramaire ainsi :

    On montre ensuite que les arbres de racine E sont pareillement déterminés ce qui entraîne la non-ambiguïté.

  2. Il suffit d'introduire ces nouvelles constructions comme de nouvelles productions de F.
    S → E
     
    E → P          E → E + P          E → E - P
     
    P → F          P → P * F          P → P / F
     
    F → int          F → + F          F → - F          F → ( E )
    Les productions F → + F et F → - F expriment que l'application des opérateurs unaires est plus prioritaire que celle des opérateurs binaires. La production F → ( E ) s'explique par la règle « on calcule d'abord à l'intérieur des parenthèses », par ailleurs, on doit pouvoir mettre une expression arbiraires entre parenthèses. On peut encore écrire l'analyse en s'inspirant des règles et de fait il suffit de mofifier parseF.
      private String parseF() {
            switch (tok.nature) {
            case Token.SUB:
              Token op = tok ;
          step() ;
              return echo ("0", op,  parseF()) ;
            case Token.ADD:
          step() ;
              return parseF() ;
            case Token.OPAR:
          step() ;
              String r = parseE() ;
              if (tok.nature != Token.CPAR) error(")", tok) ;
          step() ;
              return r ;
            default:
              return readInt() ;
        }
      }

    Prouvons maintenant la non-ambiguïté, qui semble bien assurée car nous utilisons quotidiennement cette grammaire sans quiproquo aucun.

    Soit donc un mot α dérivé d'un non-terminal Σ. Le cas Σ = F est facile, le premier symbole du flux déterminant le choix d'une production.

    On considère ensuite seulement un example.
    On ne peut pas s'en tirer comme précédemment, car cette fois un mot dérivé de F peut contenir le terminal *.

    On se sert d'un lemme de bon-parenthésage. On peut montrer facilement que tout mot dérivé α d'un non-terminal comprend autant de parenthèses ouvrantes que fermantes. Mais plus précisément, tout préfixe de α contient plus (au sens large) d'ouvrantes que de fermantes, tandis que tout suffixe de α contient moins (toujours au sens large) d'ouvrantes que de fermantes.

    En cas d'ambiguïté, donc, on est en raison de la nécessaire parenthèse fermante qui termine le mot α, et de la parenthèse ouvrante qui le commence presque, nécessairement dans le cas suivant.

    Autrement dit, α se décompose nécessairement d'une part en β ( η ) γ et d'autre part en β ( η' ) où β est une suite peut-être vide de + et de -, tandis que η et η' dérivent de E. Soit η ) est un préfixe de η'. Or η ) contient une fermante de plus que d'ouvrantes, contradiction.

  3. Donc deux premières séries de productions.
    O → O + int          O → int
     
    S → int + S          S → int
     
    Puis une dernière série qui se détermine en fonction d'un symbole situé à la fin.
    E → O *          E → S /
    Il est clair que cette grammaire n'est pas ambigüe (la preuve est essentiellement la même que pour les grammaires d'Oscar et de Samir). Mais en écrivant la méthode correspondant à E, on ne peut connaître quelle méthode appeler avant que cette dernière aie retourné.

    Ici, on peut s'en tirer en lisant de droite à gauche, mais c'est s'éloigner de principe du flux. Par ailleurs, ça ne fonctionnera pas toujours. Considérer par exemple :
    E → O * S          E → S / O