Estoy tratando de entender qué se entiende por "determinista" en expresiones como "gramática determinista sin contexto". (Hay "cosas" más deterministas en este campo). ¡Agradecería un ejemplo más que la explicación más elaborada! Si es posible.
Mi principal fuente de confusión es no poder decir cómo esta propiedad de una gramática es diferente de la (no) ambigüedad.
Lo más cerca que pude encontrar lo que significa es esta cita del documento de D. Knuth sobre la traducción de idiomas de izquierda a derecha :
Ginsburg y Greibach (1965) han definido la noción de un lenguaje determinista; mostramos en la Sección V que estos son precisamente los lenguajes para los que existe una gramática LR (k)
que se vuelve circular tan pronto como llegas al Section V
, porque allí dice que lo que el analizador LR (k) puede analizar es el lenguaje determinista ...
A continuación hay un ejemplo que podría encontrar para ayudarme a entender lo que significa "ambiguo", por favor, eche un vistazo:
onewartwoearewe
Que se puede analizar como one war two ear ewe
o o new art woe are we
, si una gramática lo permite (digamos que tiene todas las palabras que acabo de enumerar).
¿Qué debería hacer para que este lenguaje de ejemplo (no) sea determinista? (Podría, por ejemplo, eliminar la palabra o
de la gramática, para que la gramática no sea ambigua).
¿Es el lenguaje anterior determinista?
PD. El ejemplo es del libro Godel, Esher, Bach: Eternal Golden Braid.
Digamos que definimos la gramática para el lenguaje de ejemplo de esta manera:
S -> A 'we' | A 'ewe'
A -> B | BA
B -> 'o' | 'new' | 'art' | 'woe' | 'are' | 'one' | 'war' | 'two' | 'ear'
Según el argumento sobre tener que analizar toda la cadena, ¿esta gramática hace que el lenguaje no sea determinista?
let explode s =
let rec exp i l =
if i < 0 then l else exp (i - 1) (s.[i] :: l) in
exp (String.length s - 1) [];;
let rec woe_parser s =
match s with
| 'w' :: 'e' :: [] -> true
| 'e' :: 'w' :: 'e' :: [] -> true
| 'o' :: x -> woe_parser x
| 'n' :: 'e' :: 'w' :: x -> woe_parser x
| 'a' :: 'r' :: 't' :: x -> woe_parser x
| 'w' :: 'o' :: 'e' :: x -> woe_parser x
| 'a' :: 'r' :: 'e' :: x -> woe_parser x
(* this line will trigger an error, because it creates
ambiguous grammar *)
| 'o' :: 'n' :: 'e' :: x -> woe_parser x
| 'w' :: 'a' :: 'r' :: x -> woe_parser x
| 't' :: 'w' :: 'o' :: x -> woe_parser x
| 'e' :: 'a' :: 'r' :: x -> woe_parser x
| _ -> false;;
woe_parser (explode "onewartwoearewe");;
- : bool = true
| Label | Pattern |
|---------+--------------|
| rule-01 | S -> A 'we' |
| rule-02 | S -> A 'ewe' |
| rule-03 | A -> B |
| rule-04 | A -> BA |
| rule-05 | B -> 'o' |
| rule-06 | B -> 'new' |
| rule-07 | B -> 'art' |
| rule-08 | B -> 'woe' |
| rule-09 | B -> 'are' |
| rule-10 | B -> 'one' |
| rule-11 | B -> 'war' |
| rule-12 | B -> 'two' |
| rule-13 | B -> 'ear' |
#+TBLFM: @2$1..@>$1='(format "rule-%02d" (1- @#));L
Generating =onewartwoearewe=
First way to generate:
| Input | Rule | Product |
|-------------------+---------+-------------------|
| '' | rule-01 | A'we' |
| A'we' | rule-04 | BA'we' |
| BA'we' | rule-05 | 'o'A'we' |
| 'o'A'we' | rule-04 | 'o'BA'we' |
| 'o'BA'we' | rule-06 | 'onew'A'we' |
| 'onew'A'we' | rule-04 | 'onew'BA'we' |
| 'onew'BA'we' | rule-07 | 'onewart'A'we' |
| 'onewart'A'we' | rule-04 | 'onewart'BA'we' |
| 'onewart'BA'we' | rule-08 | 'onewartwoe'A'we' |
| 'onewartwoe'A'we' | rule-03 | 'onewartwoe'B'we' |
| 'onewartwoe'B'we' | rule-09 | 'onewartwoearewe' |
|-------------------+---------+-------------------|
| | | 'onewartwoearewe' |
Second way to generate:
| Input | Rule | Product |
|-------------------+---------+-------------------|
| '' | rule-02 | A'ewe' |
| A'ewe' | rule-04 | BA'ewe' |
| BA'ewe' | rule-10 | 'one'A'ewe' |
| 'one'A'ewe' | rule-04 | 'one'BA'ewe' |
| 'one'BA'ewe' | rule-11 | 'onewar'A'ewe' |
| 'onewar'A'ewe' | rule-04 | 'onewar'BA'ewe' |
| 'onewar'BA'ewe' | rule-12 | 'onewartwo'A'ewe' |
| 'onewartwo'A'ewe' | rule-03 | 'onewartwo'B'ewe' |
| 'onewartwo'B'ewe' | rule-13 | 'onewartwoearewe' |
|-------------------+---------+-------------------|
| | | 'onewartwoearewe' |
B -> 'o'
ya no será ambigua ...
S
. Mediante la aplicación de la regla S := ...
, obtenemos ...
, ..."