In che modo la non ambuiguità è diversa dal determinismo?


13

Sto cercando di capire cosa si intende per "deterministico" in espressioni come "grammatica libera dal contesto deterministico". (Ci sono "cose" più deterministiche in questo campo). Gradirei un esempio più della spiegazione più elaborata! Se possibile.

La mia principale fonte di confusione è dal non essere in grado di dire come questa proprietà di una grammatica sia diversa dalla (non) ambiguità.

Il più vicino che ho trovato nel significato è questa citazione dall'articolo di D. Knuth sulla traduzione delle lingue da sinistra a destra :

Ginsburg e Greibach (1965) hanno definito la nozione di un linguaggio deterministico; mostriamo nella Sezione V che queste sono precisamente le lingue per le quali esiste una grammatica LR (k)

che diventa circolare non appena si arriva al Section V, perché lì dice che ciò che il parser LR (k) può analizzare è il linguaggio deterministico ...


Di seguito è riportato un esempio che potrei trovare per aiutarmi a capire cosa significa "ambiguo", per favore dai un'occhiata:

onewartwoearewe

Che può essere analizzato come one war two ear eweo o new art woe are we- se una grammatica lo consente (supponiamo che abbia tutte le parole che ho appena elencato).

Cosa dovrei fare per rendere questo linguaggio di esempio (non) deterministico? (Potrei, ad esempio, rimuovere la parola odalla grammatica, per rendere la grammatica non ambigua).

La lingua sopra è deterministica?

PS. L'esempio è tratto dal libro Godel, Esher, Bach: Eternal Golden Braid.


Diciamo, definiamo la grammatica per la lingua di esempio in questo modo:

S -> A 'we' | A 'ewe'
A -> B | BA
B -> 'o' | 'new' | 'art' | 'woe' | 'are' | 'one' | 'war' | 'two' | 'ear'

Con l'argomento di dover analizzare l'intera stringa, questa grammatica rende la lingua non deterministica?


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' |

1
-1, poiché la domanda ora ha poco senso. Prima di tutto, una stringa non è una lingua; le stringhe non sono ambigue, non ambigue, deterministiche o non deterministiche; sono solo stringhe. La grammatica che dai non genera la stringa di esempio. Non ho controllato tutte le 180 derivazioni per vedere se ci sono duplicati, ma in teoria è tutto ciò che dovresti fare per vedere se la grammatica è ambigua. Purtroppo, la lingua non può essere intrinsecamente ambigua, poiché la lingua è finita, quindi regolare, quindi accettata da un DPDA, quindi deterministico.
Patrick87,

@ Patrick87 eh? Dove dice che la stringa è la lingua? Questa stringa è un prodotto di esempio e sicuramente è possibile generare usando la grammatica fornita. Cosa ti fa pensare diversamente? La stringa in questione è esattamente il caso, in cui due diverse sequenze di applicazioni di regole producono la stessa stringa, quindi la grammatica è ambigua, ma se si rimuovono alcune regole (ad esempio B -> 'o', allora non sarà più ambiguo ...
wvxvw

Prima di tutto, puoi fornire una derivazione della stringa di esempio usando la grammatica? Dalla tua stessa domanda: "La lingua sopra è deterministica?" Non nominate mai una lingua, solo una stringa, generata da un'infinità di grammatiche, anche se non quella che proponete.
Patrick87,

Puoi scriverlo in inglese? Ad esempio, "Inizia con S. Con l'applicazione della regola S := ..., otteniamo ..., ..."
Patrick87

@ Patrick87 Ho aggiunto la procedura di generazione passo-passo e ho capito di aver fatto un errore grammaticale, che ho risolto.
wvxvw,

Risposte:


9

Un PDA è deterministico, quindi un DPDA, se per ogni configurazione raggiungibile dell'automa, esiste al massimo una transizione (vale a dire al massimo una nuova configurazione possibile). Se si dispone di un PDA che può raggiungere una configurazione per la quale sono possibili due o più transizioni univoche, non si dispone di un DPDA.

Esempio:

Q={q0,q1}Σ=Γ={a,b}A=q0δ

q    e    s    q'   s'
--   --   --   --   --
q0   a    Z0   q1   aZ0
q0   a    Z0   q2   bZ0
...

Questi sono PDA non deterministici perché la configurazione iniziale - q_0, Z0- è raggiungibile, e ci sono due transizioni valide che portano via da essa se il simbolo di input lo è a. Ogni volta che questo PDA inizia a provare a elaborare una stringa che inizia con una , c'è una scelta. Scelta significa non deterministico.

Considera invece la seguente tabella di transizione:

q    e    s    q'   s'
--   --   --   --   --
q0   a    Z0   q1   aZ0
q0   a    Z0   q2   bZ0
q1   a    a    q0   aa
q1   a    b    q0   ab
q1   a    b    q2   aa
q2   b    a    q0   ba
q2   b    b    q0   bb
q2   b    a    q1   bb

Potresti essere tentato di dire che questo PDA non è deterministico; dopo tutto, ci sono due transizioni valide lontano dalla configurazione q1, b(a+b)*, per esempio. Tuttavia, poiché questa configurazione non è raggiungibile da alcun percorso attraverso l'automa, non conta. Le uniche configurazioni raggiungibili sono un sottoinsieme di q_0, (a+b)*Z0, q1, a(a+b)*Z0e q2, b(a+b)*Z0, e per ognuna di queste configurazioni, viene definita al massimo una transizione.

Un CFL è deterministico se è la lingua di alcuni DPDA.

Un CFG non è ambiguo se ogni stringa ha al massimo una derivazione valida secondo il CFG. Altrimenti, la grammatica è ambigua. Se hai un CFG e puoi produrre due diversi alberi di derivazione per una stringa, hai una grammatica ambigua.

Un CFL è intrinsecamente ambiguo se non è la lingua di un CFG inequivocabile.

Nota quanto segue:

  • Un CFL deterministico deve essere la lingua di alcuni DPDA.
  • Ogni CFL è il linguaggio di infiniti PDA non deterministici.
  • Un CFL intrinsecamente ambiguo non è il linguaggio di alcun CFG inequivocabile.
  • Ogni CFL è il linguaggio di infiniti CFG ambigui.
  • Un CFL intrinsecamente ambiguo non può essere deterministico.
  • Un CFL non deterministico può o meno essere intrinsecamente ambiguo.

1
Wiki afferma che il PDA non è deterministico (potrebbe esserci una versione deterministica e una non deterministica), ma potresti anche omettere la prima parte della frase, non sta davvero contribuendo a ciò che stai dicendo: / Ma, ancora una volta, questo definisce un linguaggio deterministico come linguaggio di input di qualcosa deterministico e che qualcosa si chiama deterministico perché accetta un linguaggio deterministico - è come dire "l'erba è verde perché il verde è il colore dell'erba". È vero, ma non è utile :( Per favore, l'esempio sarebbe più che prezioso!
wvxvw,

@wvxvw: non stai leggendo correttamente. Dice: "Un PDA è deterministico se e solo se ogni stato / simbolo / stacktop triplo ha solo uno stato successivo". Non c'è niente in quella definizione su quale lingua accetta l'automa.
Wandering Logic,

2
@wvxvw La definizione di PDA deterministico, o DPDA, che non do in alcun modo, forma o forma, si basa sulla definizione di un linguaggio libero dal contesto deterministico. Definisco DPDA basandomi solo sulle proprietà dell'automa. Definisco quindi cos'è un CFL deterministico in termini di definizione di DPDA. Rileggi la risposta alla luce di questi e dei commenti di Wandering Logic e prova a capire se questo ha senso. Mi impegnerò a fornire alcuni brevi esempi.
Patrick87,

q1,b(a+b)q2,b(a+b)Q={q0,...q2} o qualcosa del genere? O forse non capisco cosa intendi per "configurazione". La configurazione non dovrebbe includere lo stack ex+x(x)*x
wvxvw,

@wvxvw La configurazione si riferisce allo stato corrente e al contenuto corrente dello stack. x+in genere si riferisce a "uno o più di x, mentre in x*genere si riferisce a" zero o più di x; Posso usare xx*al posto di x+, poiché questi sono identici.
Patrick87,

7

Ecco alcuni esempi (da Wikipedia):

S0S0|1S1|ε perché esiste un solo albero di analisi per ogni stringa nella lingua.

Un linguaggio privo di contesto è deterministico se e solo se esiste almeno un automa deterministico di push-down che accetta quel linguaggio. (Potrebbero esserci anche molti automi push-down non deterministici che accettano il linguaggio, e sarebbe comunque un linguaggio deterministico.) Essenzialmente un automa push-down deterministico è uno in cui le transizioni macchina sono basate in modo deterministico sullo stato corrente, il simbolo di input e l'attuale simbolo più in alto dello stack . Deterministicoqui significa che non esiste più di una transizione di stato per qualsiasi stato / simbolo di input / simbolo di stack più in alto. Se hai due o più stati successivi per alcuni stati / simbolo di input / simbolo di stack più in alto triplo, l'automa non è deterministico. (Dovresti "indovinare" quale transizione intraprendere per decidere se l'automa accetta o meno.)

Ciò che Knuth ha dimostrato è che ogni grammatica LR (k) ha un automa deterministico di pushdown e che ogni automa deterministico di pushdown ha una grammatica LR (k). Quindi grammatiche LR (k) e automi pushdown deterministici possono gestire lo stesso insieme di lingue. Ma l'insieme delle lingue che hanno un automa deterministico di pushdown che le accetta sono (per definizione) le lingue deterministiche. L'argomento non è circolare.

Quindi un linguaggio deterministico implica che esiste una grammatica non ambigua. E abbiamo mostrato una grammatica inequivocabile che non ha un automa pushdown deterministico (e quindi è una grammatica inequivocabile che accetta un linguaggio non deterministico).

{anbmcmdn|n,m>0}{anbncmdm|n,m>0}{anbnccdn|n>0}


Puoi per favore elaborare, perché dover guardare l'intera stringa prima di determinare il centro rende questo linguaggio non deterministico? Ho letto un'altra spiegazione di cosa sia "deterministico", e qui dice che "se non è necessario tornare indietro durante l'analisi, quel linguaggio è deterministico". Non vedo la necessità di tornare indietro per analizzare questa lingua ...
wvxvw,

1
Considera la stringa di input "10011001". Gli automi pushdown non sanno quanto è lunga la stringa fino a quando non arriva alla fine. Quando arrivi al secondo 0 devi fare una scelta: è questa la stringa di 4 caratteri "1001" o una stringa più lunga che assomiglia a "100 ???? 001"? Quando arrivi al quinto carattere ancora non lo sai: è questa la stringa di 8 caratteri "10011001" o una stringa più lunga che assomiglia a "10011 ???? 11001"?
Wandering Logic,

1
La cosa "analizza l'intera stringa" non è la definizione di non deterministico. Era solo un'intuizione che stavo cercando di aggiungere. Sia @ Patrick87 che io ti abbiamo dato la vera definizione di deterministico: da ogni stato c'è al massimo uno stato successivo. Se una lingua non ha una grammatica chiara, deve essere non deterministica. Non posso rispondere del tuo esempio senza fare altro lavoro: hai mostrato una grammatica ambigua, ma non è questo ciò che conta, devi dimostrare che non esiste una grammatica non ambigua se vuoi dimostrare che la lingua è intrinsecamente ambigua.
Wandering Logic,

1
@wvxvw Se stai cercando una procedura computazionale, probabilmente sei sfortunato ... secondo en.wikipedia.org/wiki/List_of_undecidable_problems , è indecidibile se un CFG sia ambiguo, figuriamoci se il suo linguaggio è intrinsecamente ambiguo ; è anche impossibile stabilire se un CFG generi tutte le stringhe. Detto questo, dubito seriamente che sia decidibile, molto meno efficiente decidere se il linguaggio di un CFG sia un CFL deterministico.
Patrick87,

1
@wvxvw Se ti capita di essere fortunato, hai a che fare con quello che chiamiamo un caso felice, vale a dire, non uno dei casi che lo rende un problema indecidibile. Puoi definire l'euristica che funziona per molti casi felici e non esplodere per il resto, ma non funzionerà su tutti i casi felici; se lo facessero, avresti un decisore per il problema, che per nostra premessa è impossibile.
Patrick87,

5

Le lingue senza contesto deterministico sono quelle che sono accettate da un automa di pushdown deterministico (le lingue senza contesto sono quelle accettate da un automa di pushdown non deterministico). Come tale, è una proprietà di una lingua piuttosto che di una grammatica . Al contrario, l' ambiguità è una proprietà di una grammatica, mentre l' ambiguità intrinseca è una proprietà di una lingua (una lingua senza contesto è intrinsecamente ambigua se ogni grammatica senza contesto per la lingua è ambigua).

C'è una connessione tra le due definizioni: i linguaggi deterministici senza contesto non sono mai intrinsecamente ambigui, come mostrato nella risposta a questa domanda .


Spiacenti, non è molto utile. In realtà ho iniziato con DPDA, ma non spiega mai perché si chiama deterministico. Questa è una definizione facile da trovare su Wikipedia / Google per altri articoli. Ma quale proprietà della grammatica / lingua / parser è descritta dalla parola "deterministico"? In altre parole, cosa dovrebbe accadere nella grammatica per essere definito deterministico?
wvxvw,

Scusa, se commento troppo. La confusione è perché non posso dire, ad esempio, guardando una lingua se è deterministica o meno, e non saprei da dove iniziare per identificare il "determinismo" della lingua. Un esempio di un linguaggio che è deterministico e poi cambiato nel modo in cui lo rende non deterministico sarebbe immensamente utile.
wvxvw

1
Ribadendo, il determinismo è una proprietà della lingua. La proprietà della lingua descritta dalla parola deterministicaLR(k)

1
Spiacenti, ancora non utile. Capisco quello che stai dicendo, ma non mi aiuta a riconoscere una lingua che è deterministica e a dirla a parte non deterministica. Per fare un esempio: se una lingua ha una regola di produzione che crea un problema di parentesi bilanciata, so immediatamente che non può essere analizzata da FSM. (Perché richiederebbe uno stack). Ma quando menzioni solo un altro formalismo, diventa solo ricorsivo, non mi aiuta a capire come quella lingua dovrebbe differire da un'altra.
wvxvw,

In altre parole (come hai menzionato in un commento precedente), vuoi esempi di linguaggi deterministici e non deterministici senza contesto dello stesso "ordinamento". Forse dovresti fare una domanda mirata a riguardo.
Yuval Filmus,

1

{a,b}{w(a+b)w=wR}SaSa|bSb|a|b|ϵababab ' leggendo l'input e facendo scoppiare la pila fino a quando entrambi sono vuoti. Ma non c'è modo di creare un PDA DETERMINISTICO per questa lingua, perché non c'è modo per il PDA di individuare il centro della stringa senza indovinare.


1

definizioni

  1. Un accettatore pushdown deterministico (DPDA) è un automa pushdown che non ha mai scelta nella sua mossa.
  2. DPDA e NPDA non sono equivalenti.
  3. Un CFG non è deterministico se ci sono almeno due produzioni con lo stesso prefisso terminale sul lato destro di esse.
  4. Un CFG è ambigua sse esiste qualche w ∈ L (G) che ha almeno due alberi di derivazione distinti. Pertanto, ha due o più derivazioni più a sinistra o più a destra corrispondenti a due diversi alberi di derivazione.
  5. Un CFG è inequivocabile se ogni stringa ha al massimo una derivazione valida secondo il CFG. Altrimenti, la grammatica è ambigua.
  6. Un CFL è intrinsecamente ambiguo se non è la lingua di un CFG non ambiguo. Non può avere alcun DPDA.
    Se ogni grammatica che genera CFL è ambigua, allora il CFL è chiamato intrinsecamente ambiguo . Quindi non è la lingua di nessuno CFG inequivocabile.

I fatti

  1. Ogni CFL è la lingua di infinitamente molti PDA non deterministici.
  2. Ogni CFL è la lingua di infinitamente molti CFG ambigui.
  3. Un CFL accettato da alcuni DPDA non è intrinsecamente ambiguo. (Esiste almeno un CFG non ambiguo per questo.)
  4. Un CFL accettato da NDPDA può o meno essere intrinsecamente ambiguo in quanto potrebbe esistere un DPDA (o CFG non ambiguo) per esso.
  5. Le CFL generato da CFG ambiguo può o non può essere intrinsecamente ambigua quanto potrebbe esistere una certa CFG (o DPDA) non ambiguo per esso.
  6. Un CFL generato da almeno uno CFG non ambiguo non è intrinsecamente ambiguo. (Esistono alcuni DPDA per questo.)
  7. Una grammatica non deterministica può o meno essere ambigua.

Risposta alla tua domanda (relazione tra determinismo e ambiguità)

  1. L'ambiguità (non) si applica principalmente alle grammatiche (qui CFG). Il determinismo (non) si applica sia alla grammatica che all'automa (qui PDA).

    Se vuoi differenze logiche, puoi guardare gli ultimi quattro punti nella sezione fatti mentre provano a mettere in relazione ambiguità e determinismo. Qui li sto ripetendo di nuovo:

  2. Un CFL accettato da alcuni PDA deterministici non è intrinsecamente ambiguo . (Esiste almeno un CFG non ambiguo per questo.)

  3. Un CFL accettato da PDA non deterministico può o meno essere intrinsecamente ambiguo in quanto potrebbe esistere un DPDA (o CFG non ambiguo ) per esso.
  4. Un CFL generato da CFG ambiguo può o meno essere intrinsecamente ambiguo in quanto potrebbe esistere un CFG non ambiguo (o deterministico PDA ) per esso.
  5. Le CFL generato da almeno un inequivocabile CFG non è intrinsecamente ambigua . (Esistono alcuni DPDA per questo.)
  6. Una grammatica non deterministica può o meno essere ambigua .

PS:

  1. La risposta accettata utilizza linee come "CFL è deterministico", "CFL deterministico", "CFL non può essere deterministico", "Un CFL non deterministico". Immagino che gli aggettivi "deterministico" e "ambiguo" non si applichino al CFL, ma al PDA e al CFG. (Sebbene l'aggettivo "intrinsecamente ambiguo" si applica al CFL) Anche se non voglio criticare la risposta originale, come ho imparato punti da esso. (In effetti ho letteralmente copiato alcune righe incollate da quella risposta.) Ma ho comunque pensato che dovesse essere reso più corretto. Quindi ho cercato di mettere le cose più chiaramente qui in due parti definizioni e fatti (avrei potuto renderlo inutilmente prolisso e lungo). Immagino che avrei dovuto modificare la risposta originale, ma ciò comporterà l'eliminazione di molti punti che utilizzano le righe sopra. E non so se questo renderà qualsiasi modifica valida in quanto comporta una completa riscrittura.
  2. Si noti che ho messo una parola quantitativa in grassetto corsivo per evidenziare le differenze comparative nelle diverse definizioni e fatti. I termini della definizione sono solo in grassetto .
  3. Alcuni punti mi sono fatto, quindi avrò bisogno di una conferma da parte di qualcuno esperto qui sulla correttezza di ogni punto.

PS 1 è errato: esiste una definizione standard per i CFL deterministici / ambigui, vale a dire, sono definiti come quelli per i quali tutti i CFG sono deterministici / ambigui.
reinierpost,

ho appena realizzato che il fatto 7 è sbagliato. Anche il punto 6 della seconda ultima lista è lo stesso ed è sbagliato.
Maha,

Infatti ... il determinismo non sta avendo ambiguità in nessun momento durante l' analisi, quindi è strettamente più forte dell'ambiguità (cioè l'ambiguità anche dopo che l' analisi è stata completata).
reinierpost,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.