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

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

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 = \{q_0, q_1\}$$\Sigma = \Gamma = \{a, b\}$$A = q_0$$\delta$

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.

Ecco alcuni esempi (da Wikipedia):

$S \rightarrow 0S0 | 1S1|\varepsilon$ 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).

$\{a^nb^mc^md^n|n,m>0\}$$\{a^nb^nc^md^m|n,m>0\}$$\{a^nb^nc^cd^n|n>0\}$

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 .

$\{a,b\}$$\{ w \in (a+b)^* \mid w = w^R \}$$S\to aSa | bSb | a | b | \epsilon$$a$$b$$a$$b$$a$$b$ ' 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.

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.