Il existe (au moins) une façon de prouver l’ambiguïté d’une grammaire pourlangage L . Il se compose de deux étapes:G=(N,T,δ,S)L
- Prouver .L⊆L(G)
- Prouver .[zn]SG(z)=|Ln|
La première étape est assez claire: montrez que la grammaire génère (au moins) les mots que vous voulez, c'est l'exactitude.
La deuxième étape montre que a autant d'arbres de syntaxe pour les mots de longueur n que L a de mots de longueur n - avec 1. cela implique une ambiguïté. Il utilise la fonction de structure de G qui remonte à Chomsky et Schützenberger [1], à savoirGnLnG
SG(z)=∑n=0∞tnzn
avec le nombre d'arbres de syntaxe G a pour les mots de longueur n . Bien sûr, vous devez avoir | L n | pour que cela fonctionne.tn=[zn]SG(z)Gn|Ln|
La bonne chose est que est (généralement) facile à obtenir pour les langages sans contexte, bien que trouver une forme fermée pour t n puisse être difficile. Transformez G en un système d'équations de fonctions avec une variable par non terminal:SGtnG
⎡⎣A(z)=∑(A,a0…ak)∈δ ∏i=0k τ(ai) :A∈N⎤⎦ with τ(a)={a(z)z,a∈N,a∈T.
Cela peut sembler intimidant, mais ce n'est en réalité qu'une transformation syntaxique, comme cela apparaîtra clairement dans l'exemple. L'idée est que les symboles terminaux générés sont comptés dans l'exposant de et que le système a la même forme que G , z n se produit le plus souvent dans la somme en tant que n bornes peuvent être générés par G . Consultez Kuich [2] pour plus de détails.zGznnG
La résolution de ce système d'équation (algèbre informatique!) Donne ; il ne vous reste plus qu'à "tirer" le coefficient (sous forme fermée et générale). La triche TCS et l'algèbre informatique peuvent souvent le faire.S(z)=SG(z)
Exemple
Considérez la grammaire simple avec des règlesG
.S→aSa∣bSb∣ε
Il est clair que (étape 1, preuve par induction). Il y a 2 nL(G)={wwR∣w∈{a,b}∗} palindromes de longueurnsinest pair,0sinon.2n2nn0
Configuration des rendements du système d'équations
S(z)=2z2S(z)+1
dont la solution est
.SG(z)=11−2z2
Les coefficients de coïncident avec le nombre de palindromes, doncSG est sans ambiguïté.G
- La théorie algébrique des langues sans contexte par Chomsky, Schützenberger (1963)
- Sur l'entropie des langages hors contexte par Kuich (1970)
This is a good question, but some Googling would have told you that there is no general method for deciding ambiguity, so you need to make your question more specific.
la source
For some grammars, a proof by induction (over word length) is possible.
Consider for example a grammarG over Σ={a,b} given by the following rules:
All words of length≤1 in L(G) -- there's only ε -- have only one left-derivation.
Assume that all words of length≤n for some n∈N have only one left-derivation.
Now consider arbitraryw=w1w′wn∈L(G)∩Σn for some n>0 . Clearly, w1∈Σ . If w1=a , we know that the first rule in every left-derivation has to be S→aSa ; if w1=b , it has to be S→bSb . This covers all cases. By induction hypothesis, we know that there is exactly one left-derivation for w′ . In combination, we conclude that there is exactly one left-derivation for w as well.
This becomes harder if
It may help to strengthen the claim to all sentential forms (if the grammar has no unproductive non-terminals) and "root" non-terminals.
I think the conversion to Greibach normal form maintains (un)ambiguity, to applying this step first may take care of left-recursion nicely.
The key is to identify one feature of every word that fixes (at least) one derivation step. The rest follows inductively.
la source
Basically, it's a child generation problem. Start with the first expression, and generate it's children .... Keep doing it recursively (DFS), and after quite a few iterations, see if you can generate the same expanded expression from two different children. If you are able to do that, it's ambiguous. There is no way to determine the running time of this algorithm though. Assume it's safe, after maybe generating 30 levels of children :) (Of course it could bomb on the 31st)
la source