APIC.md

# Grammatica

## *Es1*

Si consideri la seguente grammatica G:

$S \to ABC \mid \varepsilon$
$ABC \to aaX$
$X \to ABC$
$A \to a$
$BC \to A$

1.  Di che tipo è G nella gerarchia di Chomsky?
2.  Utilizzare un formalismo non grammaticale a potere espressivo minimo, tra quelli visti a lezione, che caratterizzi il linguaggio L generato da G.

---

### Spiegazione e Svolgimento Passo Passo

#### **Domanda 1: Classificazione della grammatica G**

**Obiettivo:** Determinare il tipo della grammatica G secondo la gerarchia di Chomsky.

**Ragionamento:**
Per classificare una grammatica, dobbiamo analizzare le sue regole di produzione e confrontarle con le definizioni dei vari tipi della gerarchia, partendo dal più restrittivo (Tipo 3) al più generale (Tipo 0).

*   **Tipo 3 (Regolare):** Le regole devono essere della forma $A \to aB$ o $A \to a$ (lineari a destra) oppure $A \to Ba$ o $A \to a$ (lineari a sinistra). Regole come $S \to ABC$ e $ABC \to aaX$ violano questa forma perché hanno più di un non-terminale a destra o a sinistra. **Quindi, G non è di Tipo 3.**

*   **Tipo 2 (Libera dal contesto / Context-Free):** Le regole devono essere della forma $A \to \gamma$, dove A è un singolo simbolo non-terminale. Le regole $ABC \to aaX$ e $BC \to A$ violano questa condizione perché la parte sinistra della regola ha più di un simbolo. **Quindi, G non è di Tipo 2.**

*   **Tipo 1 (Sensibile al contesto / Context-Sensitive):** Le regole devono essere della forma $\alpha A \beta \to \alpha \gamma \beta$ con $\gamma \neq \varepsilon$, o, in modo più generale, devono essere "monotone", cioè la lunghezza della parte destra deve essere maggiore o uguale alla lunghezza della parte sinistra ($|\text{destra}| \geq |\text{sinistra}|$).
    *   Analizziamo la regola $BC \to A$.
    *   La lunghezza della parte sinistra è $|BC| = 2$.
    *   La lunghezza della parte destra è $|A| = 1$.
    *   Poiché $1 < 2$, la regola non è monotona (la stringa si "accorcia").
    *   Questa violazione della monotonicità implica che **la grammatica G non è di Tipo 1.**

*   **Tipo 0 (Generale / Ricorsivamente Enumerabile):** Questo tipo non ha restrizioni sulla forma delle regole, a parte il fatto che la parte sinistra non può essere vuota. Poiché G non rientra in nessuno dei tipi più restrittivi, essa appartiene al tipo più generale.

**Soluzione (Punto 1):**
La grammatica G è di **Tipo 0 (generale)**. La regola critica è $BC \to A$, che non è né context-free (perché ha due simboli a sinistra) né context-sensitive (perché la parte destra è più corta di quella sinistra, violando la proprietà di monotonicità).

---

#### **Domanda 2: Caratterizzazione del linguaggio L**

**Obiettivo:**
1.  Capire qual è il linguaggio L generato dalla grammatica G.
2.  Descriverlo usando il "formalismo non grammaticale a potere espressivo minimo".

**Passo 1: Analisi delle derivazioni per scoprire il linguaggio L**

Cerchiamo di derivare alcune stringhe per capire la struttura del linguaggio.

*   **Derivazione della stringa vuota (ε):** La regola $S \to \varepsilon$ ci dice subito che la stringa vuota appartiene al linguaggio L.

*   **Analisi delle altre regole:** Le regole $ABC \to aaX$ e $X \to ABC$ creano un ciclo di sostituzione. Se sostituiamo X nella prima regola, otteniamo:
    $ABC \to aa(ABC)$
    Questa regola ci dice che possiamo sostituire la sequenza `ABC` con `aa` seguito di nuovo da `ABC`. Questo è un passo ricorsivo che aggiunge `aa` alla stringa.

*   **Come terminare una derivazione?** Per ottenere una stringa di soli terminali (in questo caso, solo simboli 'a'), dobbiamo eliminare tutti i non-terminali. Le regole che ci permettono di farlo sono $A \to a$ e $BC \to A$.

**Proviamo a derivare le stringhe più corte:**
*   Partiamo da $S \to ABC$.
*   Per terminare subito, dobbiamo sbarazzarci di `A` e `BC`.
*   $S \to ABC \to (A)(BC) \to (a)(A) \to (a)(a) = aa$.
    *   Abbiamo usato $A \to a$ e poi $BC \to A$.
    *   Quindi, la stringa **"aa"** appartiene a L.

*   **Proviamo a fare un passo ricorsivo:**
*   $S \to ABC \to aaABC$ (usando il ciclo che abbiamo identificato).
*   Ora, da questa nuova stringa, cerchiamo di terminare:
*   $aaABC \to aa(A)(BC) \to aa(a)(A) \to aa(a)(a) = aaaa$.
    *   Quindi, la stringa **"aaaa"** appartiene a L.

*   **Proviamo con due passi ricorsivi:**
*   $S \to ABC \to aaABC \to aa(aaABC) = aaaaABC$.
*   Terminiamo la derivazione:
*   $aaaaABC \to aaaa(A)(BC) \to aaaa(a)(A) \to aaaa(a)(a) = aaaaaa$.
    *   Quindi, la stringa **"aaaaaa"** appartiene a L.

**Conclusione sull'identità di L:**
Le stringhe generate sono ε, aa, aaaa, aaaaaa, ... . Questo è l'insieme di tutte le stringhe composte da un numero pari di 'a'.
Il linguaggio L è quindi descritto dall'espressione regolare **(aa)\***.

**Passo 2: Scelta del formalismo non grammaticale minimo**

*   Il linguaggio L = (aa)\* è un **linguaggio regolare**.
*   Nella gerarchia dei linguaggi, i linguaggi regolari sono quelli con il potere espressivo più basso.
*   I formalismi "non grammaticali" per descrivere i linguaggi regolari sono principalmente due:
    1.  **Espressioni Regolari**
    2.  **Automi a Stati Finiti (FSA)**

Entrambi sono formalismi a potere espressivo minimo in grado di caratterizzare L.

**Soluzione (Punto 2):**

1.  **Mediante Espressione Regolare:** Il linguaggio L può essere caratterizzato dall'espressione regolare **(aa)\***.

2.  **Mediante Automa a Stati Finiti (ASF/FSA):** Possiamo costruire un automa a stati finiti deterministico che riconosca questo linguaggio.
    *   Servono due stati: uno stato iniziale `q0` e uno stato `q1`.
    *   Lo stato iniziale `q0` è anche uno stato finale (per accettare la stringa vuota ε).
    *   Da `q0`, leggendo una 'a', si passa a `q1`.
    *   Da `q1`, leggendo una 'a', si torna a `q0`.
    *   Questo automa accetta una stringa solo se, dopo aver letto tutti i caratteri, si trova nello stato finale `q0`. Ciò accade solo dopo aver letto un numero pari di 'a'.


## **Es2**

Si consideri la seguente grammatica $G$:

$S \to ABc$
$A \to a$
$AB \to aAB$
$AB \to aB$
$B \to b$
$B \to bB$

1. Di che tipo è $G$ nella gerarchia di Chomsky?
2. Utilizzare un formalismo non grammaticale a potere espressivo minimo, tra quelli visti a lezione, che caratterizzi il linguaggio $L$ generato da $G$.

---

**Svolgimento dettagliato:**

**Parte 1: Classificazione della grammatica $G$ nella gerarchia di Chomsky.**

La gerarchia di Chomsky classifica le grammatiche formali in quattro tipi principali:
*   **Tipo 0 (Non ristrette):** Nessuna restrizione sulle regole di produzione. Possono generare tutti i linguaggi ricorsivamente enumerabili.
*   **Tipo 1 (Dipendenti dal contesto - Context-Sensitive):** Per ogni regola di produzione $\alpha \to \beta$, la lunghezza di $\alpha$ deve essere minore o uguale alla lunghezza di $\beta$ (cioè $|\alpha| \leq |\beta|$), a meno che $\alpha \to \epsilon$ (la stringa vuota) non sia l'unica eccezione, e in quel caso $\alpha$ non deve essere il simbolo iniziale. Inoltre, le regole sono spesso della forma $\gamma A \delta \to \gamma \beta \delta$, dove $A$ è un non terminale e $\beta$ è una stringa non vuota. Ciò significa che la produzione di $A$ dipende dal suo contesto $\gamma$ e $\delta$.
*   **Tipo 2 (Libere dal contesto - Context-Free):** Le regole di produzione sono della forma $A \to \beta$, dove $A$ è un singolo non terminale e $\beta$ è una stringa qualsiasi di terminali e non terminali.
*   **Tipo 3 (Regolari - Regular):** Le regole di produzione sono della forma $A \to aB$ o $A \to a$, oppure $A \to Ba$ o $A \to a$. Sono le grammatiche più restrittive e generano i linguaggi regolari.

Analizziamo le regole di $G$:

1.  $S \to ABc$ : Un non terminale a sinistra, più simboli a destra. (Compatibile con Tipo 2, 1, 0)
2.  $A \to a$ : Un non terminale a sinistra, un terminale a destra. (Compatibile con Tipo 2, 1, 0)
3.  $AB \to aAB$ : Questa è la regola chiave. A sinistra abbiamo una stringa di due simboli ($AB$), e a destra una stringa più lunga ($aAB$). Questa regola **non è del tipo 2 o 3** perché il lato sinistro non è un singolo non terminale.
4.  $AB \to aB$ : Similmente, a sinistra $AB$, a destra $aB$. Non è Tipo 2 o 3.
5.  $B \to b$ : Un non terminale a sinistra, un terminale a destra. (Compatibile con Tipo 2, 1, 0)
6.  $B \to bB$ : Un non terminale a sinistra, un terminale e un non terminale a destra. (Compatibile con Tipo 2, 1, 0)

Le regole $AB \to aAB$ e $AB \to aB$ violano la forma delle grammatiche di Tipo 2 e Tipo 3, poiché il lato sinistro non è un singolo non terminale.

Vediamo se rientrano nel Tipo 1 (Dipendenti dal contesto).
Per le grammatiche dipendenti dal contesto, la condizione principale è che per ogni regola $\alpha \to \beta$, si abbia $|\alpha| \leq |\beta|$.

*   $S \to ABc$: $|S|=1$, $|ABc|=3$. $1 \leq 3$. Ok.
*   $A \to a$: $|A|=1$, $|a|=1$. $1 \leq 1$. Ok.
*   $AB \to aAB$: $|AB|=2$, $|aAB|=3$. $2 \leq 3$. Ok.
*   $AB \to aB$: $|AB|=2$, $|aB|=2$. $2 \leq 2$. Ok.
*   $B \to b$: $|B|=1$, $|b|=1$. $1 \leq 1$. Ok.
*   $B \to bB$: $|B|=1$, $|bB|=2$. $1 \leq 2$. Ok.

Tutte le regole soddisfano la condizione $|\alpha| \leq |\beta|$. Inoltre, la forma $AB \to aAB$ o $AB \to aB$ può essere vista come un'espansione di un simbolo $A$ (o $B$) che è contestualizzata dalla presenza di $B$ (o $A$). Più precisamente, queste regole sono proprio un esempio di regole contestuali.

**Conclusione per la Parte 1:** La grammatica $G$ è di **Tipo 1 (dipendente dal contesto)**.

---

**Parte 2: Caratterizzare il linguaggio $L$ generato da $G$ utilizzando un formalismo non grammaticale a potere espressivo minimo.**

Prima di tutto, cerchiamo di capire quale linguaggio genera questa grammatica.
Partiamo da $S$:
$S \to ABc$

Ora dobbiamo espandere $A$ e $B$. Sappiamo che $A \to a$. Quindi, prima o poi, $A$ diventerà $a$.
$S \to aBc$ (sostituendo $A$ con $a$)

Ora, l'interessante è la gestione di $AB$.
Consideriamo la parte $AB$ che non è ancora stata espansa completamente.
Le regole che coinvolgono $AB$ sono:
*   $AB \to aAB$ (prefixed by 'a', then itself again)
*   $AB \to aB$ (prefixed by 'a', then just 'B')

E le regole per $B$:
*   $B \to b$
*   $B \to bB$

Vediamo alcune derivazioni:

1.  $S \to ABc$
    $S \to aBc$ (usando $A \to a$)
    $S \to a b c$ (usando $B \to b$)
    Questo genera la stringa "abc".

2.  $S \to ABc$
    $S \to aBc$ (usando $A \to a$)
    $S \to a b B c$ (usando $B \to bB$)
    $S \to a b b c$ (usando $B \to b$)
    Questo genera la stringa "abbc".
    Da qui si intuisce che $B$ può generare una o più 'b's. Formalmente, $B \Rightarrow b^+$.

3.  $S \to ABc$
    $S \to aABc$ (usando $AB \to aAB$)
    $S \to aaBc$ (usando $A \to a$)
    $S \to aabB_1B_2c$ (usando $B \to bB_1$, $B_1 \to bB_2$)
    $S \to aa(b^*)bc$
    Questo non è del tutto corretto, perché $A$ non è ricorsivo.

Rivediamo le derivazioni concentrandoci su $AB$:
$S \to ABc$

Se usiamo $AB \to aB$:
$S \to aBc$
Poi $A \to a$ è già stata usata implicitamente o non serve più per il primo $A$.
$S \to a b^+ c$ (dove $b^+$ significa una o più 'b')
Quindi, stringhe come $abc, abbc, abbbc$, ecc. sono generate.

Se usiamo $AB \to aAB$:
$S \to aABc$
Ora abbiamo di nuovo $AB$. Possiamo ripetere:
$S \to aaABc$
$S \to aaaABc$
...
$S \to a^n ABc$ per $n \geq 1$. (Questo è un po' impreciso per via dell'A iniziale)

Vediamo la produzione di $A$ separata dal gruppo $AB$.
$S \to ABc$
Il primo $A$ si espande solo in $a$: $A \to a$. Non ci sono altre produzioni per $A$.
Quindi, $S \to aBc$.

Ora il focus è su $B$.
$B \to b$
$B \to bB$
Questo significa che $B$ può generare una sequenza di uno o più $b$. In termini di espressioni regolari, $B \Rightarrow b^+$.

Quindi, da $S \to aBc$ e $B \Rightarrow b^+$, otteniamo stringhe della forma $ab^+c$.
Esempio: $abc, abbc, abbbc, \dots$

Ma le regole $AB \to aAB$ e $AB \to aB$ non sono state ancora pienamente interpretate.
Queste regole si applicano quando $A$ e $B$ sono adiacenti.
Riprendiamo da $S \to ABc$.

Possibilità 1: $AB \to aB$
$S \to aBc$
Poi $B$ genera $b^+$:
$S \to a b^+ c$

Possibilità 2: $AB \to aAB$
$S \to aABc$
Ora abbiamo di nuovo $AB$.
Possiamo continuare a usare $AB \to aAB$:
$S \to a(aAB)c$
$S \to aa(aAB)c$
...
$S \to a^k AB c$ per $k \ge 1$.
Una volta che abbiamo $a^k AB c$, dobbiamo alla fine usare la regola $AB \to aB$ per terminare la ricorsione di $AB$:
$S \to a^k (aB) c$
$S \to a^{k+1} B c$
Poi $B \to b^+$:
$S \to a^{k+1} b^+ c$.

Mettendo insieme, le stringhe generate sono della forma $a^{k+1} b^+ c$ per $k \geq 0$.
Questo significa $a^+ b^+ c$.
(Se $k=0$, si ha $a^1 b^+ c$).

Quindi, il linguaggio $L$ generato da $G$ è $L = \{ a^n b^m c \mid n \geq 1, m \geq 1 \}$.
Esempi di stringhe: $abc, aabc, abbc, aabbc, aaabbc$, ecc.

**Formalismo non grammaticale a potere espressivo minimo:**
Per i linguaggi generati da grammatiche di Tipo 3 (Regolari), il formalismo a potere espressivo minimo sono le **Espressioni Regolari (ER)** o gli **Automi a Stati Finiti (FSA)**.
Il linguaggio $L = \{ a^n b^m c \mid n \geq 1, m \geq 1 \}$ è un linguaggio regolare. Possiamo verificarlo.

Un'espressione regolare per $a^n b^m c$ con $n \geq 1, m \geq 1$ è:
$a a^* b b^* c$
o equivalentemente:
$a^+ b^+ c$

Questo è il formalismo a potere espressivo minimo perché una grammatica di Tipo 1 potrebbe generare un linguaggio non regolare (ma questo specifico linguaggio è regolare). Il fatto che $G$ sia di Tipo 1 non significa che *debba* generare un linguaggio non regolare; significa solo che *può* farlo. In questo caso, il linguaggio è regolare.

**Conclusione per la Parte 2:**
Il linguaggio $L$ generato da $G$ è $L = \{ a^n b^m c \mid n \geq 1, m \geq 1 \}$.
Il formalismo non grammaticale a potere espressivo minimo per caratterizzare questo linguaggio è l'**Espressione Regolare**:

$R = a^+ b^+ c$

Oppure, in alternativa (ma di pari potere espressivo minimo), un **Automa a Stati Finiti** come quello disegnato sopra.

Certamente! Questo è un classico problema di teoria della computabilità, che si presta bene a essere spiegato passo passo.




Certamente! Analizziamo questo esercizio passo dopo passo, concentrandoci sul motivo per cui la natura del numero `m` (naturale vs. reale) cambia radicalmente il tipo di linguaggio generato.

## Es3

Si considerino i seguenti linguaggi definiti sull’alfabeto {a, b} e, per ognuno dei due, si costruisca un automa riconoscitore o una grammatica a potenza minima. Si rammenta che ⌊x⌋ indica la parte intera del valore x.

1.  $L_1 = \{a^n b^{\lfloor mn \rfloor} \mid n \ge 0, 0 < m < 5, \text{ con } m \text{ e } n \text{ numeri naturali}\}$.
2.  $L_2 = \{a^n b^{\lfloor mn \rfloor} \mid n \ge 0, m > 0, \text{ con } m \text{ numero reale e } n \text{ numero naturale}\}$.

---

### Spiegazione e Svolgimento del Punto 1 (L1)

#### **Passo 1: Analizzare la definizione di L1**

La definizione è $L_1 = \{a^n b^{\lfloor mn \rfloor} \mid n \ge 0, 0 < m < 5, m, n \in \mathbb{N}\}$.

La condizione più importante qui è che **`m` è un numero naturale** compreso tra 0 e 5 (esclusi). Quindi, i valori possibili per `m` sono un insieme finito:
`m` può essere **1, 2, 3, o 4**.

Questo significa che il linguaggio $L_1$ non è definito da un unico pattern, ma è l'**unione** di quattro linguaggi distinti, uno per ogni valore possibile di `m`:

*   Se **m = 1**: il linguaggio è $\{a^n b^{\lfloor 1 \cdot n \rfloor}\} = \{a^n b^n \mid n \ge 0\}$.
*   Se **m = 2**: il linguaggio è $\{a^n b^{\lfloor 2 \cdot n \rfloor}\} = \{a^n b^{2n} \mid n \ge 0\}$.
*   Se **m = 3**: il linguaggio è $\{a^n b^{\lfloor 3 \cdot n \rfloor}\} = \{a^n b^{3n} \mid n \ge 0\}$.
*   Se **m = 4**: il linguaggio è $\{a^n b^{\lfloor 4 \cdot n \rfloor}\} = \{a^n b^{4n} \mid n \ge 0\}$.

Quindi, $L_1 = \{a^n b^n\} \cup \{a^n b^{2n}\} \cup \{a^n b^{3n}\} \cup \{a^n b^{4n}\}$.

#### **Passo 2: Determinare la potenza minima del riconoscitore**

*   Il linguaggio $\{a^n b^n\}$ è l'esempio classico di un **linguaggio non regolare e libero dal contesto (context-free)**. Richiede una memoria (come una pila) per contare il numero di `a` e confrontarlo con il numero di `b`.
*   Allo stesso modo, anche $\{a^n b^{kn}\}$ per una costante `k` è un linguaggio context-free.
*   La classe dei linguaggi context-free è chiusa rispetto all'unione. Ciò significa che l'unione di un numero finito di linguaggi context-free è ancora un linguaggio context-free.

Poiché $L_1$ è context-free ma non regolare, il riconoscitore a potenza minima è un **automa a pila (Pushdown Automaton)**, e la grammatica a potenza minima è una **grammatica libera dal contesto (Context-Free Grammar)**.

#### **Passo 3: Costruire la grammatica**

Per costruire una grammatica per l'unione di più linguaggi, si introduce un nuovo simbolo di inizio `S` che può generare l'inizio di una qualsiasi delle grammatiche dei singoli linguaggi.

*   **Caso n=0**: `a⁰b⁰ = ε` (la stringa vuota) appartiene a tutti e quattro i sotto-linguaggi. Quindi `S` deve poter generare `ε`.
*   **Grammatica per {aⁿbⁿ} (n ≥ 1)**: `A → aAb | ab`.
*   **Grammatica per {aⁿb²ⁿ} (n ≥ 1)**: `B → aBbb | abb`.
*   **Grammatica per {aⁿb³ⁿ} (n ≥ 1)**: `C → aCbbb | abbb`.
*   **Grammatica per {aⁿb⁴ⁿ} (n ≥ 1)**: `D → aDbbbb | abbbb`.

Unendo tutto con il simbolo di inizio `S`:
$S \to A \mid B \mid C \mid D \mid \varepsilon$
$A \to aAb \mid ab$
$B \to aBbb \mid abb$
$C \to aCbbb \mid abbb$
$D \to aDbbbb \mid abbbb$

Questa grammatica è esattamente quella fornita nella soluzione e caratterizza correttamente il linguaggio $L_1$.

---

### Spiegazione e Svolgimento del Punto 2 (L2)

#### **Passo 1: Analizzare la definizione di L2**

La definizione è $L_2 = \{a^n b^{\lfloor mn \rfloor} \mid n \ge 0, m > 0, \text{ con } m \text{ reale}, n \in \mathbb{N}\}$.

La differenza cruciale è che ora **`m` è un qualsiasi numero reale positivo**. Questo cambia tutto. Non abbiamo più un insieme finito di rapporti tra `a` e `b`, ma un insieme infinito e continuo.

Chiediamoci: per una data sequenza di `a` (cioè fissato `n > 0`), quante `b` possiamo generare? Sia `k` il numero di `b`. Vogliamo generare la stringa $a^n b^k$. È possibile farlo?

Dobbiamo trovare un numero reale `m > 0` tale che $k = \lfloor mn \rfloor$.
Questa equazione è equivalente alla disuguaglianza: $k \le mn < k+1$.
Dividendo per `n` (che è positivo), otteniamo:
$\frac{k}{n} \le m < \frac{k+1}{n}$

Per qualsiasi numero di `a` (`n > 0`) e qualsiasi numero desiderato di `b` (`k ≥ 0`), possiamo sempre trovare un numero reale `m` in questo intervallo. Ad esempio, possiamo scegliere $m = \frac{k}{n} + \frac{1}{2n}$. Questo valore di `m` è positivo e soddisfa la condizione.

**Conclusione:** Per qualsiasi numero di `a` (`n > 0`), possiamo generare un qualsiasi numero di `b` (`k ≥ 0`). Questo descrive il linguaggio $a^+b^*$.

Cosa succede se **n = 0**?
La stringa diventa $a^0 b^{\lfloor m \cdot 0 \rfloor} = a^0 b^0 = \varepsilon$.
Quindi, la stringa vuota `ε` è nel linguaggio.

Il linguaggio completo è quindi l'unione del caso `n=0` e del caso `n>0`:
$L_2 = \{\varepsilon\} \cup \{a^+ b^*\} = a^* b^*$
Questo è il linguaggio di tutte le stringhe composte da zero o più `a`, seguite da zero o più `b`.

#### **Passo 2: Determinare la potenza minima del riconoscitore**

Il linguaggio descritto dall'espressione regolare `a*b*` è un **linguaggio regolare**.
Pertanto, il riconoscitore a potenza minima è un **automa a stati finiti (Finite State Automaton)** e la grammatica a potenza minima è una **grammatica regolare (Tipo 3)**.

#### **Passo 3: Costruire la grammatica**

Dobbiamo costruire una grammatica regolare per `a*b*`.

*   `S` è lo stato iniziale. Da qui possiamo generare `a` o `b` o terminare.
*   Stato per generare `a`: `S → aS` (continua a generare `a`).
*   Transizione per iniziare a generare `b`: `S → bB` (genera la prima `b` e passa allo stato `B`).
*   Stato per generare `b`: `B → bB` (continua a generare `b`).
*   Terminazione:
    *   `S → ε` (per generare stringhe con solo `a`, o la stringa vuota).
    *   `B → ε` o, per una grammatica regolare standard, si fa terminare la produzione direttamente: `S → b`, `B → b`.

Una grammatica regolare semplice è:
$S \to aS \mid B$
$B \to bB \mid \varepsilon$

La grammatica fornita nella soluzione è leggermente diversa ma equivalente:
$S \to aA \mid aB \mid a \mid \varepsilon$
$A \to aA \mid aB$
$B \to bB \mid b$

Analizziamola:
*   $S \to \varepsilon$: accetta la stringa vuota.
*   $S \to a$: accetta la stringa "a".
*   $S \to aB$: genera una `a` e poi una sequenza non vuota di `b` (da `B`), generando $ab^+$.
*   $S \to aA$: genera una `a` e passa ad `A`. Da `A` si possono generare altre `a` ($aA$) o iniziare la sequenza di `b` ($aB$). Questo percorso genera le stringhe in $a^+b^*$.

Sommando tutti i percorsi, la grammatica genera correttamente il linguaggio $a^*b^*$, ed è una grammatica regolare.

## Es 3
### Traccia dell'Esercizio

1.  Si definisca una grammatica a potenza minima che generi il linguaggio `L1` su `{a,b}` delle stringhe in cui il numero di `a` sia pari al numero di `b` più 2 (cioè, `∀x(x ∈ L1 ↔ #a(x) = #b(x) + 2)`).
2.  Cambierebbe il tipo di grammatiche a potenza minima per generare il linguaggio `L2` delle stringhe in cui il numero di `a` è doppio rispetto al numero di `b` (cioè, `∀x(x ∈ L2 ↔ #a(x) = 2 * #b(x))`)? Giustificare la risposta. Non serve specificare la grammatica che genera il linguaggio, ma solo il suo tipo.

---

### Spiegazione e Svolgimento del Punto 1 (L1)

#### **Passo 1: Determinare il tipo di linguaggio**

Il linguaggio `L1` richiede di contare il numero di `a` e `b` e di mantenere una relazione specifica tra di loro (`#a = #b + 2`).
*   **Non è Regolare:** Un automa a stati finiti (FSA) ha memoria finita (i suoi stati). Non può tenere traccia di un conteggio illimitato di simboli per garantire che la relazione sia sempre soddisfatta per stringhe arbitrariamente lunghe.
*   **È Libero dal Contesto (Context-Free):** Questo tipo di problema di "bilanciamento" o "conteggio" è il classico esempio di un linguaggio che può essere gestito da un **automa a pila (Pushdown Automaton)**, che ha una memoria infinita (la pila). I linguaggi riconosciuti dagli automi a pila sono generati da **grammatiche libere dal contesto (Context-Free Grammars)**.

Quindi, la "potenza minima" richiesta è quella di una **Grammatica Libera dal Contesto (CFG)**.

#### **Passo 2: Analizzare la strategia della grammatica fornita**

La soluzione proposta è:
`S → TaTaT`
`T → aTbT | bTaT | ε`

Questa grammatica è molto elegante e si basa su un principio di "divide et impera".

*   **Il ruolo del non-terminale `T`:**
    Analizziamo le regole di `T`. Notiamo che per ogni `a` che viene aggiunto, viene aggiunto anche un `b` (`aTbT` e `bTaT`). La regola `T → ε` è il caso base. Questo significa che qualsiasi stringa derivata da `T` avrà sempre un numero uguale di `a` e di `b`.
    **`T` genera il linguaggio di tutte le stringhe con un numero uguale di `a` e `b`**. Ad esempio:
    *   `T → ε`
    *   `T → aTbT → a(ε)b(ε) → ab`
    *   `T → bTaT → b(ε)a(ε) → ba`
    *   `T → aTbT → a(ba)b(ε) → abab`

*   **Il ruolo del non-terminale `S`:**
    La regola di partenza `S → TaTaT` sfrutta la proprietà di `T`.
    1.  Prende tre stringhe bilanciate generate da `T`. Chiamiamole `t₁`, `t₂`, `t₃`.
    2.  Inserisce **due `a`** in mezzo a queste stringhe.
    La stringa finale avrà la forma `t₁ a t₂ a t₃`.
    Calcoliamo il numero di `a` e `b` nella stringa finale:
    *   `#a(finale) = #a(t₁) + 1 + #a(t₂) + 1 + #a(t₃) = #a(t₁) + #a(t₂) + #a(t₃) + 2`
    *   `#b(finale) = #b(t₁) + #b(t₂) + #b(t₃)`
    Poiché sappiamo che ogni `tᵢ` è bilanciata (`#a(tᵢ) = #b(tᵢ)`), possiamo sostituire:
    *   `#a(finale) = #b(t₁) + #b(t₂) + #b(t₃) + 2`
    Questo significa che `#a(finale) = #b(finale) + 2`, che è esattamente la definizione di `L1`.

Questa grammatica genera tutte le stringhe richieste, perché le due `a` in eccesso possono apparire in qualsiasi posizione, separate e circondate da stringhe con un numero bilanciato di `a` e `b`.

---

### Spiegazione e Svolgimento del Punto 2 (L2)

#### **Passo 1: Analizzare la natura del linguaggio L2**

Il linguaggio `L2` richiede che il numero di `a` sia il doppio del numero di `b` (`#a = 2 * #b`). Anche questo è un problema di conteggio.

#### **Passo 2: Confrontare L2 con L1 e determinare il tipo di grammatica**

La risposta è che il tipo di grammatica **non cambierebbe**. Rimane una **Grammatica Libera dal Contesto (CFG)**.

**Giustificazione:**
La ragione fondamentale è che la classe dei linguaggi generati dalle CFG è la stessa classe dei linguaggi riconosciuti dagli **Automi a Pila (PDA)**. Se possiamo dimostrare che `L2` è riconoscibile da un PDA, allora deve essere un linguaggio context-free.

Possiamo facilmente immaginare un PDA che riconosca `L2`. La pila può essere usata come un contatore per mantenere la relazione `2:1`.

Ecco come funzionerebbe un PDA (non deterministico):
*   Ogni volta che legge una **`b`** dall'input, **spinge due simboli** (es. `X`, `X`) sulla pila.
*   Ogni volta che legge una **`a`** dall'input, **estrae un simbolo** (`X`) dalla pila.

Una stringa viene accettata se, dopo aver letto l'intera stringa, la pila è vuota.
*   **Esempio 1: `aab`**
    1.  Leggi `a`: la pila è vuota, quindi il PDA deve "prendere in prestito". Un PDA non deterministico può spingere una `A` per ricordare un debito di `b`. (Una macchina più semplice gestisce questo in modo diverso, ma il concetto è valido).
    2.  Una strategia migliore: Leggi `b`: spingi `XX`. Leggi `a`: pop `X`. Leggi `a`: pop `X`. Fine input, pila vuota. **Accetta**.
*   **Esempio 2: `ab`**
    1.  Leggi `a`: ...
    2.  Leggi `b`: ...
    Alla fine la pila non sarà vuota. **Rifiuta**.

Poiché esiste un automa a pila in grado di riconoscere `L2` (mantenendo un contatore che viene incrementato di 1 per ogni `a` e decrementato di 2 per ogni `b`, o viceversa), il linguaggio `L2` è **libero dal contesto**. Di conseguenza, la grammatica a potenza minima richiesta per generarlo è ancora una **Grammatica Libera dal Contesto**, la stessa classe di quella per `L1`.
## Es4
### Passo 1: Analisi e Scomposizione del Linguaggio

Il linguaggio `L` è definito da un insieme di regole che creano una partizione naturale. Una stringa in `L` può contenere:
1.  **Nessuna `c` o `d`**: In questo caso, la stringa è composta solo da `a` e `b` in numero arbitrario. Chiamiamo questo sotto-linguaggio `L_ab`.
2.  **Esattamente una `c`**: La stringa ha la forma `xcy`, dove `x` e `y` sono composti solo da `a` e `b`. La condizione è che `#a(x) = #b(x)` (numero di `a` uguale al numero di `b` in `x`) e `#a(y) = #b(y)`. Chiamiamo questo sotto-linguaggio `L_c`.
3.  **Esattamente una `d`**: La stringa ha la forma `xdy`, dove `x` e `y` sono composti solo da `a` e `b`. La condizione è che `#a(x) = 2 * #b(x)` (numero di `a` doppio rispetto al numero di `b` in `x`) e `#a(y) = 2 * #b(y)`. Chiamiamo questo sotto-linguaggio `L_d`.

Il linguaggio totale `L` è l'unione di questi tre sotto-linguaggi: `L = L_ab ∪ L_c ∪ L_d`.

### Passo 2: Classificazione dei Sotto-Linguaggi e Scelta del Formalismo

Per trovare la grammatica a "potenza minima", dobbiamo determinare la classe di linguaggio più semplice in grado di descrivere `L`. Analizziamo la classe di ogni sotto-linguaggio:

*   **`L_ab`**: Questo è il linguaggio di tutte le stringhe sull'alfabeto `{a, b}`. È descritto dall'espressione regolare `(a|b)*`. Pertanto, `L_ab` è un **linguaggio regolare**.

*   **`L_c`**: Questo linguaggio richiede di contare e confrontare il numero di `a` e `b`. Il linguaggio delle stringhe `w` con `#a(w) = #b(w)` è l'esempio classico di un linguaggio **libero dal contesto (Context-Free) ma non regolare**. Poiché `L_c` è costruito concatenando due linguaggi di questo tipo con il simbolo `c`, `L_c` è anch'esso **libero dal contesto**.

*   **`L_d`**: Similmente a `L_c`, questo linguaggio richiede un conteggio (`#a(w) = 2 * #b(w)`). Questa operazione non può essere gestita da un automa a stati finiti (memoria finita), ma può essere gestita da un automa a pila (memoria illimitata). Pertanto, `L_d` è anch'esso **libero dal contesto**.

**Conclusione sulla classe di `L`:**
Il linguaggio `L` è l'unione di un linguaggio regolare (`L_ab`) e due linguaggi liberi dal contesto (`L_c`, `L_d`). La classe dei linguaggi liberi dal contesto è chiusa rispetto all'unione. Poiché i componenti `L_c` e `L_d` non sono regolari, il linguaggio complessivo `L` non può essere regolare.
Pertanto, il linguaggio `L` è **Libero dal Contesto (Context-Free)**, e la grammatica a potenza minima che lo genera è una **Grammatica Libera dal Contesto (Context-Free Grammar)**.

### Passo 3: Costruzione della Grammatica

Costruiremo la grammatica seguendo la scomposizione del linguaggio.

1.  **Simbolo di Inizio `S`**: Gestisce l'unione dei tre sotto-linguaggi.
2.  **Non-terminale `R`**: Genera il linguaggio regolare `L_ab`.
3.  **Non-terminale `E`**: Genera le stringhe `w` con un numero uguale di `a` e `b` (`#a(w) = #b(w)`), necessarie per `L_c`.
4.  **Non-terminale `T`**: Genera le stringhe `w` con il doppio di `a` rispetto alle `b` (`#a(w) = 2 * #b(w)`), necessarie per `L_d`.

Ecco la grammatica completa:

**1. Regola di Partenza (Unione):**
`S → R | E c E | T d T`

*   `S → R`: genera una stringa composta solo da `a` e `b`.
*   `S → E c E`: genera una stringa di `L_c`.
*   `S → T d T`: genera una stringa di `L_d`.

**2. Regole per `R` (Linguaggio Regolare `{a,b}*`)**
`R → aR | bR | ε`

*   Queste sono le regole standard per generare qualsiasi sequenza di `a` e `b`, inclusa la stringa vuota (`ε`).

**3. Regole per `E` (Linguaggio con `#a = #b`)**
`E → aEbE | bEaE | ε`

*   Questa è la grammatica classica per questo linguaggio. Ogni regola di produzione mantiene il bilanciamento: per ogni `a` introdotto, viene introdotto anche un `b`. Le chiamate ricorsive a `E` in mezzo permettono di generare le stringhe in qualsiasi ordine (es. `ab`, `ba`, `aabb`, `abab`, etc.). `ε` è il caso base.

**4. Regole per `T` (Linguaggio con `#a = 2 * #b`)**
`T → aTaTbT | aTbTaT | bTaTaT | ε`

*   Questa grammatica è un'estensione del concetto usato per `E`. Per mantenere il bilanciamento `2:1`, **ogni volta che introduciamo una `b`, dobbiamo introdurre anche due `a`**. Le tre regole non terminali coprono le permutazioni di base (`aab`, `aba`, `baa`). Le chiamate ricorsive a `T` in mezzo permettono di generare stringhe più complesse mantenendo la proporzione. `ε` è il caso base.

---
### **Riepilogo della Grammatica a Potenza Minima**

**Simboli Non Terminali:** `{S, R, E, T}`
**Simboli Terminali:** `{a, b, c, d}`
**Simbolo di Inizio:** `S`
**Regole di Produzione:**
*   `S → R | E c E | T d T`
*   `R → aR | bR | ε`
*   `E → aEbE | bEaE | ε`
*   `T → aTaTbT | aTbTaT | bTaTaT | ε`

## ES5
Si consideri la seguente grammatica:

$G = \begin{cases} S \to CBS | CS | BS | a \\ CB \to BC \\ CC \to c \\ BB \to b \end{cases}$

a) Che tipo di grammatica è G?
b) Che linguaggio genera G?
c) Si scriva un automa a potenza minima che accetti il linguaggio generato da G.

---

### **a) Che tipo di grammatica è G?**

Per classificare la grammatica, la analizziamo secondo la gerarchia di Chomsky, partendo dal tipo più restrittivo.

1.  **Tipo 3 (Regolare):** No. Le regole regolari devono avere la forma `A → aB` o `A → a`. Regole come `S → CBS` (con più di un non-terminale) violano questa forma.
2.  **Tipo 2 (Libera dal contesto / Context-Free):** No. Le regole libere dal contesto devono avere un singolo simbolo non-terminale sulla sinistra. Le regole `CB → BC`, `CC → c` e `BB → b` hanno più di un simbolo a sinistra, quindi violano questa condizione.
3.  **Tipo 1 (Sensibile al contesto / Context-Sensitive):** No. Le regole sensibili al contesto devono essere "monotone", cioè la lunghezza della parte destra deve essere maggiore o uguale alla lunghezza della parte sinistra (`|destra| ≥ |sinistra|`). Le regole `CC → c` e `BB → b` **non sono monotone** (`1 < 2`), in quanto sono regole "contraenti". Questa violazione significa che la grammatica non è di Tipo 1.
4.  **Tipo 0 (Generale / Ricorsivamente Enumerabile):** Sì. Poiché la grammatica non rientra in nessuna delle classi più restrittive, appartiene alla classe più generale, che non ha restrizioni sulla forma delle regole (a parte il fatto che il lato sinistro non può essere vuoto).

**Risposta:** La grammatica G è di **Tipo 0 (generale)**.

---

### **b) Che linguaggio genera G?**

Analizziamo l'interazione tra le regole per capire quali stringhe terminali (`a`, `b`, `c`) possono essere generate.

*   **Regole di generazione (`S → CBS|CS|BS`):** Queste regole introducono i non-terminali `C` e `B`.
*   **Regola di scambio (`CB → BC`):** Questa regola è fondamentale. Permette di scambiare di posto una `C` e una `B` adiacenti. Ciò significa che l'ordine in cui `C` e `B` vengono generati è irrilevante; possiamo sempre riordinarli per raggruppare tutte le `B` e tutte le `C`.
*   **Regole di consumo (`CC → c`, `BB → b`):** Queste sono le uniche regole che producono i terminali `b` e `c`. È cruciale notare che consumano i non-terminali **in coppia**. Questo implica che, per eliminare tutti i non-terminali `C` e `B` da una derivazione, il numero totale di `C` generati deve essere **pari**, e il numero totale di `B` generati deve essere **pari**.
*   **Regola terminale (`S → a`):** Questa è l'unica regola che produce il terminale `a` e che ferma la ricorsione (eliminando `S`).

Mettendo insieme queste osservazioni, una derivazione valida deve generare un numero pari di `B` e un numero pari di `C`, che possono essere trasformati in un qualsiasi numero di `b` e `c`. Infine, la derivazione deve terminare con la regola `S → a`. La struttura delle regole di `S` fa sì che questo `a` appaia alla fine. Pertanto, il linguaggio è composto da qualsiasi sequenza di `b` e `c`, seguita da un'unica `a`.

**Risposta:** Il linguaggio generato da G può essere descritto dall'espressione regolare **`(b|c)*a`**.

---

### **c) Si scriva un automa a potenza minima che accetti il linguaggio generato da G.**

Poiché il linguaggio è `(b|c)*a`, si tratta di un **linguaggio regolare**. Il modello a potenza minima per un linguaggio regolare è un **Automa a Stati Finiti (FSA)**, in particolare un Automa a Stati Finiti Deterministico (DFA).

#### **Guida al Disegno dell'Automa**

Segui questi passaggi per disegnare il DFA che riconosce `(b|c)*a`.

**1. Disegnare gli Stati**
Avrai bisogno di tre stati in totale:
*   Disegna un cerchio e etichettalo **`q₀`**. Aggiungi una freccia che punta verso di esso per indicare che è lo **stato iniziale**. In questo stato, non abbiamo ancora visto la `a` finale.
*   Disegna un secondo cerchio e etichettalo **`q₁`**. Disegna un **doppio cerchio** attorno ad esso per indicare che è uno **stato finale (di accettazione)**. Raggiungeremo questo stato subito dopo aver letto la `a` finale.
*   Disegna un terzo cerchio e etichettalo **`q_dead`**. Questo sarà uno stato "trappola" non finale. Se la stringa continua dopo la `a`, finiremo qui.

**2. Disegnare le Transizioni (le frecce tra gli stati)**

*   **Freccia 1 (Loop su `b` e `c`):**
    *   **Da dove a dove:** Disegna una freccia che parte da `q₀` e torna su se stesso.
    *   **Etichetta:** Scrivi **`b, c`** sopra la freccia.
    *   **Significato:** Finché l'automa legge i caratteri `b` o `c`, rimane nello stato iniziale, in attesa della `a` finale. Questo gestisce la parte `(b|c)*`.

*   **Freccia 2 (Transizione su `a`):**
    *   **Da dove a dove:** Disegna una freccia che parte da `q₀` e punta a `q₁`.
    *   **Etichetta:** Scrivi **`a`** sopra la freccia.
    *   **Significato:** Quando l'automa legge una `a`, passa allo stato finale. Questa è la fine prevista per una stringa valida.

*   **Freccia 3 (Transizioni dallo stato finale):**
    *   **Da dove a dove:** Disegna una freccia che parte da `q₁` e punta allo stato trappola `q_dead`.
    *   **Etichetta:** Scrivi **`a, b, c`** sopra la freccia.
    *   **Significato:** Se, dopo aver raggiunto lo stato finale, l'automa legge qualsiasi altro carattere, la stringa non è valida (la `a` non era l'ultima). L'automa passa a uno stato non finale da cui non può più uscire.

*   **Freccia 4 (Loop nello stato trappola):**
    *   **Da dove a dove:** Disegna una freccia che parte da `q_dead` e torna su se stesso.
    *   **Etichetta:** Scrivi **`a, b, c`** sopra la freccia.
    *   **Significato:** Una volta che una stringa è stata invalidata, rimane non valida indipendentemente dai caratteri successivi.

## ES 6

a) Scrivere una grammatica a potenza minima che generi il linguaggio seguente:
`L1 = {(bc)ᵐ | m ≥ 2}`

b) Sfruttando la risposta al punto precedente, scrivere una grammatica a potenza minima che generi il linguaggio seguente:
`L2 = {bᵏ a (bc)ᵐ aⁿ bᵖ | k > p, n = m, m ≥ 2}`

---

### **a) Grammatica per L1 = {(bc)ᵐ | m ≥ 2}**

#### **1. Analisi e Classificazione del Linguaggio**

*   **Linguaggio:** L1 è l'insieme delle stringhe che consistono nella ripetizione del blocco "bc" per almeno due volte. Esempi: `bcbc`, `bcbcbc`, `bcbcbcbc`, etc.
*   **Classe:** Questo linguaggio ha una struttura ripetitiva molto semplice. Non richiede una memoria illimitata per essere riconosciuto. È un **linguaggio regolare**.
*   **Formalismo a Potenza Minima:** Poiché il linguaggio è regolare, il formalismo a potenza minima è una **Grammatica Regolare (Tipo 3)** o, equivalentemente, un Automa a Stati Finiti.

#### **2. Costruzione della Grammatica Regolare**

La strategia è generare i primi due blocchi `bc` obbligatoriamente, e poi permettere la generazione di altri blocchi `bc` opzionali.

*   **Simbolo di Inizio:** `S`
*   **Regole:**
    1.  `S → bcA`: Questa regola genera il primo blocco `bc` e ci sposta in uno stato `A` per generare il secondo.
    2.  `A → bcB`: Questa regola genera il secondo blocco `bc`, soddisfacendo il vincolo `m ≥ 2`, e ci sposta in uno stato `B` per le ripetizioni opzionali.
    3.  `B → bcB | ε`: Dallo stato `B`, possiamo generare un altro blocco `bc` e rimanere in `B`, oppure possiamo terminare la derivazione con la stringa vuota (`ε`).

**Grammatica Regolare per L1:**
*   `S → bcA`
*   `A → bcB`
*   `B → bcB | ε`

*(Nota: La grammatica nella soluzione fornita è confusa e probabilmente errata o mal trascritta. Quella qui sopra è una grammatica regolare standard e corretta per L1).*

---

### **b) Grammatica per L2 = {bᵏ a (bc)ᵐ aⁿ bᵖ | k > p, n = m, m ≥ 2}**

#### **1. Analisi e Classificazione del Linguaggio**

*   **Linguaggio:** La struttura è `b...b` (prefisso), `a`, `(bc)...(bc)`, `a...a`, `b...b` (suffisso).
*   **Vincoli:** Ci sono due vincoli di conteggio indipendenti:
    1.  `k > p`: Il numero di `b` all'inizio deve essere maggiore del numero di `b` alla fine. Questo è un problema di conteggio classico per i linguaggi liberi dal contesto.
    2.  `n = m`: Il numero di `(bc)` al centro deve essere uguale al numero di `a` che li seguono. Anche questo è un problema di conteggio context-free.
*   **Problema:** Un singolo automa a pila ha una sola pila (memoria). Non può gestire contemporaneamente due compiti di conteggio indipendenti e non annidati come questi (`bᵏ...bᵖ` all'esterno e `(bc)ᵐ...aᵐ` all'interno). Questo linguaggio è un classico esempio di linguaggio che **non è libero dal contesto**. Richiede una memoria più potente.
*   **Classe:** Il linguaggio è **sensibile al contesto (Context-Sensitive)**.
*   **Formalismo a Potenza Minima:** Poiché il linguaggio non è libero dal contesto, la grammatica a potenza minima **non è una grammatica context-free** come suggerito nella soluzione dell'immagine. Sarebbe una **Grammatica Sensibile al Contesto (Tipo 1)**.

#### **2. Costruzione di una Grammatica (per una versione semplificata e Context-Free)**

La soluzione fornita nell'immagine è errata nell'affermare che il linguaggio sia context-free. Tuttavia, il suggerimento "sfruttando la risposta al punto precedente" è un indizio importante. È molto probabile che il linguaggio inteso fosse più semplice, in modo da essere effettivamente context-free e poter riutilizzare la grammatica di L1.

Consideriamo una versione del linguaggio che mantiene solo **uno** dei vincoli di conteggio, ad esempio `k > p`, e tratta la parte centrale come un blocco unico.

**Linguaggio Semplificato (e probabilmente inteso):** `L2' = {bᵏ a w a bᵖ | k > p, w ∈ L1}`
Dove `w` è una qualsiasi stringa generata dalla grammatica per L1.

Per questo linguaggio `L2'`, che **è libero dal contesto**, possiamo costruire una grammatica.

**Grammatica per L2' (Context-Free):**
La strategia è usare una grammatica per generare più `b` all'inizio che alla fine, e nel mezzo inserire una chiamata al simbolo di inizio della grammatica per L1.

*   **Simbolo di Inizio:** `S₂`
*   **Simbolo di Inizio di L1:** `S₁` (rinominiamo `S` da parte (a) per evitare confusione)
*   **Regole:**
    1.  `S₂ → bS₂b`: Questa regola genera una `b` all'inizio e una alla fine, mantenendo il bilanciamento.
    2.  `S₂ → bA`: Questa regola genera una `b` extra all'inizio, rompendo il bilanciamento e garantendo che `k > p`. Ci sposta in uno stato `A` per generare la parte centrale.
    3.  `A → a S₁ a`: Questa regola genera la `a` prima di `w`, poi genera `w` (chiamando la grammatica di L1 tramite il suo simbolo di inizio `S₁`), e infine genera la `a` finale.

**Grammatica Completa (unendo le parti):**
*   `S₂ → bS₂b | bA`
*   `A → a S₁ a`
*   `S₁ → bcB` *(Usiamo una versione leggermente compattata di G1)*
*   `B → bcC`
*   `C → bcC | ε`
## ES 7


Si consideri il seguente linguaggio `L` definito sull'alfabeto `Σ = {a, b, c, d}`:

`L = {aⁿbⁱcʲdᵏ | n ≥ 0, i ≥ 0, j ≥ 0, k ≥ 0, n = i + j + k}`

Si descriva la grammatica a potenza minima che lo genera.

---

### **Analisi e Classificazione del Linguaggio**

1.  **Struttura della stringa:** Le stringhe hanno una forma molto rigida e ordinata: prima tutte le `a`, poi tutte le `b`, poi tutte le `c`, e infine tutte le `d`.
2.  **Vincolo di Conteggio:** Il numero di `a` iniziali (`n`) deve essere esattamente uguale alla somma del numero di `b`, `c` e `d` (`i + j + k`).
3.  **Classificazione:**
    *   Questo vincolo di conteggio non può essere gestito da un automa a stati finiti (FSA), che ha una memoria finita. Pertanto, il linguaggio **non è regolare**.
    *   Il vincolo può essere gestito da un **automa a pila (Pushdown Automaton)**. La strategia sarebbe:
        1.  Leggere tutte le `n` `a` e spingere `n` simboli sulla pila.
        2.  Leggere tutte le `b`, `c` e `d` e, per ogni simbolo letto, estrarre (pop) un simbolo dalla pila.
        3.  Se, alla fine della stringa, la pila è vuota, significa che il conteggio `n = i + j + k` era corretto.
    *   Poiché il linguaggio è riconoscibile da un automa a pila, è un **linguaggio libero dal contesto (Context-Free)**.

**Conclusione:** La grammatica a potenza minima che lo genera è una **Grammatica Libera dal Contesto (Context-Free Grammar)**.

---

### **Spiegazione della Grammatica Fornita**

La soluzione fornisce la seguente grammatica:

$G = \begin{cases} S \to aSd \mid A \\ A \to aAc \mid B \\ B \to aBb \mid \varepsilon \end{cases}$

Questa grammatica è molto elegante e funziona generando "dall'esterno verso l'interno". La strategia è quella di generare una `a` all'inizio della stringa per ogni `b`, `c` o `d` generato alla fine.

Analizziamo il funzionamento delle regole:

*   **Regola `B → aBb | ε` (Gestisce le `b`):**
    *   Questa regola è il cuore del conteggio. Ogni volta che viene applicata ricorsivamente (`aBb`), genera una `a` a sinistra e una `b` a destra, mantenendo il bilanciamento `1 a : 1 b`.
    *   La regola `B → ε` (epsilon) termina la generazione di `a` e `b`, lasciando una stringa della forma `aⁱBbⁱ`. Sostituendo `B` con `ε`, si ottiene `aⁱbⁱ`.

*   **Regola `A → aAc | B` (Aggiunge le `c`):**
    *   Questa regola si basa sulla precedente. Ogni volta che viene applicata (`aAc`), genera una `a` a sinistra e una `c` a destra.
    *   Quando si decide di smettere di generare `c`, si passa a `B` (`A → B`).
    *   Una derivazione tipica che parte da `A` sarebbe: `A → aAc → aaAcc → aaBcc`. Ora, espandendo `B` (ad esempio con `B → aBb → ab`), si ottiene `aa(ab)cc = a³b¹c²`. Notiamo che il numero di `a` (3) è uguale alla somma del numero di `b` (1) e `c` (2). `A` genera quindi stringhe della forma `aʲ⁺ⁱ bⁱ cʲ`.

*   **Regola `S → aSd | A` (Aggiunge le `d`):**
    *   Questa è la regola di livello più alto e segue la stessa logica. Ogni applicazione di `aSd` genera una `a` all'inizio e una `d` alla fine.
    *   Quando si smette di generare `d`, si passa ad `A` (`S → A`).
    *   Una derivazione completa potrebbe essere:
        `S → aSd` (genera `a...d`, `k=1`)
        `→ a(aSd)d = aaSdd` (genera `a...d`, `k=2`)
        `→ aa(A)dd` (smette di generare `d`, passa ad A)
        `→ aa(aAc)dd` (genera `a...c`, `j=1`)
        `→ aa(a(B)c)dd = aaaBcdd` (smette di generare `c`, passa a B)
        `→ aaa(aBb)cdd` (genera `a...b`, `i=1`)
        `→ aaa(a(ε)b)cdd = a⁴εb¹c¹d² = a⁴b¹c¹d²`
    *   Controlliamo il risultato: `n=4`, `i=1`, `j=1`, `k=2`. La condizione `n = i+j+k` è soddisfatta (`4 = 1+1+2`). La stringa generata `aaaabcdd` ha la forma corretta.

Questa grammatica genera correttamente tutte e sole le stringhe del linguaggio `L`, ed è una grammatica libera dal contesto.
# DECIDIBILITA'




## *Es1:*

Ada e Gino hanno un progetto di famiglia e stanno pensando ai possibili nomi per la futura prole. Ciascuno dei due attinge da un insieme N di nomi, infinito e numerabile, e fornisce una descrizione finita dell’insieme (non vuoto) dei nomi di proprio gradimento. Si assuma per semplicità che tali descrizioni siano espresse come algoritmi Ai, i ∈ {Ada, Gino}, scritti in linguaggio C, che calcolano le corrispettive funzioni fi : N → {0,1} che restituiscono 1 a fronte di un nome gradito o 0 altrimenti.

1.  È decidibile stabilire se, dato un generico nome n, esso sia gradito ad entrambi?
2.  È decidibile stabilire se l’insieme dei nomi graditi ad entrambi sia vuoto?

Dopo attenta analisi, le descrizioni dei nomi graditi ai due non risultano sufficientemente compatibili e Ada si sta chiedendo se con un potenziale nuovo partner x (capace di fornire analoga descrizione dell’insieme non vuoto dei nomi di proprio gradimento) avrebbe miglior fortuna.

3.  È decidibile stabilire se l’insieme dei nomi graditi sia ad Ada sia al generico partner x sia vuoto?

---

**Spiegazione Passo Passo e Soluzione:**

Per affrontare questo tipo di problemi, dobbiamo richiamare alcuni concetti fondamentali della Teoria della Computabilità:

*   **Funzione Computabile:** Una funzione è computabile se esiste un algoritmo (come un programma C) che la calcola.
*   **Decidibilità:** Un problema è decidibile se esiste un algoritmo che, per ogni possibile input, termina in un tempo finito e fornisce una risposta corretta (sì/no, vero/falso).
*   **Semidecidibilità (o Riconoscibilità):** Un problema è semidecidibile se esiste un algoritmo che, per ogni input "sì", termina e risponde "sì", mentre per ogni input "no", o termina e risponde "no", o non termina affatto. In altre parole, possiamo riconoscere le istanze positive, ma non siamo garantiti di riconoscere quelle negative.
*   **Teorema di Rice:** Afferma che ogni proprietà non banale di funzioni parziali computabili è indecidibile. Una proprietà è "non banale" se non è soddisfatta da tutte le funzioni computabili e non è soddisfatta da nessuna funzione computabile. Una proprietà di una funzione è "intrinseca" se dipende solo dal comportamento della funzione (cioè, l'insieme degli input su cui è definita e i valori che assume), e non da come è implementata.

---

**Analisi del Problema:**

Le funzioni $f_{Ada}$ e $f_{Gino}$ sono definite da algoritmi C, quindi sono funzioni computabili. Poiché restituiscono 0 o 1 per ogni nome in N, sono anche funzioni **totali** (cioè, sono definite per ogni possibile input, non vanno mai in loop infinito).

---

**1. È decidibile stabilire se, dato un generico nome n, esso sia gradito ad entrambi?**

*   **Cosa chiede il problema:** Dato un input specifico `n` (un nome), vogliamo sapere se `f_Ada(n) = 1` E `f_Gino(n) = 1`.

*   **Come possiamo verificarlo:**
    1.  Esegui l'algoritmo $A_{Ada}$ con input `n`. Poiché $f_{Ada}$ è totale, questo calcolo terminerà e ci darà $f_{Ada}(n)$.
    2.  Esegui l'algoritmo $A_{Gino}$ con input `n`. Poiché $f_{Gino}$ è totale, questo calcolo terminerà e ci darà $f_{Gino}(n)$.
    3.  Controlla se entrambi i risultati sono 1.

*   **Conclusione:** Sì, è decidibile. Abbiamo un algoritmo (descritto sopra) che termina sempre e fornisce una risposta corretta (vero/falso). Quindi, è anche semidecidibile.

---

**2. È decidibile stabilire se l’insieme dei nomi graditi ad entrambi sia vuoto?**

*   **Cosa chiede il problema:** Vogliamo sapere se esiste almeno un nome `n` tale che $f_{Ada}(n) = 1$ E $f_{Gino}(n) = 1$. In simboli: $\exists n \in N : (f_{Ada}(n)=1 \land f_{Gino}(n)=1)$.

*   **Riflessione sulla Decidibilità:**
    *   Consideriamo il complemento del problema: "l'insieme dei nomi graditi ad entrambi NON è vuoto" (cioè, esiste almeno un nome gradito ad entrambi). Questo problema è semidecidibile. Possiamo enumerare tutti i nomi $n_1, n_2, n_3, \dots$ nell'insieme infinito e numerabile N. Per ogni nome $n_k$:
        *   Calcoliamo $f_{Ada}(n_k)$ e $f_{Gino}(n_k)$.
        *   Se troviamo un $n_k$ per cui entrambi sono 1, allora l'algoritmo termina e risponde "sì" (l'insieme non è vuoto).
        *   Se l'insieme fosse vuoto, l'algoritmo continuerebbe a cercare all'infinito senza mai trovare un nome e quindi non terminerebbe mai.
    *   Un problema è decidibile se e solo se sia esso che il suo complemento sono semidecidibili.
    *   Quindi, se il complemento del problema (insieme non vuoto) è semidecidibile, dobbiamo chiederci se il problema originale (insieme vuoto) è anch'esso semidecidibile.

* 
    *   **Conclusioni (seguendo la logica standard):** Il problema "è decidibile stabilire se l'insieme dei nomi graditi ad entrambi sia vuoto?" è **indecidibile** e nemmeno semidecidibile. Il suo complemento "l'insieme non è vuoto" è semidecidibile.
    * 
---

**3. È decidibile stabilire se l’insieme dei nomi graditi sia ad Ada sia al generico partner x sia vuoto?**

*   **Cosa chiede il problema:** Ora, invece di Gino, abbiamo un generico partner `x`. Ci viene data la sua descrizione (algoritmo $A_x$) e vogliamo sapere se l'intersezione dei nomi graditi da Ada e da `x` è vuota.
    *   In altre parole, data una funzione computabile $f_x$ (definita dal suo algoritmo $A_x$), vogliamo sapere se $\exists n \in N : (f_{Ada}(n)=1 \land f_x(n)=1)$.
    *   Questo problema è del tipo: "Stabilire una proprietà della funzione $f_x$ (o meglio, della coppia $(f_{Ada}, f_x)$)".

*   **Applicazione del Teorema di Rice:**
    *   **Il Teorema di Rice si applica a proprietà non banali di funzioni parziali computabili.** Anche se le funzioni sono totali, il teorema di Rice si estende anche a proprietà degli insiemi ricorsivi (cioè gli insiemi dei nomi graditi, che sono gli insiemi accettati dalle funzioni).
    *   **Cos'è la proprietà in questione?** La proprietà è: "L'insieme dei nomi graditi comuni ad Ada e a $x$ è vuoto". Formalmente, se $L_{Ada} = \{n \mid f_{Ada}(n)=1\}$ e $L_x = \{n \mid f_x(n)=1\}$, la proprietà è "$L_{Ada} \cap L_x = \emptyset$".
    *   **È una proprietà non banale?**
        *   Consideriamo $f_x$ tale che $f_x(n) = 0$ per tutti gli $n$. In questo caso, $L_x = \emptyset$, quindi $L_{Ada} \cap L_x = \emptyset$. Questa funzione soddisfa la proprietà.
        *   Consideriamo $f_x$ tale che $f_x(n) = f_{Ada}(n)$ per tutti gli $n$. Poiché l'insieme dei nomi graditi di Ada è non vuoto (specificato nel problema), allora $L_{Ada} \cap L_x = L_{Ada} \neq \emptyset$. Questa funzione NON soddisfa la proprietà.
        *   Poiché la proprietà è soddisfatta da alcune funzioni $f_x$ e non da altre, è una proprietà **non banale**.
    *   **Conclusione dal Teorema di Rice:** Poiché è una proprietà non banale di una funzione computabile, è **indecidibile**.

*   **Semidecidibilità:**
    *   **Il complemento del problema:** "L'insieme dei nomi graditi sia ad Ada sia al generico partner x **non** è vuoto." ($\exists n \in N : (f_{Ada}(n)=1 \land f_x(n)=1)$).
    *   Questo è semidecidibile. Possiamo enumerare tutti i nomi $n_0, n_1, n_2, \dots$. Per ogni $n_i$:
        *   Eseguiamo $A_{Ada}(n_i)$ e $A_x(n_i)$. (Ricorda che $A_x$ è un algoritmo in C, quindi computabile).
        *   Se entrambi restituiscono 1, allora l'algoritmo termina e risponde "sì" (l'intersezione non è vuota).
        *   Se l'intersezione è vuota, l'algoritmo non troverà mai un nome e continuerà all'infinito, quindi non terminerà.
    *   Poiché il complemento è semidecidibile, e il problema originale è indecidibile (dal Teorema di Rice), allora il problema originale **non è semidecidibile**. (Ricorda: un problema è decidibile se e solo se sia esso che il suo complemento sono semidecidibili. Se un problema non è semidecidibile ma il suo complemento lo è, allora è indecidibile).

---

**Riepilogo delle Soluzioni (con mia analisi critica sul punto 2):**

1.  **È decidibile stabilire se, dato un generico nome n, esso sia gradito ad entrambi?**
    *   **Soluzione:** Decidibile.
    *   **Motivazione:** Le funzioni $f_{Ada}$ e $f_{Gino}$ sono computabili e totali. Basta eseguire entrambi gli algoritmi per il nome `n` e verificare i risultati.

2.  **È decidibile stabilire se l’insieme dei nomi graditi ad entrambi sia vuoto?**
    *   **Soluzione Data dall'esercizio:** Decidibile (è una domanda chiusa).
    *   **Mia analisi critica:** Indecidibile e non semidecidibile. Si tratta di una proprietà non banale dell'output combinato di due funzioni computabili totali (se il loro insieme di "1" ha un'intersezione vuota). Per il Teorema di Rice, è indecidibile. Il suo complemento (l'insieme *non* è vuoto) è semidecidibile.

3.  **È decidibile stabilire se l’insieme dei nomi graditi sia ad Ada sia al generico partner x sia vuoto?**
    *   **Soluzione:** Indecidibile e non semidecidibile.
    *   **Motivazione:** Si tratta di una proprietà non banale dell'insieme accettato dalla funzione $f_x$ in relazione a $f_{Ada}$. Si applica il Teorema di Rice, rendendo il problema indecidibile. Il suo complemento (l'intersezione *non* è vuota) è semidecidibile.


##  Es 2

**Esercizio 2 (8 punti)**

Siete stati incaricati di valutare l’efficacia di strumenti di Intelligenza Artificiale (IA) generativa per codice, per esempio Copilot. Per questo motivo, vi viene chiesto di creare un insieme finito e non vuoto di programmi C di riferimento, e per ognuno di questi programmi di definire un prompt da dare a Copilot per generare il programma richiesto (per esempio “genera un programma C che calcola la radice quadrata intera di un numero intero ricevuto in ingresso”).

NB: Un programma di IA generativa come Copilot restituisce risposte (per esempio, programmi) diverse anche a fronte dello stesso prompt, quando invocato più volte.

1.  L’obiettivo è di valutare se, per ognuno dei programmi di riferimento, il programma generato da Copilot funziona come desiderato (nell’esempio precedente, se calcola veramente la radice quadrata del numero ricevuto in ingresso) oppure no. È fattibile il compito che vi hanno assegnato? Motivare opportunamente la risposta.

2.  Supponiamo che, invece che studiare la capacità di generare programmi C, vi sia richiesto di studiare la capacità di generare automi a stati finiti (quindi, in questo caso si tratterebbe di creare un insieme di FSA di riferimento, ognuno con il relativo prompt, e chiedere allo strumento di IA generativa di produrre l’automa richiesto). È fattibile il compito che vi hanno assegnato? Motivare opportunamente la risposta.

---

### Spiegazione e Svolgimento Passo Passo

#### **Domanda 1: Valutare l'equivalenza di programmi C**

**Obiettivo:** Stabilire se un programma generato da Copilot (`P_Copilot`) è funzionalmente equivalente a un nostro programma di riferimento (`P_Rif`). "Funzionalmente equivalente" significa che per ogni possibile input, i due programmi producono lo stesso output (o entrambi non terminano).

**Ragionamento:**

1.  **Formalizzare il problema:** Il compito richiede di risolvere il **Problema dell'Equivalenza tra Programmi**. Dati due programmi, `P1` e `P2`, vogliamo decidere se calcolano la stessa funzione.

2.  **Richiamare la Teoria della Computabilità:** Questo è un problema classico e fondamentale. La domanda è: esiste un algoritmo universale `Equivalente(P1, P2)` che prende in input il codice sorgente di due programmi e restituisce `true` se sono equivalenti e `false` altrimenti, terminando sempre?

3.  **Applicare il Teorema di Rice:** Il Teorema di Rice afferma che **ogni proprietà non banale delle funzioni calcolabili è indecidibile**.
    *   **Proprietà:** Una caratteristica della funzione che un programma calcola (es. "la funzione restituisce sempre 0", "la funzione termina per l'input 42").
    *   **Non banale:** La proprietà deve essere vera per almeno una funzione calcolabile e falsa per almeno un'altra.

4.  **Verificare le condizioni del Teorema di Rice nel nostro caso:**
    *   La nostra "proprietà" è: "calcolare la stessa funzione del nostro programma di riferimento `P_Rif`".
    *   Questa proprietà è **non banale**?
        *   Sì. Esiste almeno un programma che la soddisfa (lo stesso `P_Rif`).
        *   Sì. Esiste almeno un programma che non la soddisfa (ad esempio, un programma che stampa "hello world" invece di calcolare la radice quadrata).
    *   Poiché la proprietà è non banale e riguarda il comportamento funzionale dei programmi (e non la loro sintassi), il Teorema di Rice si applica.

**Conclusione (Punto 1):**
Il compito **non è fattibile** (è indecidibile). Non esiste un algoritmo generale in grado di determinare se due programmi arbitrari sono equivalenti. Potremmo testare i programmi con alcuni input, ma non potremo mai avere la certezza matematica che si comporteranno allo stesso modo per *tutti* gli infiniti input possibili. Qualsiasi tentativo di creare un verificatore automatico fallirebbe nel caso generale.

---

#### **Domanda 2: Valutare l'equivalenza di Automi a Stati Finiti (FSA)**

**Obiettivo:** Stabilire se un automa a stati finiti generato da Copilot (`A_Copilot`) è equivalente a un nostro automa di riferimento (`A_Rif`). "Equivalente" qui significa che i due automi **riconoscono lo stesso linguaggio**.

**Ragionamento:**

1.  **Formalizzare il problema:** Il compito richiede di risolvere il **Problema dell'Equivalenza tra Automi a Stati Finiti**. Dati due FSA, `A1` e `A2`, vogliamo decidere se `L(A1) = L(A2)`.

2.  **Richiamare la Teoria degli Automi:** A differenza dei programmi generici (che sono potenti come le Macchine di Turing), gli automi a stati finiti sono un modello di calcolo molto meno potente e più limitato. Questa limitazione rende molti problemi, che sono indecidibili per i programmi, **decidibili** per gli automi.

3.  **Algoritmi per la decisione:** Esistono algoritmi effettivi che risolvono questo problema. La soluzione ne suggerisce due, vediamoli in dettaglio.

    **Metodo 1: Basato su operazioni di chiusura (Complemento e Intersezione)**
    Due linguaggi `L1` e `L2` sono uguali se e solo se non ci sono stringhe che appartengono a uno ma non all'altro. Formalmente: `L1 = L2` se e solo se `(L1 \ L2) ∪ (L2 \ L1) = ∅`.
    Questa espressione è nota come differenza simmetrica. Poiché `L1 \ L2` è uguale a `L1 ∩ L2ᶜ` (complemento di L2), possiamo costruire un automa per la differenza simmetrica e verificare se il suo linguaggio è vuoto.

    *   **Passo 1:** Dati `A_Rif` e `A_Copilot`, costruiamo gli automi per i linguaggi complemento, `L(A_Rif)ᶜ` e `L(A_Copilot)ᶜ`. Questo è un algoritmo standard (basta invertire stati finali e non finali in un DFA).
    *   **Passo 2:** Costruiamo un automa per l'intersezione `L(A_Rif) ∩ L(A_Copilot)ᶜ`. Anche questo è un algoritmo standard (costruzione del prodotto).
    *   **Passo 3:** Costruiamo un automa per l'intersezione `L(A_Copilot) ∩ L(A_Rif)ᶜ`.
    *   **Passo 4:** Costruiamo un automa per l'unione dei due linguaggi risultanti.
    *   **Passo 5:** Verifichiamo se il linguaggio riconosciuto dall'automa finale è vuoto. Questo è decidibile: basta controllare se esiste un percorso dallo stato iniziale a uno stato finale.

    Poiché ogni passo è eseguibile da un algoritmo che termina, l'intero processo è un algoritmo di decisione.

    **Metodo 2: Basato sulla Minimizzazione**
    Questo metodo è spesso più elegante e pratico. Si basa su un teorema fondamentale: per ogni linguaggio regolare, esiste un **unico** automa a stati finiti deterministico (DFA) minimo (con il minor numero di stati) che lo riconosce (a meno di isomorfismo, cioè i nomi degli stati possono cambiare ma la struttura del grafo è identica).

    *   **Passo 1:** Se `A_Rif` e `A_Copilot` non sono deterministici (NFA), li convertiamo in DFA equivalenti (algoritmo di costruzione per sottoinsiemi).
    *   **Passo 2:** Applichiamo un algoritmo di minimizzazione (es. algoritmo di Hopcroft o di riempimento della tabella) a entrambi i DFA.
    *   **Passo 3:** Confrontiamo i due automi minimi risultanti. Se sono isomorfi (hanno la stessa struttura), allora i linguaggi originali erano equivalenti. Altrimenti, non lo erano.

    Anche in questo caso, tutti i passaggi sono algoritmici e garantiti per terminare.

**Conclusione (Punto 2):**
Il compito **è fattibile** (è decidibile). A differenza dei programmi C, l'equivalenza degli automi a stati finiti può essere verificata automaticamente e in modo affidabile. Possiamo implementare uno degli algoritmi sopra descritti per confrontare l'automa di riferimento con quello generato e ottenere una risposta certa "Sì" o "No".
## Es 3
#### **1. Stabilire se ogni macchina di Turing il cui indice è pari e minore di 100 si arresta ricevendo in ingresso il proprio indice.**

*   **Analisi del problema:** La domanda riguarda un insieme **finito e specifico** di macchine di Turing. Le macchine da controllare sono quelle con indice `i` appartenente a `{0, 2, 4, ..., 98}`. Sono esattamente 50 macchine. Per ciascuna di queste 50 macchine, la domanda "si arresta sul proprio indice?" (`f_i(i)` termina?) ha una risposta fissa e determinata: o "sì" o "no". Di conseguenza, la domanda complessiva "TUTTE queste 50 macchine si arrestano?" ha una sola risposta possibile, che è o "Vero" o "Falso".

*   **Motivazione ("La domanda è chiusa"):** Il termine "domanda chiusa" significa che la risposta è un valore booleano costante (vero o falso), anche se non lo conosciamo a priori. Poiché la risposta è una costante, esiste un algoritmo che la decide:
    *   Se la risposta vera è "Sì", allora l'algoritmo `return "Sì"` è un algoritmo corretto che termina sempre.
    *   Se la risposta vera è "No", allora l'algoritmo `return "No"` è un algoritmo corretto che termina sempre.
    Poiché un tale algoritmo esiste, il problema è, per definizione, **decidibile**.

*   **Conclusione:**
    *   **Decidibile? SÌ.** Il problema riguarda una verifica su un insieme finito di istanze.
    *   **Semidecidibile? SÌ.** Ogni problema decidibile è anche semidecidibile.

---

#### **2. Stabilire se ogni macchina di Turing il cui indice è pari si arresta ricevendo in ingresso il proprio indice.**

*   **Analisi del problema:** Qui la situazione cambia radicalmente. La domanda ora riguarda un insieme **infinito** di macchine di Turing: quelle con indice `i` in `{0, 2, 4, 6, ...}`. Non possiamo più controllarle una per una.

*   **Motivazione:** Dobbiamo decidere la verità di un'affermazione universale (`∀`) su un insieme infinito di computazioni: `∀k ∈ N, f_{2k}(2k) termina`. Questo è un problema strettamente legato al Problema dell'Arresto, che è indecidibile.
    *   **Perché non è decidibile?** Non esiste un algoritmo generale che possa prendere un indice `i` e determinare se `f_i(i)` termina. A maggior ragione, non esiste un algoritmo che possa farlo per un'infinità di indici.
    *   **Perché non è semidecidibile?** Un algoritmo per semidecidere questo problema dovrebbe terminare e dire "Sì" se la proprietà è vera. Ma per verificare che *tutte* le infinite macchine si arrestino, l'algoritmo dovrebbe, in teoria, simularle tutte e vederle terminare, il che è impossibile. Non c'è un punto in cui ci si può fermare ed essere sicuri che non ci sia una macchina più avanti nell'enumerazione che non termini.
    *   **Nota sulla soluzione fornita:** La motivazione "La domanda è ancora chiusa" qui è **scorretta o fuorviante**. Mentre per il punto 1 si applicava a un numero finito di casi, per un numero infinito di casi questo ragionamento non è più valido e porta a una conclusione errata. Questo problema è una variante del Problema della Totalità ed è **altamente indecidibile** (non è nemmeno semidecidibile).

*   **Conclusione:**
    *   **Decidibile? NO.** È un'affermazione universale su un insieme infinito di computazioni, riconducibile al Problema dell'Arresto.
    *   **Semidecidibile? NO.** Per confermare la risposta "Sì", si dovrebbero verificare infinite computazioni.

---

#### **3. Stabilire se una generica macchina di Turing ha un indice pari.**

*   **Analisi del problema:** L'input è una "generica macchina di Turing". Generalmente, questo significa che ci viene fornito il suo indice `i` (il suo numero di Gödel). Il problema è semplicemente: "Dato un numero `i`, `i` è pari?".

*   **Motivazione:** Questo è un semplice problema aritmetico. L'algoritmo consiste nel calcolare `i mod 2` e verificare se il risultato è 0. Questo algoritmo è banale, termina sempre e dà la risposta corretta. La complessità della macchina di Turing associata a quell'indice è completamente irrilevante.

*   **Conclusione:**
    *   **Decidibile? SÌ.** Il problema si riduce a una semplice verifica di parità su un numero intero.
    *   **Semidecidibile? SÌ.** Poiché è decidibile.

---

#### **4. Stabilire se una generica macchina di Turing restituisce un numero pari per almeno un ingresso.**

*   **Analisi del problema:** Data una macchina `M_i`, dobbiamo stabilire se esiste (`∃`) un input `x` tale che `f_i(x)` termina e il suo valore è un numero pari.

*   **Motivazione per l'indecidibilità (Teorema di Rice):** Questa è una domanda sul **comportamento** della funzione calcolata dalla macchina (`f_i`), non sulla sua sintassi o sul suo indice. Possiamo quindi applicare il Teorema di Rice.
    1.  **La proprietà è "semantica"?** Sì, riguarda il codominio (l'insieme dei valori di output) della funzione.
    2.  **La proprietà è "non banale"?**
        *   Esiste almeno una funzione che la soddisfa? Sì, ad esempio `f(x) = 2`, che restituisce sempre un numero pari.
        *   Esiste almeno una funzione che non la soddisfa? Sì, ad esempio `f(x) = 1`, che non restituisce mai un numero pari.
    Poiché la proprietà è semantica e non banale, per il Teorema di Rice il problema è **indecidibile**.

*   **Motivazione per la semidecidibilità:** Dobbiamo verificare se esiste un algoritmo che termina e dice "Sì" quando la risposta è "Sì". La struttura della domanda ("per **almeno un** ingresso") suggerisce che possiamo cercarlo.
    *   Non possiamo testare gli input uno dopo l'altro (`x=0`, `x=1`, ...) perché la macchina potrebbe non terminare su uno di essi, bloccando la ricerca.
    *   Possiamo usare una tecnica di ricerca esaustiva chiamata **dovetailing (o enumerazione diagonale)**: si simulano tutte le computazioni possibili in parallelo.
    1.  Esegui 1 passo di `f_i(0)`.
    2.  Esegui 2 passi di `f_i(0)` e 1 passo di `f_i(1)`.
    3.  Esegui 3 passi di `f_i(0)`, 2 passi di `f_i(1)` e 1 passo di `f_i(2)`.
    4.  ...e così via.
    Se esiste un input `x` per cui la macchina termina con un output pari, questa procedura di ricerca prima o poi eseguirà quella computazione per un numero sufficiente di passi, troverà il risultato, verificherà che è pari e si arresterà dicendo "Sì". Se non esiste un tale input, la procedura non terminerà mai. Questo corrisponde esattamente alla definizione di **semidecidibilità**.

*   **Conclusione:**
    *   **Decidibile? NO.** Per il Teorema di Rice.
    *   **Semidecidibile? SÌ.** Tramite una ricerca esaustiva (dovetailing).

## Es 4

Si consideri un sistema, chiamato BeeS, il cui comportamento è descritto dall’automa a stati finiti `A`. Sia `S` un insieme (finito) fissato di sequenze di comandi, e `G` un algoritmo (anch’esso fissato) che, dato in input un automa e un insieme finito di sequenze, restituisce un automa a stati finiti (l'algoritmo termina sempre).

1.  È decidibile il problema di stabilire se, fornendogli in input l’automa `A` e l’insieme `S` di sequenze, l’algoritmo `G` restituisce un automa equivalente ad `A`?
2.  È decidibile il problema di stabilire se, preso un qualunque automa a stati finiti `A'` e un insieme di sequenze `S'`, se all’algoritmo `G` vengono forniti in input `A'` e `S'`, esso restituisce un automa equivalente ad `A'`?
3.  È decidibile il problema di stabilire se, preso un qualunque algoritmo `G'`, tale algoritmo, per ogni automa a stati finiti `A'` e insieme di sequenze `S'`, restituisce un automa che è equivalente ad `A'`?

---

### Spiegazione e Svolgimento Passo Passo

#### **Domanda 1: Il caso completamente "Fissato"**

**Problema:** Dati `A`, `S` e `G` (tutti noti e fissati), è decidibile se `G(A, S)` è equivalente ad `A`?

**Analisi:**
La parola chiave qui è **"fissato"**. Non ci sono variabili. La domanda riguarda un'unica, specifica istanza.
1.  Abbiamo l'algoritmo `G`. Lo conosciamo.
2.  Abbiamo l'automa `A`. Lo conosciamo.
3.  Abbiamo l'insieme `S`. Lo conosciamo.

La domanda è se una certa affermazione è vera o falsa. L'affermazione è "`L(G(A, S)) = L(A)`".
Poiché `G`, `A` e `S` sono fissati, il risultato di `G(A, S)` è un automa specifico e ben determinato, che chiamiamo `A_output`. L'algoritmo `G` termina sempre, quindi possiamo calcolare `A_output`.
A questo punto, la domanda si riduce a: "`A_output` è equivalente ad `A`?".

**Conclusione:**
Il problema è **decidibile**.
*   **Motivazione 1 (Algoritmica):** Possiamo scrivere un algoritmo che risolve il problema:
    1.  Esegui `G` con input `A` e `S` per ottenere l'automa `A_output`. Questo passo termina per ipotesi.
    2.  Confronta `A` e `A_output` per verificare se sono equivalenti. Il problema dell'**equivalenza tra due automi a stati finiti è notoriamente decidibile**. (Ad esempio, minimizzando entrambi e verificando se sono isomorfi).
    Poiché entrambi i passaggi sono eseguibili e terminano, l'intero problema è decidibile.
*   **Motivazione 2 (Teorica - "domanda chiusa"):** Poiché non ci sono input variabili, la risposta alla domanda è una costante: o è "Sì" o è "No". Un problema la cui risposta è una costante è sempre decidibile. Se la risposta è "Sì", l'algoritmo `return "Sì"` lo decide. Se la risposta è "No", l'algoritmo `return "No"` lo decide. Poiché un algoritmo decisore esiste, il problema è decidibile.

---

#### **Domanda 2: Il caso con Input "Generici"**

**Problema:** Dato l'algoritmo `G` (fisso), è decidibile se per **qualunque** `A'` e `S'`, `G(A', S')` è equivalente ad `A'`?
*Nota: La domanda come formulata è "preso un qualunque... se... esso restituisce...", che può essere interpretata in due modi. L'interpretazione più sensata (e quella della soluzione) è: "È decidibile il problema che prende in input `A'` e `S'` e determina se `G(A', S')` è equivalente ad `A'`?".*

**Analisi:**
Qui `G` è ancora un nostro strumento fisso, ma `A'` e `S'` sono gli input del problema che vogliamo decidere. Dobbiamo creare un algoritmo `Decisore(A', S')` che risponda alla domanda.

**Conclusione:**
Il problema è **decidibile**. Il ragionamento è quasi identico a quello algoritmico del punto 1, ma ora lo applichiamo a input generici.
1.  **Input:** un automa generico `A'` e un insieme di sequenze `S'`.
2.  **Passo 1:** Esegui l'algoritmo (fisso e noto) `G` con gli input `A'` e `S'` per ottenere un nuovo automa, `A'' = G(A', S')`. Questo passo termina sempre.
3.  **Passo 2:** Utilizza l'algoritmo di decisione per l'equivalenza degli FSA per confrontare `A'` e `A''`. Questo algoritmo termina e restituisce "Sì" o "No".
4.  **Output:** Restituisci il risultato del passo 2.

Abbiamo appena descritto un algoritmo che prende `A'` e `S'` e decide correttamente e in tempo finito se `G(A', S')` è equivalente ad `A'`. Pertanto, il problema è decidibile.

---

#### **Domanda 3: Il caso con Algoritmo "Generico"**

**Problema:** È decidibile se un **qualunque algoritmo `G'`** ha la proprietà di restituire sempre un automa equivalente a quello in input?

**Analisi:**
Questo cambia tutto. Ora, l'input del nostro problema di decisione non è più un automa, ma l'**algoritmo `G'` stesso** (ad esempio, il suo codice sorgente o il suo numero di Gödel). Dobbiamo analizzare questo `G'` arbitrario e decidere se ha una certa proprietà comportamentale.

Questo è un problema su una proprietà di una funzione calcolabile. Il candidato perfetto per risolverlo è il **Teorema di Rice**.

1.  **La Proprietà:** La proprietà `P` di un algoritmo `G'` è: "Per ogni input `(A', S')`, l'output `G'(A', S')` è un automa equivalente ad `A'`".
2.  **La proprietà è sul comportamento (semantica)?** Sì. Non ci interessa come è scritto `G'`, ma solo la relazione tra i suoi input e i suoi output.
3.  **La proprietà è "non banale"?** Per applicare il Teorema di Rice, dobbiamo dimostrare che la proprietà non è né sempre vera né sempre falsa.
    *   **Esiste almeno un algoritmo che ha la proprietà?** Sì. L'algoritmo banale `G_buono(A', S') { return A'; }` ha questa proprietà.
    *   **Esiste almeno un algoritmo che NON ha la proprietà?** Sì. L'algoritmo `G_cattivo(A', S') { return un_automa_che_accetta_il_linguaggio_vuoto; }` non ha questa proprietà (a meno che `A'` non accettasse già il linguaggio vuoto).

Poiché la proprietà è semantica e non banale, il Teorema di Rice si applica.

**Conclusione:**
Il problema è **indecidibile**. Per il Teorema di Rice, non esiste un algoritmo generale in grado di prendere un programma arbitrario `G'` e decidere se possiede la proprietà descritta. Non possiamo semplicemente "eseguire" `G'` come facevamo prima, perché dovremmo testarlo su un'infinità di input `(A', S')` per essere sicuri del suo comportamento universale.

## ES 5
### **Concetti Fondamentali**

*   **Insieme Ricorsivo (o Decidibile):** Un insieme `S` è ricorsivo se esiste un algoritmo (una Macchina di Turing) che, per qualsiasi input `i`, termina **sempre** e risponde correttamente "Sì" (se `i ∈ S`) o "No" (se `i ∉ S`).
*   **Teorema di Rice:** Afferma che qualsiasi proprietà **non banale** del **comportamento** (la funzione calcolata) di una Macchina di Turing è indecidibile. Per applicare il teorema, dobbiamo verificare due condizioni:
    1.  **La proprietà è "semantica":** Riguarda la funzione che la macchina calcola (`fᵢ`), non le caratteristiche interne della macchina (es. numero di stati, simboli sul nastro). Tutti i problemi in questo esercizio soddisfano questa condizione.
    2.  **La proprietà è "non banale":** L'insieme non deve essere né vuoto né l'insieme di *tutti* gli indici. In altre parole, deve esistere almeno una MT che ha la proprietà e almeno una che non ce l'ha.

---
**Si assuma che le macchine di Turing su alfabeto binario calcolino funzioni da Z a Z, interpretando le stringhe sul nastro come numeri in complemento a 2 codificati con il numero minimo di bit necessari. Si considerino i seguenti insiemi e si dica se essi sono ricorsivi, motivando la risposta:**
### **1. S1 = {i | ∃x : fᵢ(x) > 0}**

*   **Definizione in linguaggio naturale:** `S1` è l'insieme degli indici `i` delle Macchine di Turing la cui funzione `fᵢ` produce un risultato **positivo** per almeno un input `x`.
*   **Risposta:** L'insieme **non è ricorsivo**.

**Motivazione (Applicazione del Teorema di Rice):**
Dobbiamo solo verificare che la proprietà "produrre almeno un output positivo" sia non banale.

1.  **Esiste una MT che HA questa proprietà?**
    *   Sì. Consideriamo la funzione costante `f(x) = 1`. Questa funzione è banalmente calcolabile. Il suo output è sempre `1`, che è un numero positivo. L'indice della MT che calcola questa funzione appartiene a `S1`.

2.  **Esiste una MT che NON HA questa proprietà?**
    *   Sì. Consideriamo la funzione costante `g(x) = 0`. Anche questa è calcolabile. Il suo output è sempre `0`, che non è un numero positivo. L'indice della MT che calcola `g(x)` **non** appartiene a `S1`.

Poiché la proprietà è non banale (e semantica), per il Teorema di Rice, l'insieme `S1` è **non ricorsivo**.

---

### **2. S2 = {i | ∃x : fᵢ(x) ≤ 0}**

*   **Definizione in linguaggio naturale:** `S2` è l'insieme degli indici `i` delle Macchine di Turing la cui funzione `fᵢ` produce un risultato **non positivo** (nullo o negativo) per almeno un input `x`.
*   **Risposta:** L'insieme **non è ricorsivo**.

**Motivazione (Applicazione del Teorema di Rice):**
Il ragionamento è identico al precedente. Verifichiamo la non banalità.

1.  **Esiste una MT che HA questa proprietà?**
    *   Sì. La funzione costante `g(x) = 0` è calcolabile e il suo output `0` soddisfa la condizione `≤ 0`. L'indice della MT che la calcola appartiene a `S2`.

2.  **Esiste una MT che NON HA questa proprietà?**
    *   Sì. La funzione costante `f(x) = 1` è calcolabile e il suo output `1` non soddisfa mai la condizione `≤ 0`. L'indice della MT che la calcola **non** appartiene a `S2`.

Poiché la proprietà è non banale, per il Teorema di Rice, l'insieme `S2` è **non ricorsivo**.

---

### **3. S3 = S1 ∪ S2**

*   **Definizione in linguaggio naturale:** `S3` è l'insieme degli indici `i` tali che `i` è in `S1` OPPURE `i` è in `S2`. Questo significa che la funzione `fᵢ` produce un output positivo OPPURE produce un output non positivo. In parole povere, `fᵢ` **deve terminare e produrre un risultato per almeno un input**.
*   **Risposta:** L'insieme **non è ricorsivo**.

**Motivazione (Applicazione del Teorema di Rice):**
La proprietà è "avere un dominio non vuoto" (cioè, terminare per almeno un input). Verifichiamo la non banalità.

1.  **Esiste una MT che HA questa proprietà?**
    *   Sì. Qualsiasi MT che calcola una funzione che termina (come `f(x)=1` o `g(x)=0`) ha questa proprietà. I loro indici sono in `S3`.

2.  **Esiste una MT che NON HA questa proprietà?**
    *   Sì. Consideriamo una MT che, per qualsiasi input, entra in un loop infinito. Questa macchina calcola la **funzione ovunque non definita**, `h(x) = ⊥`. Questa funzione non produce mai un output, quindi non può produrre né un output positivo né uno non positivo. L'indice della MT che calcola `h(x)` **non** appartiene a `S3`.

Poiché la proprietà è non banale, per il Teorema di Rice, l'insieme `S3` è **non ricorsivo**.

---

### **4. S4 = S1 ∩ S2**

*   **Definizione in linguaggio naturale:** `S4` è l'insieme degli indici `i` tali che `i` è in `S1` AND `i` è in `S2`. Questo significa che la funzione `fᵢ` produce almeno un output positivo **E** almeno un output non positivo. In altre parole, il codominio (l'insieme dei valori di output) della funzione contiene sia valori `> 0` sia valori `≤ 0`.
*   **Risposta:** L'insieme **non è ricorsivo**.

**Motivazione (Applicazione del Teorema di Rice):**
Verifichiamo la non banalità.

1.  **Esiste una MT che HA questa proprietà?**
    *   Sì. Consideriamo la funzione `segno(x)`, che restituisce `1` se `x>0`, `0` se `x=0` e `-1` se `x<0`. Questa funzione è calcolabile. Produce sia output positivi (es. `segno(5)=1`) sia output non positivi (es. `segno(-2)=-1`). L'indice della MT che la calcola appartiene a `S4`.

2.  **Esiste una MT che NON HA questa proprietà?**
    *   Sì. La funzione costante `f(x) = 1` produce solo output positivi, quindi non appartiene a `S4`. La funzione `g(x)=0` produce solo output non positivi, quindi non appartiene a `S4`.

Poiché la proprietà è non banale, per il Teorema di Rice, l'insieme `S4` è **non ricorsivo**.

## Es 6

Dato un linguaggio `L` definito su un alfabeto `I`, si consideri l’ipotetica macchina di Turing `ML` a k nastri, che ignora la stringa in input e stampa sul nastro di output la sequenza `l₀ ⋄ l₁ ⋄ l₂ ⋄ ...`, dove `lᵢ ∈ L`, `i ∈ N` e `⋄` è un simbolo separatore. Le parole di `L` compaiono una ed una sola volta nell’output di `ML`, in un ordine non noto a priori.

1.  Si dimostri che, se `ML` esiste, allora `L` è **semi-decidibile**.
2.  Si consideri il caso in cui `ML` esiste e le parole `lᵢ ∈ L` compaiono in **ordine lessicografico** nel nastro di output di `ML`. Si indichi se `L` è decidibile, semi-decidibile o indecidibile e lo si dimostri.

---

### **Concetti Chiave**

*   **Enumeratore:** La macchina `ML` descritta è ciò che in teoria della computabilità si chiama un **enumeratore** per il linguaggio `L`. Un enumeratore è una macchina che "sforna" uno dopo l'altro tutti gli elementi di un insieme, in un qualche ordine.
*   **Semi-decidibile (o Ricorsivamente Enumerabile):** Un linguaggio `L` è semi-decidibile se esiste un algoritmo che, data una stringa `w`, si ferma e risponde "sì" se `w ∈ L`. Se `w ∉ L`, l'algoritmo può non terminare.
*   **Decidibile (o Ricorsivo):** Un linguaggio `L` è decidibile se esiste un algoritmo che, data una stringa `w`, si ferma **sempre** e risponde correttamente "sì" (se `w ∈ L`) o "no" (se `w ∉ L`).

Un teorema fondamentale afferma che **un linguaggio è semi-decidibile se e solo se esiste un enumeratore per esso**. Questo esercizio vi chiede, in pratica, di dimostrare le due parti di questo teorema.

---

### **1. Se `ML` esiste, allora `L` è semi-decidibile**

**Obiettivo:** Dobbiamo dimostrare che, avendo a disposizione l'enumeratore `ML`, possiamo costruire un algoritmo (un "semi-decisore") che riconosca le stringhe di `L`.

**Dimostrazione (Costruzione dell'Algoritmo):**

Vogliamo costruire un algoritmo `Semi_Decisore_L(w)` che prende in input una stringa `w` e si comporta così:
*   Se `w ∈ L`, termina e dice "sì".
*   Se `w ∉ L`, non termina.

Ecco come possiamo costruirlo usando `ML`:

1.  **Input:** Prendi la stringa `w` da testare.
2.  **Simulazione:** Avvia una simulazione della macchina `ML`.
3.  **Monitoraggio:** Man mano che `ML` stampa le parole `l₀, l₁, l₂, ...` sul suo nastro di output, il nostro `Semi_Decisore_L` le esamina una per una.
4.  **Confronto:** Per ogni parola `lᵢ` stampata da `ML`, confrontala con la nostra stringa di input `w`.
    *   **Se `lᵢ == w`:** Abbiamo trovato una corrispondenza! La stringa `w` è stata enumerata da `ML`, quindi `w` appartiene a `L`. L'algoritmo `Semi_Decisore_L` si **ferma immediatamente** e restituisce **"sì"**.
    *   **Se `lᵢ != w`:** Continua la simulazione e passa a esaminare la parola successiva, `lᵢ₊₁`, che `ML` stamperà.

**Analisi del Comportamento dell'Algoritmo:**
*   **Se `w` è effettivamente in `L`:** Per definizione di `ML`, la parola `w` apparirà sul nastro di output prima o poi. Sarà la k-esima parola, `lₖ`, per qualche `k`. Il nostro algoritmo la troverà, il confronto al passo 4 avrà successo, e la procedura terminerà.
*   **Se `w` non è in `L`:** Per definizione di `ML`, la parola `w` non apparirà **mai** sul nastro di output. Il nostro algoritmo continuerà a simulare `ML` all'infinito, aspettando una parola che non arriverà mai. Quindi, la procedura non terminerà.

Questo comportamento corrisponde esattamente alla definizione di un linguaggio **semi-decidibile**.

---

### **2. Se `ML` enumera in ordine lessicografico, `L` è decidibile**

**Obiettivo:** L'ordine ora ci dà un'informazione in più. Dobbiamo dimostrare che questa informazione ci permette di costruire un algoritmo che termina **sempre**, sia per le risposte "sì" che per quelle "no".

**Dimostrazione (Costruzione dell'Algoritmo):**

Vogliamo costruire un algoritmo `Decisore_L(w)` che, data una stringa `w`, si ferma sempre e risponde correttamente.

Ecco come possiamo costruirlo:

1.  **Input:** Prendi la stringa `w` da testare.
2.  **Simulazione:** Avvia una simulazione della macchina `ML`.
3.  **Monitoraggio e Confronto:** Man mano che `ML` stampa le parole `l₀, l₁, l₂, ...` (che ora sono in ordine lessicografico), confronta ogni `lᵢ` con `w`.
    *   **Caso A: Troviamo la stringa (`lᵢ == w`)**
        *   Abbiamo la prova che `w` appartiene a `L`. L'algoritmo si **ferma** e restituisce **"sì"**.

    *   **Caso B: Troviamo una stringa più grande (`lᵢ > w` in ordine lessicografico)**
        *   Poiché `ML` sta stampando le parole in ordine, se ha stampato una parola `lᵢ` che viene *dopo* `w` nell'ordinamento, significa che `w` **non può più comparire**. Se `w` fosse in `L`, sarebbe dovuta apparire prima di `lᵢ`.
        *   Abbiamo la prova che `w` **non** appartiene a `L`. L'algoritmo si **ferma** e restituisce **"no"**.

**Analisi del Comportamento dell'Algoritmo:**
Questo algoritmo **termina sempre**. Perché?
*   **Se `w ∈ L`:** Prima o poi `ML` stamperà `w`, e l'algoritmo terminerà (Caso A).
*   **Se `w ∉ L`:** O `L` è finito (e `ML` si fermerà, permettendoci di concludere), oppure `L` è infinito. Se `L` è infinito, `ML` continuerà a stampare parole sempre più grandi. Prima o poi, stamperà una parola `lᵢ` che è lessicograficamente più grande di `w`. A quel punto, l'algoritmo terminerà (Caso B).

Poiché abbiamo costruito un algoritmo che termina sempre e dà la risposta corretta, il linguaggio `L` è **decidibile**.

## ES 7
Uno stato `q` di una macchina di Turing `M` viene detto **utile** se esiste una stringa `w` tale per cui `q` viene raggiunto durante l'esecuzione di `M` quando `w` si trova in ingresso.

1.  È **decidibile** stabilire, data una macchina di Turing `M` e un suo stato `q`, se `q` sia utile?
2.  È **semidecidibile** il problema di cui sopra?

---

### **Spiegazione e Analisi della Soluzione**

#### **1. Il problema è decidibile? NO, è indecidibile.**

**Motivazione (Dimostrazione per Riduzione):**
La soluzione dimostra che il problema è indecidibile usando una tecnica fondamentale chiamata **riduzione**. L'idea è questa: se potessimo risolvere il problema della "utilità di uno stato", potremmo usarlo come "strumento" per risolvere un altro problema che sappiamo già essere impossibile da risolvere. Poiché ciò è assurdo, il nostro strumento non può esistere.

1.  **Il Problema Noto e Impossibile:** Consideriamo il **Problema della Vuotezza (Emptiness Problem)** per le Macchine di Turing. Questo problema chiede: "Dato una MT `M`, il linguaggio che essa accetta, `L(M)`, è vuoto?". Questo problema è notoriamente **indecidibile**. Si può dimostrare con il Teorema di Rice, perché "avere un linguaggio vuoto" è una proprietà non banale del comportamento della macchina.

2.  **L'Ipotesi (per assurdo):** Supponiamo che esista un algoritmo `Is_State_Useful(M, q)` che decide se lo stato `q` di `M` è utile. Questo algoritmo deve terminare sempre e dare la risposta corretta.

3.  **La Riduzione (come usare il nostro strumento):** Vediamo come possiamo usare `Is_State_Useful` per costruire un algoritmo che risolva l'Emptiness Problem.
    *   Dato una MT `M`, vogliamo sapere se `L(M)` è vuoto.
    *   Prendiamo lo **stato finale (o di accettazione)** di `M`, chiamiamolo `q_accept`. Se ci sono più stati finali, ne scegliamo uno qualsiasi (o tutti).
    *   Ora usiamo il nostro ipotetico algoritmo per chiedere: `Is_State_Useful(M, q_accept)`?

4.  **Analisi del Risultato:**
    *   **Se `Is_State_Useful` risponde "Sì"**: Questo significa che lo stato di accettazione `q_accept` è utile. Per definizione, ciò implica che **esiste almeno una stringa `w`** che, data in input a `M`, porta la macchina a raggiungere lo stato `q_accept`. Raggiungere lo stato di accettazione significa che la stringa `w` viene accettata. Quindi, `L(M)` contiene almeno `w`, e pertanto **`L(M)` non è vuoto**.
    *   **Se `Is_State_Useful` risponde "No"**: Questo significa che lo stato di accettazione `q_accept` non è utile. Per definizione, ciò implica che **non esiste nessuna stringa `w`** che possa portare la macchina a raggiungere lo stato `q_accept`. Se lo stato di accettazione non è mai raggiungibile, nessuna stringa può essere accettata. Quindi, **`L(M)` è vuoto**.

5.  **La Contraddizione:**
    Abbiamo appena creato un algoritmo infallibile per decidere l'Emptiness Problem. Ma sappiamo che tale algoritmo non può esistere. La nostra unica assunzione è stata l'esistenza di `Is_State_Useful`. Poiché questa assunzione porta a una contraddizione, essa deve essere falsa.

**Conclusione:** Il problema di stabilire se uno stato è utile **non è decidibile**.

---

#### **2. Il problema è semidecidibile? SÌ.**

**Motivazione (Ricerca Esaustiva tramite Dovetailing):**
Un problema è **semidecidibile** se possiamo scrivere un algoritmo che si ferma e dice "Sì" per tutte le istanze positive (in questo caso, quando lo stato `q` è effettivamente utile). Se l'istanza è negativa (lo stato non è utile), l'algoritmo può non terminare.

La definizione di "stato utile" ha una struttura esistenziale: "**esiste** una stringa `w`...". Questo è un forte indizio per la semidecidibilità. Dobbiamo solo trovare quella `w`.

1.  **La Sfida:** Non possiamo semplicemente provare tutte le stringhe `w` una dopo l'altra (`a`, `b`, `aa`, `ab`, ...). Se proviamo una stringa `w_i` su cui la macchina `M` va in loop, la nostra ricerca si bloccherebbe per sempre, senza mai provare le stringhe successive.

2.  **La Soluzione (Dovetailing / Enumerazione Diagonale):** Dobbiamo esplorare lo spazio di ricerca infinito (tutte le stringhe e tutti i possibili tempi di esecuzione) in modo da non rimanere mai bloccati. Lo facciamo simulando tutte le computazioni "in parallelo".

**Ecco l'algoritmo di semidecisione:**

1.  **Input:** una MT `M` e uno stato `q`.
2.  Avvia un processo di ricerca che esplora tutte le coppie `(w, i)`, dove `w` è una stringa di input e `i` è un numero di passi di computazione. La ricerca procede a "ondate":
    *   **Ondata 1:** Simula `M` sulla 1ª stringa per 1 passo.
    *   **Ondata 2:** Simula `M` sulla 1ª stringa per 2 passi E sulla 2ª stringa per 1 passo.
    *   **Ondata 3:** Simula `M` sulla 1ª stringa per 3 passi, sulla 2ª per 2 passi, E sulla 3ª per 1 passo.
    *   ...e così via.

3.  **Controllo:** Dopo ogni singolo passo di ogni simulazione, controlla lo stato corrente della macchina emulata.
    *   **Se lo stato corrente è `q`**: Congratulazioni! Hai trovato una stringa `w` e un numero di passi `i` che portano la macchina allo stato `q`. Lo stato è utile. **L'algoritmo si ferma e restituisce "Sì"**.

**Analisi del Comportamento:**
*   **Se lo stato `q` è utile:** Per definizione, esiste una stringa `w` che raggiunge `q` in un certo numero di passi `k`. La nostra procedura di dovetailing è garantita per raggiungere ed eseguire prima o poi la simulazione di `M` su `w` per `k` passi. A quel punto, troverà lo stato `q` e terminerà.
*   **Se lo stato `q` non è utile:** Nessuna stringa `w` e nessun numero di passi `i` porterà mai la macchina a raggiungere `q`. La nostra procedura di ricerca non troverà mai una corrispondenza e continuerà a girare all'infinito.

Questo comportamento corrisponde esattamente alla definizione di un problema **semidecidibile**.

## Es 8
1.  È possibile determinare se una **generica** macchina di Turing universale si arresta **per ogni** ingresso?
2.  È possibile trovare, data la **terza** (secondo l'enumerazione di Gödel) macchina di Turing universale `M`, **almeno un ingresso** per cui essa non si arresta?
3.  È possibile, data la macchina di Turing universale `M` di cui sopra, dire se essa si arresta per un **generico** ingresso `n`?

---

### **Spiegazione e Analisi della Soluzione**

#### **1. Determinare se una *generica* MTU si arresta *per ogni* ingresso**

**Risposta:** Sì, è possibile determinarlo. La risposta è sempre **NO**.

**Motivazione:**
Questa domanda è sottile. Non chiede se il "Problema della Totalità" (stabilire se una *qualsiasi* MT si ferma sempre) sia decidibile. Chiede se lo è per la classe specifica delle MTU.

Il ragionamento è il seguente:
1.  **Definizione di MTU:** Una Macchina di Turing Universale `M_U` è una macchina in grado di simulare qualsiasi altra Macchina di Turing `M_i`. L'input di una MTU è tipicamente una coppia `⟨i, x⟩`, dove `i` è la codifica (l'indice) della macchina da simulare e `x` è l'input per quella macchina.
2.  **Esistenza di Macchine che non terminano:** Sappiamo che esistono Macchine di Turing che non terminano mai (ad esempio, una macchina banale che va in loop infinito, `M_loop`). Questa `M_loop` ha un suo indice, diciamo `k`.
3.  **La Simulazione:** Se diamo a una *qualsiasi* MTU `M_U` l'input `⟨k, "qualsiasi_cosa"⟩`, la `M_U` inizierà a simulare fedelmente il comportamento di `M_loop`. Poiché `M_loop` non termina mai, anche la simulazione eseguita da `M_U` **non terminerà mai**.
4.  **Conclusione:** Abbiamo appena dimostrato che per *qualsiasi* MTU, esiste almeno un input (la codifica di una macchina che va in loop) per cui essa non si arresta.
5.  **Risposta alla domanda:** La domanda era "una generica MTU si arresta per ogni ingresso?". La risposta è inequivocabilmente **NO**. Poiché la risposta è una costante ("NO") e possiamo dimostrarla logicamente, il problema è **deciso**, e quindi **decidibile**. L'algoritmo che lo decide è banale: `return "No"`.

---

#### **2. Trovare, per una *specifica* MTU `M`, *almeno un* ingresso per cui non si arresta**

**Risposta:** Sì, è possibile.

**Motivazione:**
Questa domanda è la versione "costruttiva" della precedente. Non ci chiede solo di sapere se esiste un tale input, ma se possiamo effettivamente trovarlo.

Il ragionamento è identico a quello del punto 1, ma più concreto:
1.  **Costruisci una Macchina che va in Loop:** È banale scrivere la descrizione di una Macchina di Turing che, indipendentemente dall'input, entra in un ciclo infinito. Chiamiamola `M_loop`.
2.  **Codifica `M_loop`:** Prendi la descrizione di `M_loop` e trasformala nella stringa di input che la nostra specifica MTU `M` (la terza dell'enumerazione) si aspetta per rappresentare una macchina. Chiamiamo questa stringa di codifica `n_loop`.
3.  **L'Ingresso Trovato:** La stringa `n_loop` (o, più precisamente, la coppia `⟨n_loop, "qualsiasi_input"⟩`) è l'ingresso che stavamo cercando. Quando daremo questo input a `M`, essa simulerà `M_loop` e, di conseguenza, non si arresterà.

**Conclusione:** Sì, possiamo trovare tale ingresso. Basta codificare una macchina che sappiamo non terminare.

---

#### **3. Dire se una *specifica* MTU `M` si arresta per un *generico* ingresso `n`**

**Risposta:** No, questo non è possibile. È **indecidibile**.

**Motivazione (Riduzione dal Problema dell'Arresto):**
Questa domanda è, in essenza, il **Problema dell'Arresto** sotto mentite spoglie.

1.  **Cosa significa "generico ingresso n"?** Significa che l'input `n` può essere qualsiasi cosa. In particolare, `n` può essere la codifica di una qualsiasi coppia `⟨M_y, x⟩`, dove `M_y` è una macchina di Turing arbitraria e `x` è un input arbitrario per essa.

2.  **Il Problema dell'Arresto:** Il Problema dell'Arresto (Halting Problem) chiede: "Data una generica MT `M_y` e un generico input `x`, la computazione `M_y(x)` termina?". Questo problema è il più famoso problema indecidibile.

3.  **La Riduzione:** Mostriamo che se potessimo risolvere il nostro problema (domanda 3), potremmo risolvere l'Halting Problem.
    *   **Ipotesi (per assurdo):** Supponiamo di avere un algoritmo `A(n)` che decide se la nostra MTU `M` si arresta sull'input `n`.
    *   **Come risolvere l'Halting Problem:**
        1.  Ci vengono dati una MT generica `M_y` e un input generico `x`.
        2.  Codifichiamo la coppia `⟨M_y, x⟩` nel formato di stringa che la nostra MTU `M` accetta in input. Chiamiamo questa stringa `n_codificato`.
        3.  Ora, usiamo il nostro ipotetico algoritmo `A` sull'input `n_codificato`: eseguiamo `A(n_codificato)`.
        4.  Se `A` risponde "Sì", significa che `M` si arresta su `n_codificato`. Poiché `M` sta simulando `M_y(x)`, questo significa che `M_y(x)` si arresta.
        5.  Se `A` risponde "No", significa che `M_y(x)` non si arresta.

4.  **La Contraddizione:** Abbiamo appena descritto un metodo infallibile per risolvere il Problema dell'Arresto per qualsiasi macchina e qualsiasi input, usando `A` come "subroutine". Ma sappiamo che un tale metodo non può esistere. La nostra unica assunzione era l'esistenza dell'algoritmo `A`.

**Conclusione:** L'assunzione deve essere falsa. Pertanto, il problema di decidere se una MTU si arresta su un input generico è **indecidibile**.

## Es 9

1.  Dire se è decidibile il problema di stabilire se due programmi, uno scritto in C e uno scritto in Java, calcolano la stessa funzione.
2.  Dire se è decidibile il problema di stabilire se due programmi, entrambi scritti in C, sono identici, salvo per il fatto che i nomi delle variabili usate sono diversi tra un programma e l'altro.
3.  Dire se è decidibile il problema di stabilire se, dato un programma C che fa uso di puntatori, esiste un'esecuzione in cui, ad un certo punto, due variabili puntano entrambe allo stesso indirizzo (fenomeno dell'aliasing).

---

### **1. Equivalenza Funzionale (C vs. Java)**

**Risposta:** Il problema è **indecidibile**.

**Motivazione:**
Questo è un classico problema di teoria della computabilità, riconducibile al Teorema di Rice.

1.  **Potenza dei Linguaggi:** Sia C che Java sono linguaggi di programmazione **Turing-completi**. Questo significa che possono essere usati per implementare qualsiasi algoritmo e calcolare qualsiasi funzione calcolabile. Ai fini della teoria della computabilità, sono equivalenti a una Macchina di Turing.

2.  **Proprietà Semantica:** La domanda "calcolano la stessa funzione?" non riguarda come sono scritti i programmi (la loro sintassi), ma **cosa fanno** (la loro semantica). Stiamo chiedendo se, per ogni possibile input, i due programmi producono lo stesso output oppure entrambi non terminano.

3.  **Teorema di Rice:** Il Teorema di Rice afferma che ogni proprietà **non banale** del comportamento (la funzione calcolata) di un programma è indecidibile.
    *   La nostra proprietà è "essere funzionalmente equivalente a un dato programma Java".
    *   Questa proprietà è **non banale**? Sì. Esiste almeno un programma C che la soddisfa (una traduzione del programma Java in C) e infiniti altri programmi C che non la soddisfano (ad esempio, un programma che stampa solo "Hello World").

Poiché stiamo chiedendo di una proprietà semantica e non banale di programmi scritti in linguaggi Turing-completi, il problema dell'equivalenza è **indecidibile**. È, di fatto, una versione ancora più generale del Problema dell'Arresto.

---

### **2. Identità Sintattica (salvo nomi delle variabili)**

**Risposta:** Il problema è **decidibile**.

**Motivazione:**
A differenza del punto precedente, questa domanda è puramente **sintattica**. Non ci interessa cosa fanno i programmi, ma solo come sono strutturati, ignorando i nomi specifici delle variabili. Questo problema è noto come **equivalenza-alfa** (alpha equivalence).

Esiste un algoritmo che può decidere questo problema. Ecco come funzionerebbe:

1.  **Parsing:** L'algoritmo analizza (effettua il "parsing") entrambi i codici sorgente C per costruire una rappresentazione strutturale, come un **Abstract Syntax Tree (AST)**. Questo è esattamente ciò che fa un compilatore.
2.  **Normalizzazione:** L'algoritmo attraversa entrambi gli AST e rinomina sistematicamente tutte le variabili secondo una regola fissa. Ad esempio, la prima variabile dichiarata in ogni scope diventa `var_0`, la seconda `var_1`, e così via.
3.  **Confronto:** Una volta che entrambi gli AST sono stati "normalizzati", l'algoritmo li confronta. Se gli alberi normalizzati sono identici, significa che i programmi originali erano identici a meno del nome delle variabili. Altrimenti, non lo erano.

Poiché abbiamo descritto un algoritmo che termina sempre e fornisce la risposta corretta, il problema è **decidibile**.

---

### **3. Aliasing dei Puntatori in C**

**Risposta:** Il problema è **indecidibile**.

**Motivazione:**
Questo problema, noto come **analisi dei puntatori (pointer analysis)**, è un problema fondamentale nell'analisi statica dei programmi e nella compilazione. Sebbene possa sembrare un problema di analisi del codice, è anch'esso riconducibile al Problema dell'Arresto.

La domanda è: "**esiste un'esecuzione** in cui si verifica l'aliasing?". L'aliasing si verifica quando due puntatori contengono lo stesso indirizzo di memoria.

Vediamo perché è indecidibile con una **riduzione dal Problema dell'Arresto**:

1.  **Il Problema dell'Arresto:** Sappiamo che è indecidibile stabilire se un generico programma `P` con un generico input `I` terminerà la sua esecuzione.

2.  **La Riduzione:** Costruiamo un nuovo programma C, `P_alias`, in questo modo:

    ```c
    #include <stdio.h>

    void P_alias() {
        int a, b;
        int *ptr1 = &a; // ptr1 punta ad a
        int *ptr2 = &b; // ptr2 punta a b

        // Inizialmente, ptr1 e ptr2 NON sono alias.

        // Inseriamo qui il codice del programma P con l'input I
        // di cui vogliamo testare la terminazione.
        // Esempio:
        // while(1) { ... } // se P(I) non termina
        
        // Questa riga viene raggiunta SE E SOLO SE l'esecuzione di P(I) termina.
        ptr2 = &a; 

        // Ora ptr1 e ptr2 sono alias (puntano entrambi ad a).
    }
    ```

3.  **L'Equivalenza:**
    *   L'aliasing tra `ptr1` e `ptr2` si verifica in `P_alias` **se e solo se** la riga `ptr2 = &a;` viene mai eseguita.
    *   Questa riga viene eseguita **se e solo se** il programma `P` con l'input `I` termina.

4.  **La Contraddizione:** Se avessimo un algoritmo `Decide_Aliasing(programma)` in grado di decidere se in un programma si verifica l'aliasing, potremmo usarlo per risolvere il Problema dell'Arresto:
    *   Per sapere se `P(I)` termina, basterebbe costruire `P_alias` e darlo in pasto a `Decide_Aliasing`.
    *   Se `Decide_Aliasing(P_alias)` risponde "Sì", allora `P(I)` termina.
    *   Se risponde "No", allora `P(I)` non termina.

Poiché abbiamo ridotto il Problema dell'Arresto all'analisi dell'aliasing, e il primo è indecidibile, anche il secondo deve essere **indecidibile**.
## Es 10

1.  Siano dati due automi a pila deterministici con linguaggi `L1` e `L2`: è **ricorsivo** (decidibile) il linguaggio `L1 ∩ L2`?
2.  Siano dati due automi a pila deterministici con linguaggi `L1` e `L2` e una macchina di Turing `M`: è **decidibile** se `M` calcola `L1 ∩ L2`?

---

### **1. Il linguaggio `L1 ∩ L2` è ricorsivo (decidibile)?**

**Risposta:** Sì, il linguaggio `L1 ∩ L2` è ricorsivo (decidibile).

**Motivazione dettagliata:**

Un linguaggio `L` è detto ricorsivo (o decidibile) se esiste un algoritmo (implementabile da una Macchina di Turing) che, per qualsiasi stringa di input `w`, **termina sempre** e risponde correttamente "sì" (se `w ∈ L`) o "no" (se `w ∉ L`).

La domanda, quindi, è: possiamo costruire un tale algoritmo per il linguaggio `L1 ∩ L2`?

1.  **Definizione di Intersezione:** Una stringa `w` appartiene a `L1 ∩ L2` se e solo se `w` appartiene a `L1` **E** `w` appartiene a `L2`.

2.  **Costruzione dell'Algoritmo (una Macchina di Turing `M_inter`):**
    Il nostro algoritmo `M_inter` prenderà in input una stringa `w` e la descrizione dei due automi a pila deterministici (`APD₁` e `APD₂`).
    *   **Passo 1: Simula `APD₁` su `w`.**
        *   La proprietà fondamentale di un **automa a pila deterministico (APD)** è che la sua computazione su un qualsiasi input finito è garantita per **terminare** in un tempo finito. Non può entrare in un loop infinito.
        *   Quindi, la simulazione di `APD₁` su `w` si fermerà e darà una risposta chiara: "accetta" o "rifiuta".
    *   **Passo 2: Analizza il risultato del Passo 1.**
        *   Se `APD₁` **rifiuta** `w`, allora `w` non è in `L1`, e quindi non può essere nell'intersezione. Il nostro algoritmo `M_inter` si ferma e risponde **"no"**.
    *   **Passo 3: Simula `APD₂` su `w`.**
        *   Se `APD₁` ha accettato `w`, procediamo a simulare `APD₂` sulla stessa stringa `w`.
        *   Anche questa simulazione è garantita per **terminare**.
    *   **Passo 4: Analizza il risultato del Passo 3.**
        *   Se `APD₂` **accetta** `w`, significa che sia `APD₁` che `APD₂` hanno accettato. Pertanto, `w` è nell'intersezione. Il nostro algoritmo `M_inter` si ferma e risponde **"sì"**.
        *   Se `APD₂` **rifiuta** `w`, allora `w` non è nell'intersezione. Il nostro algoritmo `M_inter` si ferma e risponde **"no"**.

3.  **Conclusione:** Abbiamo appena descritto un algoritmo che, per qualsiasi stringa `w`, termina sempre e risponde correttamente. Pertanto, il linguaggio `L1 ∩ L2` è **decidibile**.

*(Nota: Questo non significa che `L1 ∩ L2` sia necessariamente un linguaggio riconoscibile da un APD. Significa solo che è riconoscibile da una Macchina di Turing che si ferma sempre).*

---

### **2. È decidibile se una generica MT `M` calcola `L1 ∩ L2`?**

**Risposta:** No, questo problema è **indecidibile**.

**Motivazione dettagliata (Teorema di Rice):**

Questa domanda è profondamente diversa dalla precedente. Non stiamo più chiedendo se una *stringa* appartiene a un linguaggio, ma se un *programma generico* (`M`) è funzionalmente equivalente a una specifica data (`L1 ∩ L2`). Questo è un problema di **verifica della correttezza del software**, che nel caso generale è impossibile da risolvere.

1.  **Il Problema in Questione:** Vogliamo decidere se il linguaggio accettato da `M`, `L(M)`, è uguale al linguaggio `L1 ∩ L2`.

2.  **Teorema di Rice:** Questo teorema fondamentale della teoria della computabilità afferma che **qualsiasi proprietà non banale del comportamento (cioè, del linguaggio riconosciuto) di una Macchina di Turing è indecidibile.**
    *   Una proprietà è **del comportamento (semantica)** se non dipende da come è scritto il programma (es. numero di stati), ma solo da ciò che fa (le stringhe che accetta). La nostra è chiaramente una proprietà del comportamento.
    *   Una proprietà è **non banale** se esiste almeno una Macchina di Turing che la possiede e almeno una che non la possiede.

3.  **Applichiamo il Teorema di Rice al nostro caso:**
    *   **La proprietà `P`** che stiamo testando su `M` è: "`M` accetta il linguaggio `L1 ∩ L2`".
    *   **`P` è non banale?**
        *   **Esiste almeno una MT che ha la proprietà `P`?** Sì. Nel punto 1, abbiamo descritto come costruire una MT (`M_inter`) che decide `L1 ∩ L2`. Quella macchina ha la proprietà `P`.
        *   **Esiste almeno una MT che NON ha la proprietà `P`?** Sì, certamente. Una macchina di Turing che accetta il linguaggio vuoto, o che accetta tutte le stringhe, non ha la proprietà `P` (a meno che `L1 ∩ L2` non sia uno di questi casi, ma possiamo sempre trovare un controesempio).

4.  **Conclusione:** Poiché "accettare il linguaggio `L1 ∩ L2`" è una proprietà non banale del comportamento di una Macchina di Turing, per il Teorema di Rice, il problema di stabilire se una generica macchina `M` possiede questa proprietà è **indecidibile**.

## ES 11
Nel corso di Prova Finale di API si richiede di sviluppare in C una funzione `f` da ℕ a ℕ. Un generatore di test, fornito agli studenti, enumera gli input per `f` e i corrispondenti output attesi.

a) È **decidibile** il problema di stabilire se la codifica di `f` fatta da un generico studente è corretta rispetto ad **ogni possibile** caso di test fornito dal generatore?
b) Ada e Pasquale si sono consultati prima di scrivere le proprie implementazioni. È **decidibile** il problema di stabilire se le loro codifiche di `f` sono equivalenti?
c) È **semidecidibile** il problema del punto a)?

---

### **a) Decidibilità della Correttezza rispetto al Generatore**

**Risposta:** No, il problema **non è decidibile**.

**Motivazione (Teorema di Rice):**

1.  **Cosa significa "corretta"?** Un'implementazione `f_studente` è "corretta" se per **ogni** input `x` enumerato dal generatore di test, l'output `f_studente(x)` è uguale all'output atteso `f_atteso(x)`.
2.  **Il Dominio del Problema:** Il generatore "enumera" gli input, il che implica che l'insieme dei casi di test è **infinito**. Dobbiamo quindi verificare la correttezza su un numero infinito di casi.
3.  **Applichiamo il Teorema di Rice:** Il problema di verificare se un programma `P` è corretto rispetto a una specifica `S` (in questo caso, l'insieme infinito di test) è un problema di **verifica della correttezza del software**.
    *   **La Proprietà:** La proprietà che stiamo verificando è "essere funzionalmente equivalente alla funzione attesa `f_atteso` su tutti gli input generati".
    *   **È una proprietà semantica?** Sì, riguarda *cosa* fa il programma (il suo comportamento), non come è scritto.
    *   **È una proprietà non banale?** Sì.
        *   Esiste almeno un'implementazione corretta (si spera!).
        *   Esiste almeno un'implementazione non corretta (ad esempio, una che restituisce sempre 0).
4.  **Conclusione:** Poiché stiamo verificando una proprietà semantica e non banale di un programma generico, per il Teorema di Rice il problema è **indecidibile**. Non esiste un algoritmo universale che possa prendere il codice di uno studente e garantire che funzioni correttamente su tutti gli infiniti test.

---

### **b) Decidibilità dell'Equivalenza tra Ada e Pasquale**

**Risposta:** Sì, il problema è **decidibile**.

**Motivazione ("Domanda Chiusa"):**

Questa domanda è molto diversa dalla precedente e spesso trae in inganno.

1.  **Cosa chiede il problema?** Non ci viene dato il codice di due studenti *generici* come input. Ci viene chiesto di rispondere a una domanda su **due implementazioni specifiche e fisse**: quella di Ada e quella di Pasquale.
2.  **L'argomento della "Domanda Chiusa":** Le implementazioni di Ada e Pasquale o sono equivalenti, o non lo sono. La risposta a questa domanda è una singola costante booleana: o è "Vero" o è "Falso". Non dipende da alcun input esterno.
3.  **Esistenza dell'Algoritmo:** Poiché la risposta è una costante, un algoritmo che decide il problema esiste sempre:
    *   **Se la risposta vera è "Sì"**, allora l'algoritmo `Algoritmo_Ada_Pasquale() { return "Sì"; }` è un algoritmo che termina sempre e fornisce la risposta corretta.
    *   **Se la risposta vera è "No"**, allora l'algoritmo `Algoritmo_Ada_Pasquale() { return "No"; }` è un algoritmo corretto.
4.  **Conclusione:** Poiché un algoritmo decisore esiste (anche se non siamo in grado di scrivere quale dei due sia quello giusto senza risolvere il problema di equivalenza per questo caso specifico), il problema è, per definizione, **decidibile**.

*(Nota: Questo è diverso dal problema generale "Dati due programmi P1 e P2, sono equivalenti?", che è indecidibile. Qui i programmi non sono input, sono costanti del problema).*

---

### **c) Semidecidibilità della Correttezza**

**Risposta:** No, il problema **non è semidecidibile**.

**Motivazione (Uso del Complemento):**

1.  **Cosa significa Semidecidibile?** Un problema è semidecidibile se esiste un algoritmo che termina e dice "Sì" per tutte le istanze positive. Nel nostro caso, dovrebbe esistere un algoritmo che, dato un programma corretto, si ferma e lo certifica come tale.

2.  **Analizziamo il Problema Inverso (il Complemento):**
    *   Il problema originale (P) è: "L'implementazione è corretta?" (cioè, non ha discrepanze).
    *   Il problema complemento (P̄) è: "L'implementazione **non** è corretta?" (cioè, esiste **almeno una discrepanza**).

3.  **Il Complemento È Semidecidibile? SÌ.**
    Possiamo costruire un "cercatore di bug" che semidecide il problema P̄. Ecco come funziona:
    *   Prendi il programma dello studente.
    *   Inizia a enumerare i casi di test dal generatore, uno per uno.
    *   Per ogni caso di test `(input_i, output_atteso_i)`:
        *   Esegui il programma dello studente con `input_i` per ottenere `output_studente_i`.
        *   Confronta `output_studente_i` con `output_atteso_i`.
        *   **Se sono diversi**, hai trovato un bug! L'implementazione non è corretta. L'algoritmo si ferma e risponde "Sì, ho trovato una discrepanza".
    *   **Comportamento:** Se il programma ha un bug, questo algoritmo prima o poi lo troverà e terminerà. Se il programma è perfettamente corretto, l'algoritmo continuerà a testare all'infinito, senza mai fermarsi. Questo è esattamente il comportamento di un semi-decisore per il problema P̄.

4.  **Torniamo al Problema Originale:**
    *   Abbiamo stabilito che P ("è corretto?") è **indecidibile** (punto a).
    *   Abbiamo stabilito che il suo complemento P̄ ("non è corretto?") è **semidecidibile**.
    *   Un teorema fondamentale della computabilità dice: *Un problema è decidibile se e solo se sia esso che il suo complemento sono semidecidibili.*
    *   Poiché P è indecidibile, ma il suo complemento P̄ è semidecidibile, ne consegue che P **non può essere semidecidibile**.

**Conclusione:** Il problema della correttezza non solo è indecidibile, ma non è nemmeno semidecidibile. Possiamo trovare i bug, ma non possiamo mai certificare l'assenza totale di bug.
## ES12 
1.  È **decidibile** il problema di stabilire se, data una MT deterministica e una sequenza di suoi stati `s₁, s₂, ..., sₖ`, esiste una stringa `x` in ingresso tale che la MT attraversa **esattamente**, uno per uno, la sequenza di stati desiderata durante il riconoscimento di `x`?
2.  È **semidecidibile** il problema del punto 1?
3.  È **decidibile** il problema di stabilire se, data una MT deterministica e una sequenza di suoi stati `s₁, s₂, ..., sₖ`, esiste una stringa `x` in input tale che la MT, durante il riconoscimento di `x`, attraversa gli stati desiderati nell'ordine desiderato, ma potrebbe, tra uno stato desiderato e il successivo della sequenza, attraversarne anche altri (cioè, la sequenza `s₁, s₂, ..., sₖ` è una **sottosequenza** della computazione)?

---

### **1. Il problema del percorso "esatto" è decidibile? SÌ.**

**Motivazione dettagliata:**
La chiave qui è la parola **"esattamente"**. Questo vincolo è così stringente che ci permette di costruire la stringa di input `x`, se esiste.

**Costruzione dell'Algoritmo di Decisione:**
L'algoritmo non ha bisogno di cercare tra infinite stringhe `x`. Può invece lavorare "all'indietro" dalla sequenza di stati per vedere se una tale computazione è possibile.

1.  **Input:** Una MT deterministica `M` e una sequenza di stati `S = (s₁, s₂, ..., sₖ)`.
2.  **Analisi del Percorso:** L'algoritmo analizza la sequenza di transizioni passo dopo passo.
    *   **Passo i=1 (da `s₁` a `s₂`):** Controlla le regole di transizione di `M`. Esiste una transizione che parte dallo stato `s₁` e arriva allo stato `s₂`?
        *   **Se no**, allora non esiste nessuna computazione che possa fare questo passo. L'algoritmo si ferma e risponde **"No"**.
        *   **Se sì**, significa che per compiere questa transizione la testina deve leggere un certo simbolo `σ₁` e scrivere un simbolo `τ₁`. L'algoritmo "annota" che il primo carattere dell'ipotetica stringa `x` deve essere `σ₁`.
    *   **Passo i=2 (da `s₂` a `s₃`):** Ripeti il processo. Cerca una transizione da `s₂` a `s₃`. Se esiste, annota il simbolo `σ₂` che la testina deve leggere in questa fase.
    *   ...e così via per tutti i `k-1` passi.
3.  **Ricostruzione della Stringa:** Se l'algoritmo completa l'analisi di tutti i `k-1` passi senza trovare un'impossibilità, avrà costruito l'**unica possibile** stringa di input `x = σ₁σ₂...σₖ₋₁` che può forzare la macchina a seguire *esattamente* quel percorso di stati.
4.  **Verifica Finale:** L'algoritmo ora esegue una simulazione della MT `M` con la stringa `x` appena costruita. Se la simulazione segue effettivamente il percorso `s₁, s₂, ..., sₖ`, l'algoritmo risponde **"Sì"**. Altrimenti, risponde **"No"**. (Questa verifica è quasi superflua se l'analisi delle transizioni è fatta correttamente, ma completa la logica).

**Conclusione:** Abbiamo descritto un algoritmo che, dato un percorso di lunghezza finita `k`, esegue un numero finito di controlli e simulazioni. Questo algoritmo **termina sempre** e fornisce la risposta corretta. Pertanto, il problema è **decidibile**.

---

### **2. Il problema del percorso "esatto" è semidecidibile? SÌ.**

**Motivazione:**
Un teorema fondamentale afferma che ogni problema decidibile è anche semidecidibile. Poiché abbiamo dimostrato che il problema è decidibile, ne consegue direttamente che è anche semidecidibile.

---

### **3. Il problema del percorso "in sottosequenza" è decidibile? NO.**

**Motivazione (Riduzione dal Problema dell'Arresto):**
La flessibilità introdotta dalla parola "sottosequenza" ("potrebbe... attraversarne anche altri") distrugge la decidibilità, perché ora non possiamo più ricostruire la stringa `x` in modo deterministico. Il numero di passi tra `sᵢ` e `sᵢ₊₁` è sconosciuto e potenzialmente infinito.

Dimostriamo che il problema è **indecidibile** riducendolo al Problema della Terminazione (una variante del Problema dell'Arresto).

1.  **Il Problema Indecidibile Noto:** È indecidibile stabilire se una generica MT `M` termina (cioè raggiunge uno stato finale) per almeno un input `x`. Questo è il **Problema della Terminazione non-vuota**. Si può dimostrare con il Teorema di Rice (la proprietà "avere un linguaggio non-vuoto" è non banale).

2.  **L'Ipotesi (per assurdo):** Supponiamo di avere un algoritmo `Decide_Sottosequenza(M, S)` che decide il problema del punto 3.

3.  **La Riduzione:** Vediamo come usare `Decide_Sottosequenza` per risolvere il Problema della Terminazione non-vuota.
    *   Ci viene data una generica MT `M'`. Vogliamo sapere se `L(M')` è non-vuoto.
    *   Scegliamo una sequenza di stati `S` molto semplice: `S = (q₀, q_accept)`, dove `q₀` è lo stato iniziale di `M'` e `q_accept` è uno dei suoi stati finali.
    *   Ora usiamo il nostro ipotetico algoritmo: eseguiamo `Decide_Sottosequenza(M', (q₀, q_accept))`.

4.  **Analisi del Risultato:**
    *   **Se `Decide_Sottosequenza` risponde "Sì"**: Questo significa che esiste una stringa `x` tale che l'esecuzione di `M'(x)` inizia in `q₀` e, ad un certo punto, raggiunge `q_accept`. Raggiungere uno stato di accettazione significa che `x` viene accettata. Quindi, `L(M')` contiene almeno `x` e **non è vuoto**.
    *   **Se `Decide_Sottosequenza` risponde "No"**: Questo significa che non esiste nessuna stringa `x` che possa portare la macchina dallo stato iniziale a quello finale. Quindi, nessuna stringa viene accettata e `L(M')` **è vuoto**.

5.  **La Contraddizione:** Abbiamo appena creato un algoritmo infallibile per decidere il Problema della Terminazione non-vuota. Ma sappiamo che tale algoritmo non può esistere. La nostra unica assunzione è stata l'esistenza di `Decide_Sottosequenza`.

**Conclusione:** L'assunzione deve essere falsa. Pertanto, il problema di stabilire se una sequenza di stati appare come sottosequenza in una computazione è **indecidibile**.
# MODELLO A POTENZA MINIMA

## Es1

**Esercizio 1 (8 punti)**

Si consideri il linguaggio L = {x.y | x, y ∈ {0,1}⁺, |x| = |y| oppure 2|x| = |y|}.
Si definisca un modello formale a potenza minima che accetti L.

*(Nota: {0,1}⁺ indica l'insieme delle stringhe non vuote sull'alfabeto {0,1})*



### Spiegazione e Svolgimento Passo Passo

#### Passo 1: Analizzare la definizione del linguaggio L

Il linguaggio `L` è composto da stringhe `w` che sono la concatenazione di due sotto-stringhe non vuote, `x` e `y`. La condizione per l'appartenenza a `L` riguarda le lunghezze di `x` e `y`. Analizziamo i due casi possibili per una stringa `w = x.y`.

*   **Caso 1: `|x| = |y|`**
    La lunghezza totale della stringa `w` è `|w| = |x| + |y|`.
    Sostituendo la condizione, otteniamo `|w| = |x| + |x| = 2|x|`.
    Poiché `x ∈ {0,1}⁺`, la sua lunghezza `|x|` deve essere almeno 1 (`|x| ≥ 1`).
    Di conseguenza, la lunghezza totale `|w|` può essere 2, 4, 6, 8, ...
    In altre parole, in questo caso `|w|` è un **numero pari maggiore o uguale a 2**.

*   **Caso 2: `2|x| = |y|`**
    La lunghezza totale della stringa `w` è sempre `|w| = |x| + |y|`.
    Sostituendo la condizione, otteniamo `|w| = |x| + 2|x| = 3|x|`.
    Anche qui, `|x| ≥ 1`, quindi la lunghezza totale `|w|` può essere 3, 6, 9, 12, ...
    In altre parole, in questo caso `|w|` è un **multiplo di 3 maggiore o uguale a 3**.

**Conclusione sull'analisi:**
Il linguaggio `L` è l'unione dei due casi. Quindi, `L` contiene tutte le stringhe `w` dell'alfabeto {0,1}⁺ la cui lunghezza `|w|` è **o un numero pari, o un multiplo di 3**.
Questa è esattamente la semplificazione indicata nella soluzione:
`L = {w ∈ {0,1}⁺ | |w| mod 2 = 0 oppure |w| mod 3 = 0}`.

#### Passo 2: Determinare la potenza minima del modello formale

Ora che abbiamo capito la vera natura di `L`, dobbiamo classificarlo.

*   La condizione di appartenenza di una stringa a `L` dipende **esclusivamente dalla sua lunghezza**. Non ci sono vincoli sulla struttura interna della stringa (ad esempio, che inizi con uno 0 o che il numero di 0 sia uguale al numero di 1).
*   I linguaggi la cui appartenenza è determinata da una proprietà aritmetica sulla lunghezza (come la parità o la divisibilità) sono sempre **regolari**.
*   Possiamo immaginare di costruire un Automa a Stati Finiti (FSA) per riconoscerlo. Un automa può facilmente "contare" la lunghezza modulo un certo numero. Per verificare se la lunghezza è divisibile per 2 o per 3, è sufficiente contare la lunghezza modulo 6 (il minimo comune multiplo). Un automa con 6 stati può tenere traccia di `|w| mod 6` e accettare se si trova in uno stato corrispondente a una lunghezza che sia pari o multiplo di 3.

Poiché `L` è un linguaggio regolare, il modello formale a potenza minima che lo accetta è un **Automa a Stati Finiti** o, equivalentemente, una **Grammatica Regolare (Tipo 3)**.

#### Passo 3: Analizzare la Grammatica Regolare fornita

La soluzione fornisce la seguente grammatica regolare. Vediamo come funziona.

$S \to 0A \mid 1A \mid 0A' \mid 1A'$
$A' \to 0 \mid 1 \mid 0B' \mid 1B'$
$B' \to 0A' \mid 1A'$
$A \to 0B \mid 1B$
$B \to 0 \mid 1 \mid 0C \mid 1C$
$C \to 0A \mid 1A$

La regola di partenza `S` compie una scelta non deterministica: può iniziare una derivazione usando le variabili con l'apice (`A'`) oppure quelle senza (`A`). Analizziamo i due percorsi separatamente.

**Percorso 1: La "sub-grammatica" per le lunghezze pari (con apice)**

*   Le regole sono: `S → (0|1)A'`, `A' → (0|1)` o `A' → (0|1)B'`, `B' → (0|1)A'`.
*   **Derivazione più corta:** `S → 0A' → 01`. La lunghezza è **2**.
*   **Analisi del ciclo:** Notiamo il ciclo `A' → ...B' → ...A'`. Per passare da `A'` e tornare ad `A'`, si generano due simboli (`A' → 0B'`, `B' → 0A'`). Questo ciclo aggiunge sempre 2 simboli alla stringa.
*   Le derivazioni terminano con la regola `A' → (0|1)`.
*   Vediamo le lunghezze generate:
    *   `S → A' → terminale`: lunghezza 2.
    *   `S → A' → B' → A' → terminale`: lunghezza 4.
    *   `S → A' → B' → A' → B' → A' → terminale`: lunghezza 6.
*   Questa parte della grammatica genera tutte e sole le stringhe di **lunghezza pari (≥ 2)**.

**Percorso 2: La "sub-grammatica" per i multipli di 3 (senza apice)**

*   Le regole sono: `S → (0|1)A`, `A → (0|1)B`, `B → (0|1)` o `B → (0|1)C`, `C → (0|1)A`.
*   **Derivazione più corta:** `S → 0A → 01B → 010`. La lunghezza è **3**.
*   **Analisi del ciclo:** Notiamo il ciclo `A → ...B → ...C → ...A`. Per passare da `A` e tornare ad `A'`, si generano tre simboli (`A → 0B`, `B → 0C`, `C → 0A`). Questo ciclo aggiunge sempre 3 simboli alla stringa.
*   Le derivazioni terminano con la regola `B → (0|1)`.
*   Vediamo le lunghezze generate:
    *   `S → A → B → terminale`: lunghezza 3.
    *   `S → A → B → C → A → B → terminale`: lunghezza 6.
    *   `S → A → B → C → A → B → C → A → B → terminale`: lunghezza 9.
*   Questa parte della grammatica genera tutte e sole le stringhe la cui **lunghezza è un multiplo di 3 (≥ 3)**.

**Conclusione Finale:**
La grammatica, tramite la scelta non deterministica iniziale, genera l'unione dei due linguaggi: quello delle stringhe di lunghezza pari e quello delle stringhe di lunghezza multipla di 3. Pertanto, genera correttamente il linguaggio `L`.

## Es 2

### 1. Analisi del Linguaggio e Classificazione

Il linguaggio `L` è definito come l'unione di tre linguaggi separati:
*   `L1 = {aⁿ(bc)ⁿ | n ≥ 2}`
*   `L2 = {bⁿ(ca)ⁿ | n ≥ 1}`
*   `L3 = (abc)⁺`

Per classificare `L`, dobbiamo prima classificare ciascuno dei suoi componenti e poi considerare le proprietà di chiusura della classe di linguaggi risultante.

#### Analisi dei Sotto-Linguaggi

*   **L1 = {aⁿ(bc)ⁿ | n ≥ 2}**:
    Questo linguaggio richiede di "contare" il numero di `a` iniziali e assicurarsi che corrisponda esattamente al numero di blocchi `bc` successivi. Ad esempio, `aabcbc` (n=2) e `aaabcbcbc` (n=3) sono in L1. Un automa a stati finiti (FSA) non può riconoscere questo linguaggio perché ha una memoria finita e non può tenere traccia di un conteggio `n` arbitrariamente grande. Tuttavia, un **automa a pila (PDA)** può riconoscerlo (spingendo un simbolo sulla pila per ogni `a` e estraendone uno per ogni blocco `bc`). Pertanto, **L1 è un linguaggio libero dal contesto (Context-Free) ma non regolare**.

*   **L2 = {bⁿ(ca)ⁿ | n ≥ 1}**:
    Il ragionamento è identico a quello per L1. Anche qui è necessario un conteggio che va oltre le capacità di un FSA. Ad esempio, `bca` (n=1) e `bbcaca` (n=2) sono in L2. Anche questo linguaggio è **libero dal contesto (Context-Free) ma non regolare**.

*   **L3 = (abc)⁺**:
    Questo linguaggio è descritto da un'**espressione regolare**. Tutti i linguaggi che possono essere descritti da un'espressione regolare sono, per definizione, **regolari**. Un semplice FSA a 3 stati può riconoscerlo. Poiché tutti i linguaggi regolari sono anche liberi dal contesto, L3 è sia regolare che context-free.

#### Classificazione del Linguaggio L

Il linguaggio `L` è l'unione di L1, L2 e L3. Le classi di linguaggi hanno le seguenti proprietà di chiusura:
*   I linguaggi regolari sono chiusi rispetto all'unione.
*   I linguaggi liberi dal contesto sono chiusi rispetto all'unione.

Poiché `L` è l'unione di due linguaggi context-free (L1, L2) e un linguaggio regolare (L3, che è anche context-free), il linguaggio risultante `L` è garantito essere **libero dal contesto (Context-Free)**.

**L non è regolare**. Possiamo dimostrarlo facilmente. Se `L` fosse regolare, allora la sua intersezione con un altro linguaggio regolare dovrebbe essere anch'essa regolare. Consideriamo l'intersezione di `L` con il linguaggio regolare `a*(bc)*`:
`L ∩ a*(bc)* = L1`
Abbiamo già stabilito che L1 non è regolare. Poiché l'intersezione ha prodotto un linguaggio non regolare, il linguaggio originale `L` non può essere regolare.

**Motivazione e Conclusione:**
Il linguaggio L appartiene alla classe dei **linguaggi liberi dal contesto (Context-Free Languages)**. Questo perché è l'unione di tre linguaggi (L1, L2, L3) che sono tutti context-free, e questa classe è chiusa rispetto all'unione. Tuttavia, poiché almeno uno dei suoi componenti (L1) non è regolare, L non è un linguaggio regolare.

---

### 2. Costruzione dell'Automa a Potenza Minima

Poiché `L` è un linguaggio libero dal contesto ma non regolare, il modello formale a potenza minima in grado di riconoscerlo è un **Automa a Pila non deterministico (NPDA)**.

La strategia di costruzione si basa sul non determinismo:
1.  Dallo stato iniziale, l'automa "indovina" non deterministicamente a quale dei tre sotto-linguaggi (L1, L2 o L3) la stringa di input potrebbe appartenere.
2.  Transita quindi in una "sezione" dell'automa dedicata a riconoscere specificamente quel sotto-linguaggio.

Di seguito è riportato il diagramma di un NPDA che riconosce `L`. `Z₀` è il simbolo iniziale della pila.


### **Guida al Disegno dell'Automa a Pila**

#### **Elementi di Base**

1.  **Stati:** Disegna 12 cerchi. Etichettali da `q₀` a `q₁₁`.
2.  **Stato Iniziale:** Disegna una freccia che punta verso `q₀` senza partire da nessun altro stato.
3.  **Stati Finali:** Disegna un secondo cerchio concentrico attorno a `q₉` e `q_f`. Questi sono gli stati di accettazione.
4.  **Simbolo Iniziale Pila:** Assumiamo che all'inizio la pila contenga solo il simbolo `Z₀`.

---

### **Disegno delle Transizioni (Frecce e Loro Etichette)**

#### **PARTE 1: La Scelta Non Deterministica Iniziale**

Dal tuo stato iniziale `q₀`, devi "indovinare" quale tipo di stringa stai per leggere. Questo si fa con transizioni `ε` (che non consumano input).

*   **Freccia da `q₀` a `q₁` (Percorso per L1):**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Senza leggere nulla dall'input, se in cima alla pila c'è `Z₀`, lascialo lì e passa allo stato `q₁` per provare a riconoscere una stringa di tipo `aⁿ(bc)ⁿ`."

*   **Freccia da `q₀` a `q₅` (Percorso per L2):**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Scegli il percorso per riconoscere una stringa di tipo `bⁿ(ca)ⁿ`."

*   **Freccia da `q₀` a `q₇` (Percorso per L3):**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Scegli il percorso per riconoscere una stringa di tipo `(abc)⁺`."

---

#### **PARTE 2: Disegno del Percorso per L1 = {aⁿ(bc)ⁿ | n ≥ 2}**

Questo percorso deve contare almeno due `a` e poi abbinarle a coppie `bc`.

*   **Freccia da `q₁` a `q₂`:**
    *   **Etichetta:** `a, Z₀ / AZ₀`
    *   **Significato:** "Leggi la prima `a`. Estrai `Z₀` e spingi `A` (il nostro contatore) e poi `Z₀`."

*   **Freccia da `q₂` a `q₃`:**
    *   **Etichetta:** `a, A / AA`
    *   **Significato:** "Leggi la seconda `a`. Estrai un `A` e spingi due `A`. Ora la condizione `n≥2` è soddisfatta."

*   **Freccia da `q₃` che torna su se stesso (loop):**
    *   **Etichetta:** `a, A / AA`
    *   **Significato:** "Per ogni `a` successiva, continua a spingere contatori `A` sulla pila."

*   **Freccia da `q₃` a `q₄`:**
    *   **Etichetta:** `b, A / ε`
    *   **Significato:** "Inizia la fase di confronto. Leggi una `b` ed estrai (pop) un contatore `A` dalla pila."

*   **Freccia da `q₄` a `q₃`:**
    *   **Etichetta:** `c, X / X` (shorthand per `c, A/A` e `c, Z₀/Z₀`)
    *   **Significato:** "Leggi la `c` corrispondente alla `b` precedente. Lascia la pila com'è. Torna in `q₃` per cercare la prossima coppia `bc`."
    *   *Nota: Ho usato `X/X` per semplicità, significa "non modificare la pila". Nello standard rigoroso, dovresti disegnare due frecce separate: una con `c, A / A` e una con `c, Z₀ / Z₀`.*

*   **Freccia da `q₃` allo stato finale `q_f`:**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Se l'input è finito e in cima alla pila c'è solo `Z₀` (tutti gli `A` sono stati consumati), allora la stringa è valida. Accetta."

---

#### **PARTE 3: Disegno del Percorso per L2 = {bⁿ(ca)ⁿ | n ≥ 1}**

La logica è simmetrica a quella di L1.

*   **Freccia da `q₅` che torna su se stesso (loop):**
    *   **Etichetta:** Metti due etichette su questa freccia:
        1.  `b, Z₀ / BZ₀` (per la prima `b`, `n=1`)
        2.  `b, B / BB` (per le `b` successive)
    *   **Significato:** "Leggi una o più `b` e spingi un contatore `B` per ciascuna."

*   **Freccia da `q₅` a `q₆`:**
    *   **Etichetta:** `c, B / ε`
    *   **Significato:** "Leggi una `c` ed estrai (pop) un contatore `B` dalla pila."

*   **Freccia da `q₆` a `q₅`:**
    *   **Etichetta:** `a, X / X`
    *   **Significato:** "Leggi la `a` corrispondente alla `c`. Lascia la pila com'è. Torna in `q₅` per cercare la prossima coppia `ca`."

*   **Freccia da `q₅` allo stato finale `q_f`:**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Se l'input è finito e la pila è vuota, la stringa è valida. Accetta."

---

#### **PARTE 4: Disegno del Percorso per L3 = (abc)⁺**

Questo percorso è regolare, quindi la pila non viene usata attivamente.

*   **Freccia da `q₇` a `q₈`:**
    *   **Etichetta:** `a, X / X`
    *   **Significato:** "Leggi una `a`, non toccare la pila."

*   **Freccia da `q₈` a `q₉`:**
    *   **Etichetta:** `b, X / X`
    *   **Significato:** "Leggi una `b`, non toccare la pila."

*   **Freccia da `q₉` a `q₇`:**
    *   **Etichetta:** `c, X / X`
    *   **Significato:** "Leggi una `c`, non toccare la pila, e torna all'inizio del ciclo per cercare un altro `abc`."

Ricorda di disegnare `q₉` come **stato finale**, perché dopo ogni `abc` completo la stringa è valida.

## Es 3

### **Passo 1: Analisi e Classificazione del Linguaggio**

*   **Linguaggio:** `L = {aˣbʸcᶻb*aʷ | x+2y = z+w; x,y,z,w > 0}`
*   **Struttura:** Una sequenza di `a`, seguita da una di `b`, poi `c`, poi un blocco opzionale di `b`, e infine un'altra sequenza di `a`.
*   **Vincolo Aritmetico:** `x + 2y = z + w`. Questo è un vincolo di conteggio.
*   **Vincoli di Esistenza:** `x, y, z, w > 0` significa che ogni blocco di lettere (`aˣ`, `bʸ`, `cᶻ`, `aʷ`) deve essere presente e contenere almeno un carattere. Il blocco `b*` nel mezzo può essere vuoto.

**Classificazione:**
Il linguaggio non è regolare perché richiede una memoria illimitata per verificare il vincolo `x+2y = z+w`. Un automa a stati finiti non può farlo.
Il linguaggio è **Libero dal Contesto (Context-Free)** perché il vincolo può essere gestito con una singola pila. La strategia è:
1.  **Leggere `aˣbʸ`**: Usare la pila per "sommare" il lato sinistro dell'equazione (`x + 2y`).
2.  **Leggere `cᶻb*aʷ`**: Usare la pila per "sottrarre" il lato destro (`z + w`).
3.  **Accettare se il risultato è zero (pila vuota)**.

Il modello a potenza minima è quindi un **Automa a Pila (Pushdown Automaton)**.

---

### **Passo 2: Guida Dettagliata al Disegno dell'Automa**

Ecco come disegnare il grafo, freccia per freccia, con le etichette corrette.

#### **Elementi di Base**

1.  **Stati:** Disegna 7 cerchi. Etichettali `q₀`, `q₁`, `q₂`, `q₃`, `q₄`, `q₅`, e `q_f`.
2.  **Stato Iniziale:** Disegna una freccia che punta a `q₀`.
3.  **Stato Finale:** Disegna un doppio cerchio attorno a `q_f`.
4.  **Simboli Pila:** Useremo `A` come contatore per le `a` (valore 1) e `B` come contatore per le `b` (valore 2). `Z₀` è il simbolo iniziale della pila.

#### **Disegno delle Transizioni (Frecce ed Etichette)**

La nostra strategia è "PUSH `x+2y`" e poi "POP `z+w`".

---

##### **FASE 1: Lettura di `aˣ` (Push di `x`)**

Questa fase gestisce il blocco `aˣ`, con `x > 0`.

*   **Freccia da `q₀` a `q₁`:**
    *   **Etichetta:** `a, Z₀ / AZ₀`
    *   **Significato:** "Leggi la **prima a** (soddisfa `x>0`). Se in cima alla pila c'è `Z₀`, estrailo, spingi un contatore `A` e poi rimetti `Z₀`. Ora sulla pila c'è il conteggio di una `a`."

*   **Freccia da `q₁` che torna su se stesso (loop):**
    *   **Etichetta:** `a, A / AA`
    *   **Significato:** "Per ogni **a successiva**, se in cima c'è un contatore `A`, estrailo e spingi due `A` (quello appena tolto e quello nuovo). Continua a contare le `a`."

---

##### **FASE 2: Lettura di `bʸ` (Push di `2y`)**

Questa fase gestisce il blocco `bʸ`, con `y > 0`.

*   **Freccia da `q₁` a `q₂`:**
    *   **Etichetta:** `b, A / BBA`
    *   **Significato:** "Leggi la **prima b** (soddisfa `y>0`). Estrai il contatore `A` in cima e spingi **due contatori B** (per il `2y`) e poi rimetti `A`. Ogni `b` vale due simboli sulla pila."

*   **Freccia da `q₂` che torna su se stesso (loop):**
    *   **Etichetta:** `b, B / BBB`
    *   **Significato:** "Per ogni **b successiva**, estrai il `B` in cima e spingi tre `B` (quello tolto e i due nuovi). Continua a contare `2y`."

---

##### **FASE 3: Lettura di `cᶻ` (Pop di `z`)**

Ora iniziamo a svuotare la pila. Questa fase gestisce `cᶻ`, con `z > 0`.

*   **Freccia da `q₂` a `q₃`:**
    *   **Etichetta:** `c, B / ε`
    *   **Significato:** "Leggi la **prima c** (soddisfa `z>0`). Se in cima alla pila c'è un `B`, estrailo (pop) e non spingere nulla (indicato da `ε`). Abbiamo iniziato a 'sottrarre' dal totale."

*   **Freccia da `q₃` che torna su se stesso (loop):**
    *   **Etichetta:** Metti due etichette separate per questa freccia:
        1.  `c, B / ε` (se in cima c'è un B)
        2.  `c, A / ε` (se in cima c'è un A)
    *   **Significato:** "Per ogni **c successiva**, estrai un simbolo dalla pila, non importa quale sia."

---

##### **FASE 4: Lettura del `b*` intermedio**

Questa fase salta i `b` intermedi senza alterare il conteggio.

*   **Freccia da `q₃` a `q₄`:**
    *   **Etichetta:** `b, X / X` (shorthand per `b,A/A` e `b,B/B`)
    *   **Significato:** "Leggi un `b` e lascia la pila inalterata."
    *   *Nota: La transizione da `q₃` a `q₄` può anche essere su `a` per iniziare l'ultima fase. Spostiamo il `b*` su `q₄`.*
    *   **Rettifica per un disegno più pulito:** Creiamo uno stato apposito.
    *   **Freccia da `q₃` a `q₄`:** `ε, X / X` (passaggio di stato senza leggere input)
    *   **Freccia da `q₄` che torna su se stesso (loop):**
        *   **Etichetta:** `b, X / X`
        *   **Significato:** "Leggi tutti i `b` di questo blocco senza toccare la pila."

---

##### **FASE 5: Lettura di `aʷ` (Pop di `w`)**

Questa è l'ultima fase di conteggio. Gestisce `aʷ`, con `w > 0`.

*   **Freccia da `q₄` a `q₅`:**
    *   **Etichetta:** Metti due etichette separate:
        1. `a, B / ε`
        2. `a, A / ε`
    *   **Significato:** "Leggi la **prima a** dell'ultimo blocco (soddisfa `w>0`). Estrai un simbolo dalla pila."

*   **Freccia da `q₅` che torna su se stesso (loop):**
    *   **Etichetta:** Metti due etichette separate:
        1.  `a, B / ε`
        2.  `a, A / ε`
    *   **Significato:** "Per ogni **a successiva**, continua a estrarre simboli dalla pila."

---

##### **FASE 6: Accettazione**

*   **Freccia da `q₅` allo stato finale `q_f`:**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Dopo aver letto tutto l'input (transizione `ε`), se in cima alla pila c'è solo `Z₀`, significa che `x+2y` era uguale a `z+w`. La stringa è valida. Accetta."


## Es 4

Si consideri il linguaggio `L = {uwwRv | u,v,w ∈ {a,b}+}`.

1.  Utilizzare un formalismo a potenza minima (tra tutti quelli visti a lezione) che caratterizzi il linguaggio `L`.
2.  Cambierebbe il formalismo a potenza minima se il linguaggio fosse `L' = {wwRv | v,w ∈ {a,b}+}`?

---

### **Spiegazione e Analisi del Punto 1 (Linguaggio L)**

#### **Passo 1: Comprendere la Struttura di L**

Il linguaggio `L` è composto da stringhe formate da quattro parti:
*   `u`: una stringa non vuota all'inizio.
*   `w`: una stringa non vuota.
*   `wR`: la stringa `w` letta al contrario (la sua "immagine speculare").
*   `v`: una stringa non vuota alla fine.

A prima vista, la presenza di `wwR` fa subito pensare a un linguaggio libero dal contesto (context-free), poiché riconoscere `wwR` è un compito classico per un automa a pila. Tuttavia, dobbiamo analizzare la struttura più attentamente.

#### **Passo 2: L'Intuizione Fondamentale della Soluzione**

La soluzione fa un'osservazione cruciale: **ogni stringa che si può generare con un `w` di lunghezza maggiore di 1, si può anche generare con un `w` di lunghezza 1.**

Verifichiamo questa affermazione.
*   Sia `w` una stringa con `|w| > 1`. Ad esempio, `w = "aba"`. Allora `wR = "aba"`. Il pezzo centrale della stringa sarebbe `wwR = "abaaba"`.
*   Una stringa completa in `L` potrebbe essere `u(abaaba)v`, ad esempio con `u="b"` e `v="a"`, ottenendo `babaabaa`.
*   La soluzione afferma che questa stessa stringa `babaabaa` può essere ottenuta con un `w'` di lunghezza 1. Come?
    *   Notiamo che `wwR` contiene sempre una coppia di lettere uguali al centro: se `w = c₁c₂...cₖ`, allora `wwR = c₁...cₖcₖ...c₁`. La parte `cₖcₖ` è sempre `aa` o `bb`.
    *   Nella nostra stringa `babaabaa`, la sottostringa `wwR = "abaaba"` contiene "aa" al centro.
    *   Possiamo "ridefinire" le parti della stringa:
        *   Scegliamo il `w'` di lunghezza 1: `w' = "a"`. Quindi `w'w'R = "aa"`.
        *   La parte prima di `"aa"` diventa il nuovo `u'`: `u' = "babaab"`.
        *   La parte dopo `"aa"` diventa il nuovo `v'`: `v' = "a"`.
    *   Poiché sia `u'` che `v'` sono non vuoti, questa è una scomposizione valida. La stringa `babaabaa` appartiene anche al sotto-linguaggio generato con `w` di lunghezza 1.

Questo "collasso" funziona sempre. Poiché `u` e `v` devono esistere e possono "assorbire" qualsiasi carattere, la vera condizione per l'appartenenza a `L` si riduce a trovare una sottostringa `aa` o `bb` che non sia né all'inizio né alla fine della stringa.

#### **Passo 3: Semplificazione e Formalismo**

Il linguaggio `L` è quindi equivalente a:
`L = {u(aa)v | u,v ∈ {a,b}+} ∪ {u(bb)v | u,v ∈ {a,b}+}`

Questo è il linguaggio di tutte le stringhe che contengono `aa` o `bb` come sottostringa, precedute e seguite da almeno un carattere. Questo linguaggio è **regolare**.

*   **Espressione Regolare:** `(a|b)+(aa|bb)(a|b)+`
*   **Formalismo a Potenza Minima:** Poiché il linguaggio è regolare, il formalismo a potenza minima è uno qualsiasi tra:
    *   Automa a Stati Finiti (FSA)
    *   Grammatica Regolare (Tipo 3)
    *   Espressione Regolare
    *   **Logica Monadica del Primo Ordine (MFO)**, che è un formalismo equivalente ai precedenti.

La soluzione sceglie la **MFO**. La formula fornita descrive perfettamente il linguaggio:
`∃x(x > 0 ∧ (a(x)∧a(x+1) ∨ b(x)∧b(x+1)) ∧ ¬last(x+1))`
*   `∃x`: "Esiste una posizione x..."
*   `x > 0`: "...che non è l'inizio della stringa" (garantisce che `u` non sia vuoto).
*   `(a(x)∧a(x+1) ∨ b(x)∧b(x+1))`: "...tale che in posizione x e x+1 ci sia 'aa' oppure 'bb'".
*   `¬last(x+1)`: "...e la posizione x+1 non è la fine della stringa" (garantisce che `v` non sia vuoto).

---

### **Spiegazione e Analisi del Punto 2 (Linguaggio L')**

#### **Passo 1: Comprendere la Struttura di L'**

Il linguaggio `L'` è ` {wwRv | v,w ∈ {a,b}+}`.
L'unica differenza è la **rimozione del prefisso `u`**. La stringa deve iniziare direttamente con `wwR`.

#### **Passo 2: Il "Collasso" Funziona Ancora?**

La risposta è **no**. Vediamo perché.
*   Consideriamo la stringa `abbaa` che è in `L'` con `w="ab"` e `v="a"`.
*   Se provassimo a re-interpretarla con un `w'` di lunghezza 1, diciamo `w'="a"`, allora la stringa dovrebbe iniziare con `w'w'R = "aa"`. Ma `abbaa` inizia con `a`, non con `aa`.
*   Se provassimo con `w'="b"`, la stringa dovrebbe iniziare con `w'w'R = "bb"`. Ma `abbaa` non inizia con `bb`.

La rimozione del prefisso `u` ha bloccato la nostra capacità di "ridefinire" le parti della stringa. La struttura `wwR` all'inizio deve essere rispettata per il `w` originale.

#### **Passo 3: Requisiti e Formalismo**

Per riconoscere `L'`, un automa deve:
1.  Leggere una porzione iniziale della stringa, `w`.
2.  Memorizzare `w` in qualche modo.
3.  Indovinare (non deterministicamente) il punto esatto in cui `w` finisce e `wR` inizia.
4.  Leggere la porzione successiva, `wR`, e verificare che sia l'immagine speculare di `w` usando la memoria.
5.  Verificare che ci sia una parte finale `v` non vuota.

Questo processo richiede una memoria illimitata (la pila) e non determinismo.

*   **Formalismo a Potenza Minima:** Il modello necessario è un **Automa a Pila Non Deterministico (NPDA)**. Il linguaggio `L'` è **libero dal contesto e non regolare**. La grammatica a potenza minima sarebbe una **Grammatica Libera dal Contesto (Context-Free Grammar)**.
## Es 5
Si consideri il linguaggio `L = {xy | x,y ∈ {a,b}* e #a(x) = #b(y)}`.

1.  Utilizzare un formalismo a potenza minima che caratterizzi il linguaggio `L`.
2.  Cambierebbe il formalismo a potenza minima se il linguaggio fosse `L' = {xcy | x,y ∈ {a,b}* e #a(x) = #b(y)}`?

---

### **1. Analisi del Linguaggio `L`**

#### **L'Intuizione Sorprendente: `L` è l'insieme di TUTTE le stringhe**

La parte più difficile da capire è perché `L` sia in realtà equivalente a `{a,b}*` (l'insieme di tutte le possibili stringhe con i caratteri 'a' e 'b'). La definizione di `L` ci permette di scegliere **qualsiasi punto di divisione** tra `x` e `y`. La soluzione dimostra che, data una qualsiasi stringa `w`, possiamo **sempre** trovare un punto di divisione tale che la condizione `#a(x) = #b(y)` sia soddisfatta.

**Spieghiamo la dimostrazione della soluzione in modo più semplice, con un'analogia:**

Immagina di camminare lungo la stringa `w` da sinistra a destra. Ad ogni passo `i`, sposti il confine tra `x` (la parte che hai già percorso) e `y` (la parte che devi ancora percorrere).
Definiamo un "punteggio" ad ogni passo `i`:
`Punteggio(i) = (numero di 'a' nella parte percorsa x) - (numero di 'b' nella parte restante y)`

Il nostro obiettivo è dimostrare che, durante questa camminata, il nostro punteggio toccherà **esattamente lo zero** almeno una volta.

1.  **All'inizio (passo i=0):**
    *   La parte percorsa `x` è la stringa vuota. Il numero di 'a' è 0.
    *   La parte restante `y` è l'intera stringa `w`.
    *   `Punteggio(0) = 0 - #b(w) = -#b(w)`. Questo è un numero **minore o uguale a 0**.

2.  **Alla fine (passo i=n, dove n è la lunghezza di w):**
    *   La parte percorsa `x` è l'intera stringa `w`.
    *   La parte restante `y` è la stringa vuota. Il numero di 'b' è 0.
    *   `Punteggio(n) = #a(w) - 0 = #a(w)`. Questo è un numero **maggiore o uguale a 0**.

3.  **Come cambia il punteggio a ogni passo?**
    Quando ci spostiamo dal passo `i` al passo `i+1`, prendiamo il primo carattere di `y` e lo spostiamo alla fine di `x`. Vediamo come questo influisce sul punteggio.
    *   **Se il carattere spostato è una 'a':**
        *   Il numero di 'a' in `x` aumenta di 1.
        *   Il numero di 'b' in `y` rimane invariato.
        *   Il nuovo punteggio è `(vecchio #a(x) + 1) - (vecchio #b(y)) = Punteggio(i) + 1`.
    *   **Se il carattere spostato è una 'b':**
        *   Il numero di 'a' in `x` rimane invariato.
        *   Il numero di 'b' in `y` diminuisce di 1.
        *   Il nuovo punteggio è `(vecchio #a(x)) - (vecchio #b(y) - 1) = Punteggio(i) + 1`.

Incredibilmente, in entrambi i casi, il punteggio **aumenta sempre di esattamente 1** ad ogni passo!

**Conclusione:** Abbiamo una sequenza di punteggi che parte da un valore `≤ 0`, finisce a un valore `≥ 0`, e aumenta di 1 a ogni passo. Per il principio dei valori intermedi (in versione discreta), questa sequenza **deve necessariamente passare per lo 0**.
Ciò significa che per qualsiasi stringa `w`, esiste un punto di divisione `i` per cui `#a(x) = #b(y)`.

Poiché ogni stringa `w` appartiene a `L`, allora `L = {a,b}*`.

#### **Formalismo a Potenza Minima per `L`**

*   Il linguaggio `{a,b}*` è il linguaggio **regolare** per eccellenza.
*   I formalismi a potenza minima per i linguaggi regolari sono:
    *   Automi a Stati Finiti (FSA)
    *   Grammatiche Regolari (Tipo 3)
    *   Espressioni Regolari (in questo caso, `(a|b)*`)
    *   Logica Monadica del Primo Ordine (MFO)
*   La soluzione sceglie correttamente la **MFO**. La formula `∀x(a(x) ∨ b(x))` significa "per ogni posizione `x` nella stringa, il carattere è o una 'a' o una 'b'", che descrive perfettamente `{a,b}*`.

---

### **2. Analisi del Linguaggio `L'`**

#### **L'Impatto del Marcatore 'c'**

Il linguaggio `L'` è ` {xcy | x,y ∈ {a,b}* e #a(x) = #b(y)}`.
L'introduzione del carattere `c` cambia tutto. Perché?

Perché ora **il punto di divisione non è più una nostra scelta**. Il marcatore `c` **fissa** in modo inequivocabile dove finisce `x` e dove inizia `y`. Tutta la logica della "camminata" e della ricerca di un punto di divisione crolla.

Per riconoscere `L'`, una macchina deve:
1.  Leggere la parte `x` e **contare** il numero di 'a'.
2.  Leggere il marcatore `c`, che segnala di cambiare comportamento.
3.  Leggere la parte `y` e **contare** il numero di 'b'.
4.  Alla fine, confrontare i due conteggi.

#### **Formalismo a Potenza Minima per `L'`**

*   Questa operazione di conteggio richiede una memoria potenzialmente illimitata. Un Automa a Stati Finiti non è più sufficiente.
*   Il modello perfetto per questo compito è un **Automa a Pila (Pushdown Automaton)**.
    *   Mentre legge `x`, per ogni `a` spinge un simbolo (es. `A`) sulla pila.
    *   Quando legge `c`, non fa nulla sulla pila ma cambia stato.
    *   Mentre legge `y`, per ogni `b` estrae un simbolo `A` dalla pila.
    *   Se alla fine della stringa la pila è vuota, significa che i conteggi corrispondevano e la stringa viene accettata.
*   Poiché il marcatore `c` rende il processo privo di ambiguità (non c'è da "indovinare" dove finisce `x`), un **automa a pila deterministico (DPDA)** è sufficiente.
*   **Conclusione:** Il formalismo a potenza minima cambia da **Regolare (MFO/FSA)** a **Deterministico Libero dal Contesto (DPDA)**.

## Es 6
### **1. Linguaggio L1 = {aᵏw | w ∈ A* e w contiene *almeno* k simboli a, con k ≥ 1}**

#### **Passo 1: Analisi e Scelta del Formalismo**

*   **Problema:** Dobbiamo "contare" il numero `k` di `a` all'inizio, memorizzarlo, e poi verificare che nella parte `w` della stringa ci siano *almeno* altrettante `a`.
*   **Perché non è Regolare:** Un automa a stati finiti non ha memoria illimitata. Non può ricordare un valore `k` arbitrariamente grande.
*   **Perché è Libero dal Contesto:** Un automa a pila (PDA) ha una pila, che è una memoria illimitata, perfetta per contare.
*   **Perché è Non Deterministico:** Il punto di divisione tra `aᵏ` e `w` non è segnato. Ad esempio, nella stringa `aaaba`, `k` potrebbe essere 1 (con `w=aaba`), 2 (con `w=aba`) o 3 (con `w=ba`). L'automa deve "indovinare" quale di queste è la scomposizione corretta. Questo richiede non determinismo.
*   **Conclusione:** Il formalismo a potenza minima è un **Automa a Pila Non Deterministico (NPDA)**.

#### **Passo 2: Guida al Disegno dell'Automa per L1**

La nostra strategia sarà:
1.  **Fase di Conteggio:** Leggere le `a` iniziali e spingere un "gettone" sulla pila per ciascuna.
2.  **Scelta Non Deterministica:** Indovinare quando `aᵏ` finisce e `w` inizia.
3.  **Fase di Riscontro:** Leggere `w` e, per ogni `a` trovata, togliere un gettone dalla pila.
4.  **Fase di Accettazione:** Appena la pila si svuota (abbiamo trovato `k` 'a' in `w`), entriamo in uno stato finale e accettiamo, ignorando il resto della stringa.

**Elementi di Base:**
*   **Stati:** Disegna quattro cerchi: `q₀` (iniziale), `q₁` (conteggio prefisso), `q₂` (riscontro in `w`), `q₃` (accettazione finale).
*   **Stato Finale:** Disegna un doppio cerchio attorno a `q₃`.
*   **Simboli Pila:** `X` sarà il nostro "gettone" contatore. `Z₀` è il simbolo iniziale.

**Disegno delle Transizioni (Frecce e Loro Etichette):**

*   **Freccia da `q₀` a `q₁`:**
    *   **Etichetta:** `a, Z₀ / XZ₀`
    *   **Significato:** "Leggi la **prima a** (soddisfa `k≥1`). Se la pila è vuota (contiene `Z₀`), spingi un gettone `X`."

*   **Freccia da `q₁` che torna su se stesso (loop):**
    *   **Etichetta:** `a, X / XX`
    *   **Significato:** "Per ogni **a successiva** nel prefisso, spingi un altro gettone `X`."

*   **Freccia da `q₁` a `q₂` (La Scelta Non Deterministica):**
    *   **Etichetta:** `ε, X / X`
    *   **Significato:** "A questo punto, **indovina** che il prefisso `aᵏ` è finito. Senza leggere input (`ε`), passa allo stato di riscontro `q₂`, lasciando la pila com'è."

*   **Frecce da `q₂` che tornano su se stesso (loop):**
    *   **Etichetta 1:** `b, X / X`
        *   **Significato:** "Se leggi una `b` in `w`, ignorala e lascia la pila com'è."
    *   **Etichetta 2:** `a, X / ε`
        *   **Significato:** "Se leggi una `a` in `w`, usala per 'pagare' un gettone. Estrai (pop) un `X` dalla pila."

*   **Freccia da `q₂` a `q₃`:**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "In qualsiasi momento, se la pila si è svuotata (vedi `Z₀`), significa che abbiamo trovato **almeno k** simboli `a` in `w`. La condizione è soddisfatta. Passa allo stato finale `q₃`."

*   **Frecce da `q₃` che tornano su se stesso (loop):**
    *   **Etichetta 1:** `a, Z₀ / Z₀`
    *   **Etichetta 2:** `b, Z₀ / Z₀`
    *   **Significato:** "Una volta nello stato finale, ignora tutti i caratteri rimanenti fino alla fine della stringa."

---

### **2. Linguaggio L2 = {aᵏw | w ∈ A* e w contiene *esattamente* k simboli a, con k ≥ 1}**

#### **Passo 1: Analisi e Scelta del Formalismo**

*   **Problema:** La logica è la stessa di L1, ma la condizione è più stringente: il numero di `a` in `w` deve essere *esattamente* `k`, né più né meno.
*   **Formalismo:** Il ragionamento non cambia. Serve ancora un contatore illimitato (pila) e la capacità di indovinare dove finisce `aᵏ` (non determinismo).
*   **Conclusione:** Il formalismo a potenza minima è ancora un **Automa a Pila Non Deterministico (NPDA)**.

#### **Passo 2: Guida al Disegno dell'Automa per L2**

La strategia è quasi identica, ma la condizione di accettazione cambia radicalmente. Non possiamo più accettare "in anticipo". Dobbiamo arrivare alla fine della stringa e, solo allora, controllare che la pila sia vuota.

**Elementi di Base:**
*   **Stati:** Bastano tre cerchi: `q₀` (iniziale), `q₁` (conteggio prefisso), `q₂` (riscontro in `w`).
*   **Stato Finale:** `q₂` stesso sarà lo stato finale. Lo vedremo tra poco. No, è più pulito avere uno stato finale separato. Usiamo `q_f`. Quindi `q₀, q₁, q₂, q_f`.
*   **Simboli Pila:** `X` e `Z₀`.

**Disegno delle Transizioni (Frecce e Loro Etichette):**

*   **Freccia da `q₀` a `q₁`:**
    *   **Etichetta:** `a, Z₀ / XZ₀` (Identica a L1)

*   **Freccia da `q₁` che torna su se stesso (loop):**
    *   **Etichetta:** `a, X / XX` (Identica a L1)

*   **Freccia da `q₁` a `q₂` (La Scelta Non Deterministica):**
    *   **Etichetta:** `ε, X / X` (Identica a L1)

*   **Frecce da `q₂` che tornano su se stesso (loop):**
    *   **Etichetta 1:** `b, X / X` (Identica a L1)
    *   **Etichetta 2:** `a, X / ε` (Identica a L1)
    *   **NUOVA Etichetta 3:** `b, Z₀ / Z₀`
        *   **Significato:** "Se hai già esaurito tutti i gettoni (`X`), ma trovi ancora delle `b` in `w`, va bene, ignorale."

*   **Freccia da `q₂` allo stato finale `q_f` (La Condizione Finale):**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Senza leggere input, se ti trovi nello stato `q₂` e la pila è vuota (contiene solo `Z₀`), puoi passare allo stato finale. La stringa sarà accettata **solo se** l'input è anche terminato."

**La Differenza Chiave:**
In L1, una volta raggiunto lo stato finale `q₃`, l'automa accetta indipendentemente da cosa viene dopo. In L2, non esiste uno stato del genere. L'automa rimane nello stato di riscontro `q₂` per tutta la durata di `w`. Se durante questo percorso legge una `a` ma la pila è già vuota, la computazione si blocca (fallisce). L'accettazione avviene solo alla fine dell'input, passando da `q₂` a `q_f` se e solo se la pila si è svuotata perfettamente.


## Es 7
Si considerino i linguaggi seguenti:
*   `L1 = {aⁿbⁿcⁿ | n > 0}`
*   `L2 = {b}*.{a,b,c}+`

Per ciascuno dei linguaggi indicati di seguito, utilizzare un formalismo a potenza minima (tra tutti quelli visti a lezione) che lo caratterizzi:

1.  `L = L1 \ L2` (differenza insiemistica)
2.  `L' = L1 ∪ L2` (unione)

---

### **Analisi Preliminare dei Linguaggi di Partenza**

Prima di risolvere i punti, è fondamentale capire la natura di `L1` e `L2`.

*   **L1 = {aⁿbⁿcⁿ | n > 0}**
    *   **Descrizione:** Questo è il linguaggio "modello" dei **linguaggi sensibili al contesto (Context-Sensitive)**. Contiene stringhe come `abc`, `aabbcc`, `aaabbbccc`, etc.
    *   **Classe:** Non è regolare e non è nemmeno libero dal contesto. Richiede una memoria più potente di una pila per essere riconosciuto.

*   **L2 = {b}*.{a,b,c}+**
    *   **Descrizione:** Questa è un'**espressione regolare**. Analizziamola:
        *   `{b}*`: significa "zero o più `b` all'inizio".
        *   `.`: concatenato con...
        *   `{a,b,c}+`: significa "almeno un carattere dall'alfabeto `{a,b,c}`".
    *   **Semplificazione:** Cosa descrive questa espressione? Qualsiasi stringa che inizia con zero o più `b` ed è seguita da almeno una lettera (a, b, o c). In pratica, questo descrive **qualsiasi stringa non vuota sull'alfabeto {a,b,c}**. Ad esempio, `a`, `b`, `c`, `bbb`, `abacaba` sono tutte in `L2`.
    *   **Classe:** Poiché è descritto da un'espressione regolare, `L2` è un **linguaggio regolare**.

---

### **1. Soluzione per L = L1 \ L2 (Differenza Insiemistica)**

#### **Passo 1: Comprendere la Relazione tra L1 e L2**

L'operazione `L1 \ L2` significa "prendi tutte le stringhe che sono in `L1` ma **non** sono in `L2`". Per calcolare questo, dobbiamo chiederci: esiste qualche stringa in `L1` che non sia anche in `L2`?

*   Prendiamo una qualsiasi stringa `w` da `L1`. Ad esempio, `w = aabbcc`.
*   Questa stringa `w` è composta dai caratteri `{a,b,c}`? Sì.
*   Questa stringa `w` è non vuota? Sì, perché la condizione è `n > 0`, quindi la stringa più corta è `abc`.
*   Abbiamo stabilito che `L2` è l'insieme di *tutte* le stringhe non vuote sull'alfabeto `{a,b,c}`.
*   Poiché ogni stringa di `L1` è non vuota e usa solo i caratteri `{a,b,c}`, allora **ogni stringa di `L1` è anche una stringa di `L2`**.

In termini insiemistici, **L1 è un sottoinsieme di L2** (`L1 ⊂ L2`).

#### **Passo 2: Calcolare la Differenza e Scegliere il Formalismo**

Se togliamo da `L1` tutte le stringhe che sono anche in `L2`, e abbiamo appena dimostrato che *tutte* le stringhe di `L1` sono in `L2`, cosa rimane? Nulla.

`L = L1 \ L2 = ∅` (il **linguaggio vuoto**).

*   **Classe del Linguaggio Vuoto:** Il linguaggio vuoto è un linguaggio **finito** (contiene zero stringhe). Tutti i linguaggi finiti sono **regolari**.
*   **Formalismo a Potenza Minima:** Il formalismo a potenza minima è quello per i linguaggi regolari. Tra le opzioni (Automi Finiti, Grammatiche Regolari, Espressioni Regolari, MFO), la **Logica Monadica del Primo Ordine (MFO)** è una scelta valida e potente.
*   **Spiegazione della Formula MFO:** `φL : ∃x(a(x) ∧ ¬a(x))`
    *   `∃x`: "Esiste una posizione `x`..."
    *   `a(x) ∧ ¬a(x)`: "...tale che il carattere in quella posizione è 'a' E contemporaneamente NON è 'a'."
    *   Questa è una palese **contraddizione logica**. Nessuna stringa può mai soddisfare questa condizione. Pertanto, la formula descrive perfettamente il linguaggio vuoto.

---

### **2. Soluzione per L' = L1 ∪ L2 (Unione)**

#### **Passo 1: Calcolare l'Unione**

L'operazione `L1 ∪ L2` significa "prendi tutte le stringhe che sono in `L1`, o in `L2`, o in entrambi".

*   Abbiamo già stabilito che `L1` è un sottoinsieme di `L2`.
*   Quando si unisce un insieme con un suo sottoinsieme, il risultato è semplicemente l'insieme più grande. (Esempio: l'unione dell'insieme dei "cani" e dell'insieme dei "mammiferi" è semplicemente l'insieme dei "mammiferi").

Quindi, `L' = L1 ∪ L2 = L2`.

#### **Passo 2: Scegliere il Formalismo**

Abbiamo ridotto il problema a trovare il formalismo a potenza minima per `L2`.

*   **Classe di L2:** Come analizzato all'inizio, `L2` è un **linguaggio regolare**.
*   **Formalismo a Potenza Minima:** Ancora una volta, MFO è una scelta appropriata.
*   **Spiegazione della Formula MFO:** `φL' : (a(0) ∨ b(0) ∨ c(0)) ∧ ∀x(a(x) ∨ b(x) ∨ c(x))`
    *   `∀x(a(x) ∨ b(x) ∨ c(x))`: Questa parte dice "per ogni posizione `x`, il carattere è 'a' o 'b' o 'c'". Questo definisce l'insieme di tutte le stringhe sull'alfabeto `{a,b,c}`, ovvero `{a,b,c}*`.
    *   `(a(0) ∨ b(0) ∨ c(0))`: Questa parte aggiunge una condizione: "il carattere in posizione 0 (cioè il primo carattere) deve essere 'a' o 'b' o 'c'". Questo è un modo formale per dire "la stringa non deve essere vuota".
    *   Mettendo insieme le due parti con `∧` (AND), la formula dice: "la stringa non è vuota E è composta solo da `a`, `b`, `c`". Questo è esattamente il linguaggio `{a,b,c}+`, che è la nostra versione semplificata di `L2`.

## Es 8

**Linguaggio:**  L = {aⁿbᵐcᵒd | n, m, o ∈ ℕ, n ≥ 1, o ≥ 0, m = 2n + o}.  
Utilizzare un formalismo a potenza minima che caratterizzi il linguaggio L.

**Soluzione Fornita:**  
Il linguaggio è libero dal contesto, riconoscibile da un automa a pila deterministico. Riscrivere la definizione come L = {aⁿb²ⁿbᵒcᵒd; n,o ∈ ℕ,n ≥ 1} rende evidente la natura del linguaggio. Per riconoscerlo è sufficiente impilare un simbolo per ogni a, spilarne uno ogni due b, fino a quando la pila è vuota. Per le b successive, impilare un simbolo per ogni b e spilare un simbolo per ogni c effettua il conteggio del valore o, al termine del quale è sufficiente riconoscere la presenza della singola d.

### **Analisi della Strategia**

Prima di disegnare, capiamo a fondo la logica della soluzione:

1.  **Riformulazione:** Il vincolo `m = 2n + o` viene scomposto. Il blocco di `b` viene pensato come due parti consecutive: `b²ⁿ` (per le `a`) e `bᵒ` (per le `c`). La stringa diventa `aⁿ b²ⁿ bᵒ cᵒ d`.
2.  **Fase 1 (a vs b):** L'automa prima si occupa di verificare che il primo blocco di `b` sia lungo il doppio delle `a`.
3.  **Fase 2 (b vs c):** Poi, si occupa di verificare che il secondo blocco di `b` sia lungo quanto le `c`.

Questa separazione è la chiave per rendere l'automa deterministico.

---

### **Guida Dettagliata al Disegno dell'Automa (DPDA)**

Ecco come disegnare il grafo, freccia per freccia, con le etichette corrette nello standard `input, pop / push`.

#### **Elementi di Base**

1.  **Stati:** Disegna 6 cerchi. Etichettali `q₀` (iniziale), `q₁` (legge `a` e `b` pari), `q₂` (legge `b` dispari), `q₃` (legge `b` per le `c`), `q₄` (legge `c`), `q_f` (finale).
2.  **Stato Finale:** Disegna un doppio cerchio attorno a `q_f`.
3.  **Simboli Pila:** `A` per contare le `a`, `B` per contare le `b` della seconda fase, `Z₀` come simbolo iniziale.

---

#### **FASE 1: Conteggio di `aⁿ` e Riscontro di `b²ⁿ`**

*   **Freccia da `q₀` a `q₁`:**
    *   **Etichetta:** `a, Z₀ / AZ₀`
    *   **Significato:** "Leggi la **prima a** (soddisfa `n≥1`). Spingi un contatore `A` sulla pila."

*   **Freccia da `q₁` che torna su se stesso (loop):**
    *   **Etichetta:** `a, A / AA`
    *   **Significato:** "Per ogni **`a` successiva**, continua a spingere contatori `A` sulla pila."

*   **Freccia da `q₁` a `q₂`:**
    *   **Etichetta:** `b, A / A`
    *   **Significato:** "Inizia a leggere le `b`. Leggi la **prima `b` di una coppia**. Non toccare la pila, ma cambia stato per ricordarti di aver letto una `b` dispari."

*   **Freccia da `q₂` a `q₁`:**
    *   **Etichetta:** `b, A / ε`
    *   **Significato:** "Leggi la **seconda `b` di una coppia**. Ora che la coppia è completa, estrai (pop) un contatore `A` dalla pila. Torna a `q₁` per cercare la prossima coppia."

---

#### **FASE 2: Transizione e Conteggio di `bᵒ`**

Questa fase inizia quando tutti i contatori `A` sono stati eliminati, il che significa che abbiamo letto esattamente `2n` `b`.

*   **Freccia da `q₁` a `q₃` (se `o > 0`):**
    *   **Etichetta:** `b, Z₀ / BZ₀`
    *   **Significato:** "Hai finito la prima fase (la pila è vuota, vedi `Z₀`) e leggi un'altra `b`. Questa deve essere la **prima `b` della seconda fase**. Inizia a contare per le `c` spingendo un contatore `B`."

*   **Freccia da `q₃` che torna su se stesso (loop):**
    *   **Etichetta:** `b, B / BB`
    *   **Significato:** "Per ogni **`b` successiva** di questa fase, continua a spingere contatori `B`."

---

#### **FASE 3: Riscontro di `cᵒ`**

*   **Freccia da `q₃` a `q₄`:**
    *   **Etichetta:** `c, B / ε`
    *   **Significato:** "Inizia a leggere le `c`. Per la **prima `c`**, estrai un contatore `B`."

*   **Freccia da `q₄` che torna su se stesso (loop):**
    *   **Etichetta:** `c, B / ε`
    *   **Significato:** "Per ogni **`c` successiva**, continua a estrarre contatori `B`."

---

#### **FASE 4: Accettazione Finale**

La stringa deve terminare con una `d`. L'automa deve poter leggere `d` in due scenari: se non ci sono state `c` (e quindi neanche `b` della seconda fase), oppure dopo aver letto tutte le `c`.

*   **Freccia da `q₁` a `q_f` (caso `o = 0`):**
    *   **Etichetta:** `d, Z₀ / Z₀`
    *   **Significato:** "Se, dopo aver finito la fase `aⁿb²ⁿ`, leggi una `d` e la pila è vuota, la stringa è valida. Accetta."

*   **Freccia da `q₄` a `q_f` (caso `o ≥ 0`):**
    *   **Etichetta:** `d, Z₀ / Z₀`
    *   **Significato:** "Se, dopo aver finito di riscontrare le `c`, leggi una `d` e la pila è vuota, la stringa è valida. Accetta."

## Es 9

Si costruisca una grammatica o automa o formula logica a potenza minima per il seguente linguaggio:
`{a²ⁿΣ⁺b³ⁿ | n > 0} ∪ {Σ⁺b³ⁿ | n > 0}`
con `Σ = {a, b}`.

---

### Spiegazione e Analisi della Soluzione

#### **Passo 1: Analizzare i due linguaggi componenti**

Il linguaggio `L` è l'unione di due insiemi, `L₁` e `L₂`:
*   `L₁ = {a²ⁿΣ⁺b³ⁿ | n > 0}`
*   `L₂ = {Σ⁺b³ⁿ | n > 0}`

**L₁:** Questo linguaggio è composto da stringhe che:
*   Iniziano con un numero pari e non nullo di `a` (es. `aa`, `aaaa`, ...).
*   Sono seguite da una sequenza non vuota di `a` e/o `b` (`Σ⁺`).
*   Terminano con un numero di `b` che è un multiplo di 3 non nullo, e questo numero di `b` (`3n`) è correlato al numero di `a` iniziali (`2n`).

**L₂:** Questo linguaggio è composto da stringhe che:
*   Iniziano con una sequenza non vuota di `a` e/o `b` (`Σ⁺`).
*   Terminano con un numero di `b` che è un multiplo di 3 non nullo (`b³`, `b⁶`, ...).

#### **Passo 2: L'osservazione fondamentale (Inclusione degli insiemi)**

La soluzione fa un'osservazione cruciale: **`L₁` è un sottoinsieme di `L₂`**. Vediamo perché.

Prendiamo una qualsiasi stringa `w` che appartiene a `L₁`. Per definizione, `w` ha la forma `a²ⁿs b³ⁿ`, dove `s` è una stringa non vuota (`s ∈ Σ⁺`).

Ora chiediamoci: questa stessa stringa `w` appartiene anche a `L₂`?
Per appartenere a `L₂`, una stringa deve avere la forma `t b³k`, dove `t` è una stringa non vuota (`t ∈ Σ⁺`) e `k > 0`.

*   La nostra stringa `w = a²ⁿs b³ⁿ` termina con `b³ⁿ`, che soddisfa il requisito del suffisso.
*   La parte che precede il suffisso è `a²ⁿs`. Chiamiamo questa parte `t'`.
*   È `t'` non vuota? Sì, perché `n>0` (quindi `a²ⁿ` ha almeno due `a`) e `s` è non vuota. La concatenazione di due stringhe non vuote è non vuota.
*   Quindi, `w` può essere scritta nella forma richiesta da `L₂`.

Poiché ogni stringa in `L₁` è anche in `L₂`, si ha che `L₁ ⊂ L₂`.

#### **Passo 3: Semplificazione del Linguaggio e Classificazione**

L'operazione richiesta è l'**unione** (`∪`). Quando si unisce un insieme con un suo sottoinsieme, il risultato è semplicemente l'insieme più grande.
`L = L₁ ∪ L₂ = L₂`

Il problema si è quindi semplificato enormemente. Dobbiamo solo trovare il formalismo a potenza minima per `L₂ = {Σ⁺b³ⁿ | n > 0}`.

Analizziamo `L₂`:
*   Il vincolo `b³ⁿ` significa che la stringa deve terminare con `bbb`, o `bbbbbb`, o `bbbbbbbbb`, etc.
*   Tuttavia, il prefisso `Σ⁺` può essere qualsiasi cosa, purché non sia vuoto. Può anche terminare con delle `b`.
*   **Esempio:** Consideriamo la stringa `abbbbbb`.
    *   Può essere vista come `t="abbb"` e suffisso `b³` (`n=1`). Appartiene a `L₂`.
    *   Può anche essere vista come `t="a"` e suffisso `b⁶` (`n=2`). Appartiene a `L₂`.
*   **L'osservazione finale:** A causa della flessibilità del prefisso `Σ⁺`, l'unica vera condizione che rimane è che la stringa deve iniziare con almeno un carattere (`Σ⁺`) e finire con almeno tre `b`. Qualsiasi cosa in mezzo può essere "assorbita" dal prefisso `Σ⁺`.

Il linguaggio si semplifica ulterior-mente in:
`L = {w | w ∈ Σ⁺ e w termina con bbb}`.
In notazione con espressioni regolari, questo è **`Σ⁺ b³`** o, equivalentemente, **`(a|b)⁺ bbb`**.

Questo è un **linguaggio regolare**.

#### **Passo 4: Scelta del Formalismo a Potenza Minima**

I linguaggi regolari possono essere descritti da:
*   Espressioni Regolari
*   Automi a Stati Finiti (FSA)
*   Grammatiche Regolari (Tipo 3)
*   **Logica Monadica del Primo Ordine (MFO)**

La soluzione sceglie la **MFO**, che è un formalismo a potenza minima corretto per i linguaggi regolari (in particolare, per i linguaggi *aperiodici* o *star-free* come questo).

**Spiegazione della Formula MFO:**
`∃y(y > 0 ∧ b(y) ∧ b(y+1) ∧ b(y+2) ∧ last(y+2))`

*   `∃y`: "Esiste una posizione `y` nella stringa..."
*   `y > 0`: "...che non è l'inizio della stringa". (Questo assicura che il prefisso `Σ⁺` non sia vuoto, perché il suffisso `bbb` inizia da una posizione `y > 0`). *Nota: in realtà questa parte della formula potrebbe essere ridondante se si assume che `y` sia una posizione valida e la stringa abbia almeno 3 caratteri.*
*   `b(y) ∧ b(y+1) ∧ b(y+2)`: "...tale che in posizione `y`, `y+1` e `y+2` ci siano tre 'b' consecutive".
*   `∧ last(y+2)`: "...e la posizione `y+2` è l'ultima posizione della stringa".

Questa formula descrive perfettamente il linguaggio "tutte le stringhe non vuote che terminano con `bbb`".

## Es 10


**Esercizio 1 (8 punti)**

Si definisca un automa a potenza minima per il linguaggio:
`{xcy | x, y ∈ {a, b}⁺, |x| = 2|y| oppure 2|x| = |y|}`

---

### **Passo 1: Analisi e Classificazione del Linguaggio**

1.  **Scomposizione:** Il linguaggio `L` è l'unione di due sotto-linguaggi, `L₁` e `L₂`:
    *   `L₁ = {xcy | x, y ∈ {a, b}⁺, |x| = 2|y|}`
    *   `L₂ = {xcy | x, y ∈ {a, b}⁺, 2|x| = |y|}`
    *(Nota: `x, y ∈ {a, b}⁺` significa che `x` e `y` devono essere non vuoti)*

2.  **Classificazione:**
    *   Entrambi `L₁` e `L₂` richiedono di contare la lunghezza delle stringhe `x` e `y` e di confrontarle secondo una proporzione. Questa operazione di conteggio richiede una memoria illimitata. Pertanto, nessuno dei due linguaggi (e di conseguenza nemmeno la loro unione `L`) può essere **regolare**.
    *   Questo tipo di conteggio può essere gestito da un **Automa a Pila (Pushdown Automaton)**.
    *   La presenza del marcatore centrale `c` fissa il punto di separazione tra `x` e `y`.
    *   Tuttavia, all'inizio, l'automa non sa quale delle due condizioni (`|x|=2|y|` o `2|x|=|y|`) dovrà verificare. Deve "indovinare" la strategia da adottare. Questa "divinazione" richiede **non determinismo**.

3.  **Conclusione:** Il linguaggio `L` è **Libero dal Contesto Non Deterministico**. L'automa a potenza minima che lo riconosce è un **Automa a Pila Non Deterministico (NPDA)**.

---

### **Passo 2: Guida Dettagliata al Disegno dell'Automa (NPDA)**

La strategia dell'automa si basa su una scelta non deterministica iniziale: l'automa "scommette" su quale delle due condizioni la stringa di input soddisferà.

#### **Elementi di Base**

1.  **Stati:** Disegna 6 cerchi. Etichettali `q₀` (iniziale), `q₁` (legge `x` per il caso `|x|=2|y|`), `q₂` (legge `x` per il caso `2|x|=|y|`), `q₃` (legge `y` per il caso `|x|=2|y|`), `q₄` (legge `y` per il caso `2|x|=|y|`), e `q_f` (finale).
2.  **Stato Iniziale:** Disegna una freccia che punta a `q₀`.
3.  **Stato Finale:** Disegna un doppio cerchio attorno a `q_f`.
4.  **Simboli Pila:** Useremo il simbolo `X` come "gettone" di conteggio. `Z₀` è il simbolo iniziale della pila.

#### **Disegno delle Transizioni (Frecce ed Etichette)**

---

##### **FASE 1: La Scelta Non Deterministica Iniziale**

Dallo stato `q₀`, l'automa legge il primo carattere della stringa `x` (che non può essere vuota) e sceglie uno dei due percorsi.

*   **Freccia da `q₀` a `q₁` (Percorso per `|x| = 2|y|`):**
    *   **Etichetta:** `a, Z₀ / XZ₀` e `b, Z₀ / XZ₀`
    *   **Significato:** "Leggi il primo carattere (`a` o `b`) di `x`. Spingi **un** gettone `X` sulla pila. Ora segui il percorso per verificare la condizione `|x| = 2|y|`."

*   **Freccia da `q₀` a `q₂` (Percorso per `2|x| = |y|`):**
    *   **Etichetta:** `a, Z₀ / XXZ₀` e `b, Z₀ / XXZ₀`
    *   **Significato:** "Leggi il primo carattere (`a` o `b`) di `x`. Spingi **due** gettoni `X` sulla pila. Ora segui il percorso per verificare la condizione `2|x| = |y|`."

---

##### **FASE 2: Lettura del resto di `x`**

*   **Freccia da `q₁` che torna su se stesso (loop):**
    *   **Etichetta:** `a, X / XX` e `b, X / XX`
    *   **Significato:** "Se sei sul percorso `|x|=2|y|`, per ogni carattere letto in `x` (dopo il primo), aggiungi **un** gettone `X` alla pila."

*   **Freccia da `q₂` che torna su se stesso (loop):**
    *   **Etichetta:** `a, X / XXX` e `b, X / XXX`
    *   **Significato:** "Se sei sul percorso `2|x|=|y|`, per ogni carattere letto in `x` (dopo il primo), aggiungi **due** gettoni `X` alla pila."

---

##### **FASE 3: Lettura del marcatore `c` e cambio di fase**

*   **Freccia da `q₁` a `q₃`:**
    *   **Etichetta:** `c, X / X`
    *   **Significato:** "Quando leggi il marcatore `c`, passa alla fase di lettura di `y` per il caso `|x|=2|y|`. Lascia la pila com'è."

*   **Freccia da `q₂` a `q₄`:**
    *   **Etichetta:** `c, X / X`
    *   **Significato:** "Quando leggi il marcatore `c`, passa alla fase di lettura di `y` per il caso `2|x|=|y|`. Lascia la pila com'è."

---

##### **FASE 4: Lettura di `y` e Riscontro sulla Pila**

*   **Freccia da `q₃` che torna su se stesso (loop):**
    *   **Etichetta:** `a, X / ε` e `b, X / ε`
    *   **Significato:** "Se sei sul percorso `|x|=2|y|`, per ogni carattere letto in `y`, devi estrarre (pop) **due** gettoni `X` dalla pila." (Questo richiede un piccolo trucco: si può fare in due stati, ma per semplicità si può scrivere `a, XX / ε` che non è standard, o usare un automa come quello della soluzione dell'esame). Per un disegno standard, si fa:
        *   `q₃ → q₃_bis`: `a, X / ε` e `b, X / ε`
        *   `q₃_bis → q₃`: `ε, X / ε`
    *   In breve: Per ogni carattere di `y`, rimuovi due `X`.

*   **Freccia da `q₄` che torna su se stesso (loop):**
    *   **Etichetta:** `a, X / ε` e `b, X / ε`
    *   **Significato:** "Se sei sul percorso `2|x|=|y|`, per ogni carattere letto in `y`, estrai (pop) **un** gettone `X` dalla pila."

---

##### **FASE 5: Accettazione**

*   **Freccia da `q₃` allo stato finale `q_f`:**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Se, dopo aver letto `y`, la pila è vuota (contiene solo `Z₀`), significa che il conteggio `|x|=2|y|` era corretto. Accetta."

*   **Freccia da `q₄` allo stato finale `q_f`:**
    *   **Etichetta:** `ε, Z₀ / Z₀`
    *   **Significato:** "Se, dopo aver letto `y`, la pila è vuota, significa che il conteggio `2|x|=|y|` era corretto. Accetta."

**Nota:** L'automa nella soluzione dell'esame usa una strategia leggermente diversa ma equivalente per implementare il "rimuovi due gettoni", che è molto comune in questi esercizi. La logica di base del non determinismo e del conteggio proporzionale rimane la stessa.

## ES 11

Si considerino i linguaggi `L_s = {aⁿb²ᵐ | n, m ≥ 0}` e `L_d = {ε, a, aa}`.
Si realizzi un traduttore a potenza minima che calcoli la seguente traduzione da `L_s` a `L_d`:

`τ(aⁿb²ᵐ) = aⁿ mod 3`

dove `x mod y` indica il resto della divisione intera `x/y`.

---

### **Passo 1: Analisi del Problema e Scelta del Formalismo**

1.  **Analisi della Traduzione:** La funzione `τ` prende una stringa in input e ne produce una in output.
    *   La parte `b²ᵐ` dell'input (un numero pari di `b`) viene **completamente ignorata** ai fini dell'output. Il traduttore deve solo assicurarsi che la stringa di input sia valida (cioè che le `b` siano in numero pari), ma non userà le `b` per costruire l'output.
    *   L'output dipende **esclusivamente** dal numero `n` di `a` iniziali.
    *   La regola di calcolo è `n mod 3`. Vediamo i possibili risultati:
        *   Se `n` è un multiplo di 3 (es. 0, 3, 6, ...), `n mod 3 = 0`. L'output è `a⁰`, cioè la stringa vuota `ε`.
        *   Se `n` ha resto 1 se diviso per 3 (es. 1, 4, 7, ...), `n mod 3 = 1`. L'output è `a¹`, cioè `a`.
        *   Se `n` ha resto 2 se diviso per 3 (es. 2, 5, 8, ...), `n mod 3 = 2`. L'output è `a²`, cioè `aa`.

2.  **Scelta del Formalismo a Potenza Minima:**
    *   Il traduttore deve eseguire due compiti principali: contare le `a` modulo 3 e verificare che il numero di `b` sia pari.
    *   Entrambi questi compiti ("contare modulo k" e "verificare la parità") possono essere svolti da un **Automa a Stati Finiti (FSA)**, che ha una memoria finita.
    *   Poiché la macchina deve produrre un output, il formalismo corretto è la versione "con output" di un FSA, ovvero un **Traduttore a Stati Finiti (Finite State Transducer - FST)**. Questo è il modello a potenza minima in grado di eseguire il compito.

*(Nota: Il diagramma nella soluzione fornita è un FST, anche se la sua notazione è un po' confusa e potenzialmente errata. La guida seguente costruirà un FST corretto e più facile da capire).*

---

### **Passo 2: Guida al Disegno del Traduttore a Stati Finiti (FST)**

La nostra strategia sarà:
1.  Usare degli stati per tenere traccia del conteggio delle `a` (modulo 3).
2.  Passare a un'altra serie di stati per verificare la parità delle `b`.
3.  Produrre l'output finale solo alla fine, quando la stringa è stata letta completamente e validata.

#### **Elementi di Base**

*   **Stati:** Disegneremo 6 stati: `q₀`, `q₁`, `q₂` per contare le `a`, e `q_even`, `q_odd` per contare le `b`. Infine, uno stato finale `q_f`.
*   **Stato Iniziale:** `q₀`.
*   **Stato Finale:** `q_f`.
*   **Notazione delle Frecce:** Useremo lo standard `input / output`.

#### **Disegno delle Transizioni (Frecce e Loro Etichette)**

**Fase 1: Lettura e Conteggio delle `a`**

*   **Disegna gli stati `q₀`, `q₁`, `q₂` in un ciclo.** `q₀` è lo stato iniziale e rappresenta `n mod 3 = 0`. `q₁` rappresenta `n mod 3 = 1`, e `q₂` rappresenta `n mod 3 = 2`.
*   **Freccia da `q₀` a `q₁`:**
    *   **Etichetta:** `a / ε`
    *   **Significato:** "Leggi una `a` (ora `n=1`), non produrre output per ora, e vai allo stato che ricorda `n mod 3 = 1`."
*   **Freccia da `q₁` a `q₂`:**
    *   **Etichetta:** `a / ε`
    *   **Significato:** "Leggi un'altra `a` (ora `n=2`), non produrre output, e vai allo stato che ricorda `n mod 3 = 2`."
*   **Freccia da `q₂` a `q₀`:**
    *   **Etichetta:** `a / ε`
    *   **Significato:** "Leggi un'altra `a` (ora `n=3`), non produrre output, e torna allo stato che ricorda `n mod 3 = 0`."

**Fase 2: Transizione alla Lettura delle `b`**

La stringa di input può passare dalle `a` alle `b` in uno qualsiasi dei tre stati di conteggio.

*   **Disegna gli stati `q_even` e `q_odd`** per la parte delle `b`.
*   **Freccia da `q₀` a `q_even`:**
    *   **Etichetta:** `ε / ε`
    *   **Significato:** "Senza leggere input, passa dalla fase 'a' (con `n mod 3 = 0`) alla fase 'b'."
*   **Freccia da `q₁` a `q_even`:**
    *   **Etichetta:** `ε / a`
    *   **Significato:** "Senza leggere input, passa dalla fase 'a' (con `n mod 3 = 1`) alla fase 'b', **producendo l'output finale 'a'**."
*   **Freccia da `q₂` a `q_even`:**
    *   **Etichetta:** `ε / aa`
    *   **Significato:** "Senza leggere input, passa dalla fase 'a' (con `n mod 3 = 2`) alla fase 'b', **producendo l'output finale 'aa'**."

**Fase 3: Verifica della Parità delle `b`**

*   **Freccia da `q_even` a `q_odd`:**
    *   **Etichetta:** `b / ε`
    *   **Significato:** "Leggi una `b`, non produrre output, e vai allo stato che ricorda un numero dispari di `b`."
*   **Freccia da `q_odd` a `q_even`:**
    *   **Etichetta:** `b / ε`
    *   **Significato:** "Leggi un'altra `b`, non produrre output, e torna allo stato che ricorda un numero pari di `b`."

**Fase 4: Accettazione Finale**

*   **Disegna lo stato finale `q_f` con un doppio cerchio.**
*   L'input è valido se, dopo aver letto tutta la stringa, il numero di `b` è pari. Lo stato `q_even` rappresenta questa condizione.
*   **Freccia da `q_even` a `q_f`:**
    *   **Etichetta:** `ε / ε`
    *   **Significato:** "Se sei nello stato `q_even` e l'input è terminato, la stringa è valida. Passa allo stato finale."

*(Nota: in molti formalismi, uno stato può essere direttamente finale. In questo disegno, `q_even` potrebbe essere lo stato finale, semplificando ulteriormente il diagramma).*

Ecco una rappresentazione grafica del risultato, semplificata rendendo `q_even` uno stato finale:

## ES 12
Certamente! Analizziamo questo esercizio, che è un ottimo esempio di come espressioni di linguaggio apparentemente complesse possano essere semplificate per rivelare la loro vera natura. La soluzione fornita è corretta nel suo risultato finale, anche se la formula MFO presentata è un po' confusa.

Ecco una spiegazione dettagliata passo dopo passo.

### **Traccia dell'Esercizio**

Si considerino i seguenti linguaggi sull'alfabeto `A = {a, b, c}`:
*   `L1 = A*b \ (A*(A \ {a})*A*b)`
*   `L2 = A* \ (A*(A \ {b})*A)`
*   `L3 = L1 L2`

dove `*` è la stella di Kleene, `\` è la differenza insiemistica e la giustapposizione `L1 L2` è la concatenazione.

Utilizzare un formalismo a potenza minima (tra tutti quelli visti a lezione) che caratterizzi il linguaggio `L3`.

---

### **Passo 1: Semplificazione di `L1`**

La definizione di `L1` è `A*b \ (A*(A \ {a})*A*b)`. Scomponiamola:

*   **`A*b`**: Questo è l'insieme di tutte le stringhe sull'alfabeto `{a, b, c}` che terminano con il carattere `b`.
*   **`A \ {a}`**: Questo è l'insieme dei caratteri in `A` che non sono `a`, ovvero `{b, c}`.
*   **`(A*(b|c)*A*b)`**: Questa è la parte che sottraiamo. Descrive le stringhe che (1) terminano con `b` e (2) contengono almeno un `b` o un `c` da qualche parte. *Questa interpretazione è complessa, c'è un modo più semplice di leggerla.*

La vera intenzione di questa scrittura è descrivere una proprietà dei caratteri *prima* della `b` finale. Leggiamola così: "Prendiamo tutte le stringhe che finiscono in `b` (`A*b`) e togliamo quelle che hanno un carattere non-'a' (`b` o `c`) in qualsiasi posizione". Questo non è del tutto corretto.

L'interpretazione più logica (e quella che porta alla soluzione) è:
"Prendiamo tutte le stringhe che finiscono in `b` (`A*b`) e togliamo quelle per cui **esiste un carattere che non è 'a'**." Questo è equivalente a dire che **tutti i caratteri devono essere 'a' o 'b' e che nessun carattere `b` o `c` deve apparire**. In pratica, togliamo tutte le stringhe che contengono `b` o `c`.

Una lettura più precisa è: togliamo le stringhe che contengono un carattere non-'a' (`b` o `c`). Se una stringa in `A*b` contiene un `b` prima della `b` finale, o contiene un `c`, viene rimossa. Le uniche stringhe che rimangono sono quelle composte solo da `a` seguite da una `b`.

**Conclusione per `L1`:** `L1 = a*b`.

### **Passo 2: Semplificazione di `L2`**

La definizione di `L2` è `A* \ (A*(A \ {b})*A)`. La logica è la stessa:

*   **`A*`**: L'insieme di tutte le stringhe possibili.
*   **`A \ {b}`**: L'insieme dei caratteri `{a, c}`.
*   **`(A*(a|c)*A)`**: Questo descrive tutte le stringhe che contengono almeno un `a` o un `c`.
*   **La Differenza:** Se dall'insieme di tutte le stringhe (`A*`) togliamo tutte quelle che contengono `a` o `c`, cosa rimane? Rimangono solo le stringhe composte **esclusivamente da `b`**.

**Conclusione per `L2`:** `L2 = b*`.

### **Passo 3: Calcolo e Classificazione di `L3`**

Ora dobbiamo calcolare `L3 = L1 L2`, che è la concatenazione.

*   `L3 = (a*b) ⋅ (b*)`
*   Questo significa "una stringa da `L1`" seguita da "una stringa da `L2`".
*   Una stringa da `L1` è una sequenza di `a` (anche zero) che finisce con una `b`.
*   Una stringa da `L2` è una sequenza di `b` (anche zero).
*   Concatenandole, otteniamo una sequenza di `a`, seguita da una `b`, seguita da altre `b`. Questo è equivalente a una sequenza di `a` seguita da **almeno una `b`**.

**Conclusione per `L3`:** `L3 = a*b⁺`.

Questo è un **linguaggio regolare**.

### **Passo 4: Scelta del Formalismo a Potenza Minima**

La soluzione afferma che `L3` è "star-free". Un linguaggio è **star-free** se può essere descritto da un'espressione regolare che non usa la stella di Kleene (`*` o `+`), ma può usare il complemento. La classe dei linguaggi star-free è una sotto-classe dei linguaggi regolari.

Un teorema fondamentale afferma che un linguaggio è **star-free se e solo se è definibile nella Logica Monadica del Primo Ordine (MFO)**.

Poiché `a*b⁺` è effettivamente un linguaggio star-free, il formalismo a potenza minima per caratterizzarlo è proprio la **MFO**.

#### **Analisi (e correzione) della Formula MFO**

La formula fornita nella soluzione è molto confusa e probabilmente errata. Una formula MFO corretta e molto più chiara per `L3 = a*b⁺` sarebbe:

**`∃x(last(x) ∧ b(x)) ∧ ¬∃y,z(b(y) ∧ a(z) ∧ y < z)`**

Spieghiamola:
1.  **`∃x(last(x) ∧ b(x))`**: "Esiste una posizione `x` che è l'ultima posizione della stringa (`last(x)`) E il carattere in quella posizione è una `b` (`b(x)`)." Questo garantisce che la stringa termini con `b`.
2.  **`¬∃y,z(b(y) ∧ a(z) ∧ y < z)`**: "NON (`¬`) esiste una coppia di posizioni `y` e `z` tali che in `y` ci sia una `b`, in `z` ci sia una `a`, e `y` venga prima di `z` (`y < z`)." Questo garantisce che una volta che appare una `b`, non possono più apparire delle `a`.

Questa formula descrive in modo preciso ed elegante il linguaggio `a*b⁺` ed è il formalismo a potenza minima richiesto.
# FUNZIONI CALCOLABILI(DECIDIBILI)

## Es1

1.  Si dica se la seguente funzione è calcolabile, barrando la casella opportuna e motivando la risposta:
    $g(x,y) = \begin{cases} 1 & \text{se } f_y(x) = \perp \\ 2 & \text{altrimenti} \end{cases}$
    *(Dove $f_y(x) = \perp$ significa che la y-esima funzione calcolabile, calcolata sull'input x, non termina/non è definita).*

2.  Si consideri ora il problema di stabilire se una generica macchina di Turing calcoli la funzione g. Tale problema è decidibile? semi-decidibile? deciso?

---

### Spiegazione e Svolgimento Passo Passo

#### **Domanda 1: La funzione `g` è calcolabile?**

**Obiettivo:** Stabilire se esiste un algoritmo (una Macchina di Turing) che possa calcolare la funzione `g` per ogni coppia di input `(x, y)`.

**Ragionamento:**

1.  **Cosa fa la funzione `g`?**
    La funzione `g(x, y)` ci chiede di rispondere a una domanda sul comportamento della macchina di Turing numero `y` quando riceve l'input `x`.
    *   Se la macchina `y` sull'input `x` **non termina** (va in loop infinito), allora `g` deve restituire `1`.
    *   Se la macchina `y` sull'input `x` **termina** (si arresta e produce un output), allora `g` deve restituire `2`.

2.  **Collegamento con il Problema dell'Arresto (Halting Problem):**
    Il Problema dell'Arresto è il problema di determinare, dati un programma (una macchina `y`) e un input (`x`), se quel programma terminerà o andrà in loop. Questo problema è il più famoso esempio di problema **indecidibile**: non esiste un algoritmo universale in grado di risolverlo per tutti i possibili programmi e input.

3.  **La Riduzione dal Problema dell'Arresto:**
    Per dimostrare che `g` non è calcolabile, usiamo una tecnica chiamata "riduzione". Mostriamo che se fossimo in grado di calcolare `g`, allora saremmo anche in grado di risolvere il Problema dell'Arresto. Poiché sappiamo che quest'ultimo è irrisolvibile, la nostra ipotesi iniziale (che `g` sia calcolabile) deve essere falsa.

    Ecco come costruire un risolutore per il Problema dell'Arresto, supponendo di avere un algoritmo `Calcola_g(x, y)`:

    ```
    Algoritmo Risolvi_Arresto(x, y):
      // Supponiamo esista un algoritmo che calcola g(x, y)
      risultato_g = Calcola_g(x, y)

      // Analizziamo il risultato
      if risultato_g == 1:
        // g restituisce 1 quando f_y(x) non termina
        return "NON TERMINA"
      else: // risultato_g sarà 2
        // g restituisce 2 quando f_y(x) termina
        return "TERMINA"
    ```

4.  **Conclusione:**
    L'algoritmo `Risolvi_Arresto` che abbiamo appena descritto sarebbe un algoritmo che decide il Problema dell'Arresto. Ma un tale algoritmo non può esistere. L'unica ipotesi che abbiamo fatto è stata l'esistenza di `Calcola_g`. Pertanto, questa ipotesi deve essere errata.

**Soluzione (Punto 1):**
La funzione `g` **non è calcolabile**. Se lo fosse, potremmo usarla per decidere il Problema dell'Arresto, che è noto essere indecidibile. La capacità di calcolare `g(x,y)` è equivalente alla capacità di sapere se la macchina `y` termina sull'input `x`.

---

#### **Domanda 2: Decidibilità del problema "una macchina di Turing calcola `g`"**

**Obiettivo:** Abbiamo un nuovo problema. L'input è la descrizione di una generica Macchina di Turing `M`. La domanda è: "La macchina `M` calcola la funzione `g`?". Dobbiamo stabilire se questo problema è decidibile, semi-decidibile, ecc.

**Ragionamento:**

1.  **Partiamo dal risultato precedente:** Dal punto 1, abbiamo stabilito in modo definitivo che la funzione `g` **non è calcolabile**.

2.  **Cosa significa "non calcolabile"?** Per definizione, una funzione non calcolabile è una funzione per la quale **non esiste alcuna Macchina di Turing** in grado di calcolarla.

3.  **Applichiamo questa conoscenza al problema:**
    Ci viene data una macchina di Turing `M` qualsiasi e ci viene chiesto: "Questa `M` calcola `g`?".
    Poiché *nessuna* macchina di Turing può calcolare `g`, la risposta a questa domanda sarà **sempre e comunque "No"**, indipendentemente da quale macchina `M` ci venga fornita.

4.  **Costruzione di un algoritmo di decisione:**
    Possiamo quindi creare un algoritmo semplicissimo per risolvere questo problema:

    ```
    Algoritmo Decide_se_M_calcola_g(M):
      // M è la descrizione di una macchina di Turing
      return "No"
    ```
    Questo algoritmo è banale: ignora l'input e risponde sempre "No".

5.  **Analisi dell'algoritmo:**
    *   **Termina sempre?** Sì, immediatamente.
    *   **Dà sempre la risposta corretta?** Sì, perché la risposta corretta è sempre "No".

6.  **Conclusione sulla decidibilità:**
    Poiché esiste un algoritmo che termina sempre e fornisce la risposta corretta, il problema è **decidibile**.

    *   **È semi-decidibile?** Sì. Ogni problema decidibile è anche semi-decidibile. Un problema semi-decidibile richiede un algoritmo che termini almeno sulle istanze positive (quelle la cui risposta è "Sì"). Poiché non ci sono istanze positive, questa condizione è banalmente soddisfatta.

    *   **È deciso?** Sì. Il termine "deciso" in questo contesto significa che la risposta è determinata e fissa. In questo caso, è **deciso negativamente**, perché la risposta è sempre "No".

**Soluzione (Punto 2):**
Il problema è **decidibile** (e quindi anche **semi-decidibile**). Poiché la funzione `g` non è calcolabile, nessuna Macchina di Turing può calcolarla. Di conseguenza, per qualsiasi macchina `M` data in input, la risposta alla domanda "M calcola g?" è sempre "No". Un algoritmo che risponde sempre "No" risolve correttamente e in tempo finito questo problema.

Certamente! Analizziamo questo esercizio che esplora i limiti fondamentali della computabilità, contrapponendo il mondo dei programmi generici a quello più strutturato degli automi a stati finiti.

Certamente! Questo è un ottimo esercizio per comprendere a fondo la differenza tra decidibilità, semi-decidibilità e calcolabilità. Analizziamo ogni funzione passo dopo passo.

### Concetti Preliminari Fondamentali

Prima di iniziare, chiariamo alcuni concetti chiave:

*   **Funzione Calcolabile:** Una funzione è calcolabile se esiste un algoritmo (una Macchina di Turing) che, per ogni input su cui la funzione è definita, termina e restituisce il valore corretto. Se la funzione è definita ovunque (totale), l'algoritmo deve terminare sempre. Se la funzione è parziale (non definita su alcuni input, indicati con ⊥), l'algoritmo deve non terminare per quegli input.
*   **Problema Decidibile:** Un problema "sì/no" è decidibile se esiste un algoritmo che termina sempre e fornisce la risposta corretta. È equivalente a dire che la sua funzione caratteristica (che restituisce 1 per "sì" e 0 per "no") è totale e calcolabile.
*   **Problema Semi-decidibile:** Un problema "sì/no" è semi-decidibile se esiste un algoritmo che termina e risponde "sì" per tutte le istanze positive. Per le istanze negative, può terminare e rispondere "no" oppure non terminare affatto.
*   **Teorema di Rice:** Qualsiasi proprietà non banale delle funzioni calcolabili è indecidibile. Una proprietà è "non banale" se esiste almeno una funzione che la possiede e almeno una che non la possiede.

---

## Es2

Per ciascuna delle seguenti funzioni si chiarisca, barrando la casella corrispondente e motivando adeguatamente la risposta, se è calcolabile.

1.  $h_1(x,y) = \begin{cases} 1 & \text{se } f_y(x) > 1 \\ 0 & \text{altrimenti} \end{cases}$
2.  $h_2(x,y) = \begin{cases} 1 & \text{se } f_y(x) > 1 \\ \perp & \text{altrimenti} \end{cases}$
3.  $h_3(x,y) = \begin{cases} \perp & \text{se } f_y(x) > 1 \\ 0 & \text{altrimenti} \end{cases}$
4.  $h_4(x,y) = \begin{cases} \perp & \text{se } f_y(x) > 1 \\ \perp & \text{altrimenti} \end{cases}$

*(Nota: $f_y(x)$ è la funzione calcolata dalla y-esima Macchina di Turing con input x. $\perp$ significa che la macchina non termina).*

---

### Analisi delle Funzioni

#### 1. Funzione `h1` (Totale, richiede una decisione)

**Funzione:** $h_1(x,y) = \begin{cases} 1 & \text{se } f_y(x) > 1 \\ 0 & \text{altrimenti} \end{cases}$

*   **Natura:** Questa è una funzione **totale**. Deve sempre restituire 0 o 1.
*   **Problema Equivalente:** Calcolare `h1` è equivalente a **decidere** il problema "La funzione $f_y$ sull'input $x$ termina con un valore maggiore di 1?".
*   **Motivazione:** Per poter restituire `0` nel caso "altrimenti", il nostro algoritmo deve essere in grado di gestire tutte le situazioni in cui la condizione non è vera. Queste situazioni sono:
    1.  $f_y(x)$ termina con un valore ≤ 1.
    2.  $f_y(x)$ non termina affatto (cioè $f_y(x) = \perp$).
    Un algoritmo per `h1` dovrebbe saper distinguere il caso "termina con valore > 1" da *entrambi* questi altri casi. In particolare, dovrebbe essere in grado di determinare se $f_y(x)$ non termina, per poter restituire `0`. Questo è il Problema dell'Arresto, che è indecidibile.
*   **Dimostrazione con Teorema di Rice:** La proprietà P = "la funzione calcolata restituisce un valore > 1 per l'input x" è una proprietà non banale delle funzioni calcolabili (ad es. la funzione `f(a) = 2` la possiede, la funzione `f(a) = 0` non la possiede). Pertanto, per il Teorema di Rice, è indecidibile.
*   **Conclusione:** `h1` **non è calcolabile**. Un algoritmo che calcola `h1` sarebbe un algoritmo che decide un problema indecidibile.

---

#### 2. Funzione `h2` (Parziale, richiede il riconoscimento dei "sì")

**Funzione:** $h_2(x,y) = \begin{cases} 1 & \text{se } f_y(x) > 1 \\ \perp & \text{altrimenti} \end{cases}$

*   **Natura:** Questa è una funzione **parziale**. È definita solo se la condizione è vera.
*   **Problema Equivalente:** Calcolare `h2` è equivalente a **semi-decidere** il problema "La funzione $f_y$ sull'input $x$ termina con un valore maggiore di 1?".
*   **Motivazione:** Possiamo costruire un algoritmo che simuli il comportamento di `h2`? Proviamoci:
    1.  Usa una Macchina di Turing Universale per simulare l'esecuzione di $f_y(x)$.
    2.  **Se la simulazione termina:** controlla il valore del risultato.
        *   Se il risultato è `> 1`, l'algoritmo si ferma e restituisce `1`. **Corretto**.
        *   Se il risultato è `≤ 1`, l'algoritmo entra deliberatamente in un loop infinito (es. `while(true){}`). In questo modo, non termina. **Corretto**.
    3.  **Se la simulazione non termina:** l'algoritmo che simula, di conseguenza, non terminerà. **Corretto**.
*   **Conclusione:** `h2` **è calcolabile**. L'algoritmo di simulazione appena descritto calcola esattamente la funzione `h2`.

---

#### 3. Funzione `h3` (Parziale, richiede il riconoscimento dei "no")

**Funzione:** $h_3(x,y) = \begin{cases} \perp & \text{se } f_y(x) > 1 \\ 0 & \text{altrimenti} \end{cases}$

*   **Natura:** Questa è una funzione **parziale**, complementare a `h2`.
*   **Problema Equivalente:** Calcolare `h3` è equivalente a **semi-decidere il complemento** del problema precedente.
*   **Motivazione:**
    1.  Dal punto 1, sappiamo che il problema P = "$f_y(x) > 1$" è **indecidibile**.
    2.  Dal punto 2, sappiamo che lo stesso problema P è **semi-decidibile**.
    3.  Esiste un teorema fondamentale (Teorema di Post) che afferma: un problema è decidibile se e solo se sia esso che il suo complemento sono semi-decidibili.
    4.  Poiché P è indecidibile ma semi-decidibile, il suo complemento **non può essere semi-decidibile**. Se lo fosse, P sarebbe decidibile, il che è una contraddizione.
    5.  La funzione `h3` è definita (restituisce 0) esattamente sui casi che appartengono al complemento di P. Un algoritmo che calcola `h3` sarebbe un semi-decisore per il complemento di P.
*   **Conclusione:** `h3` **non è calcolabile**. La sua calcolabilità implicherebbe che il complemento di un problema semi-decidibile e indecidibile sia a sua volta semi-decidibile, il che è impossibile.

---

#### 4. Funzione `h4` (Costante)

**Funzione:** $h_4(x,y) = \begin{cases} \perp & \text{se } f_y(x) > 1 \\ \perp & \text{altrimenti} \end{cases}$

*   **Natura:** A prima vista sembra complessa, ma osserviamo l'output.
*   **Motivazione:** Indipendentemente dal valore di `x`, di `y` e dal risultato di $f_y(x)$, la funzione `h4` restituisce **sempre** $\perp$ (non termina). La condizione è irrilevante. Si tratta della funzione costantemente non definita.
*   **Algoritmo:** Esiste un algoritmo che la calcola? Sì, uno molto semplice:
    ```
    Algoritmo_per_h4(x, y):
      while(true) {
        // Loop infinito
      }
    ```
    Questo algoritmo non termina mai, per nessun input, che è esattamente il comportamento richiesto dalla funzione `h4`.
*   **Conclusione:** `h4` **è calcolabile**.
Certamente! Questo è un classico esercizio di teoria della computabilità che utilizza la tecnica della **riduzione** per dimostrare l'indecidibilità. Analizziamolo in dettaglio, spiegando il ragionamento che sta dietro ogni passaggio.

## Es 3

Data una funzione f(x), il suo dominio Df è dato dall’insieme di tutti quei valori in input tali che il risultato è definito: Df = {x | f(x) ≠ ⊥}. Similmente, il codominio (range) di f, Rf, è dato dall’insieme di quei valori y tali per cui esiste almeno un input x per cui vale f(x) = y, ovvero Rf = {y | ∃x f(x) = y}.

1.  È decidibile il problema di stabilire se, date due generiche macchine di Turing Mx e My, le corrispondenti funzioni da loro calcolate fx ed fy sono tali che il dominio di fx è un sottoinsieme del dominio di fy?
2.  È decidibile il problema di stabilire se, date due generiche macchine di Turing Mx e My, le corrispondenti funzioni da loro calcolate fx ed fy sono tali che il codominio di fx è un sottoinsieme del codominio di fy?

*(Nota: nella traccia c'è un piccolo errore di battitura, il dominio è l'insieme dove la funzione è definita, f(x) ≠ ⊥, non il contrario).*

---

### Spiegazione e Svolgimento Passo Passo

La strategia generale per risolvere questi problemi è la seguente:
1.  Prendere il problema generale che ci viene posto.
2.  Semplificarlo **fissando una delle due macchine** a un caso specifico e molto semplice.
3.  Mostrare che, facendo questa semplificazione, il problema generale si "riduce" a un altro problema che **sappiamo già essere indecidibile** (come il problema della totalità o dell'equivalenza alla funzione vuota).
4.  Concludere che se il problema generale fosse decidibile, allora anche il problema noto sarebbe decidibile, il che è una contraddizione. Pertanto, il problema generale deve essere indecidibile.

---

#### **Domanda 1: Il dominio di fx è un sottoinsieme del dominio di fy? (Dfₓ ⊆ Dfᵧ)**

**Obiettivo:** Vogliamo decidere se ogni input che fa terminare la macchina `Mx` fa terminare anche la macchina `My`.

**Ragionamento (seguendo la soluzione):**

1.  **Semplifichiamo il problema:** Invece di considerare due macchine generiche `Mx` e `My`, fissiamo `Mx` in modo che sia una macchina semplicissima di cui conosciamo perfettamente il dominio. La scelta più utile è una macchina che calcola una **funzione totale**, cioè una funzione che termina *sempre*, per ogni input.
    *   **Esempio:** Sia `Mx` una macchina che calcola la funzione costante `f_x(input) = 1`.

2.  **Analizziamo il dominio di questa `Mx` specifica:** Poiché `f_x` è totale, il suo dominio `Df_x` è l'insieme di **tutti i possibili input**. Chiamiamo questo insieme U.
    *   `Df_x = U` (l'universo di tutti gli input).

3.  **Riformuliamo la domanda originale:** La domanda originale era "È `Df_x` ⊆ `Df_y`?". Con la nostra `Mx` specifica, la domanda diventa:
    *   "È `U` ⊆ `Df_y`?"

4.  **Capiamo cosa significa questa nuova domanda:** L'insieme di tutti gli input `U` può essere un sottoinsieme del dominio di `f_y` solo se il dominio di `f_y` è anch'esso l'insieme di tutti gli input. In altre parole, `U ⊆ Df_y` è vero se e solo se `Df_y = U`.
    *   Dire che `Df_y = U` significa che la funzione `f_y` è **totale** (termina per ogni input).

5.  **La Riduzione:** Abbiamo dimostrato che se fossimo in grado di risolvere il problema generale ("`Df_x` ⊆ `Df_y`?"), potremmo risolvere anche il problema "La funzione `f_y` è totale?". Per farlo, basterebbe:
    *   Prendere la macchina `My` di cui vogliamo testare la totalità.
    *   Creare la nostra macchina `Mx` che calcola la funzione costante 1.
    *   Dare `Mx` e `My` in pasto al nostro ipotetico algoritmo che decide l'inclusione dei domini.
    *   Se l'algoritmo risponde "Sì", significa che `f_y` è totale. Se risponde "No", non lo è.

6.  **Conclusione:** Abbiamo "ridotto" il problema dell'inclusione dei domini al **Problema della Totalità**. Il Problema della Totalità è notoriamente **indecidibile**. Poiché abbiamo dimostrato che un risolutore per il nostro problema implicherebbe un risolutore per un problema impossibile, concludiamo che il nostro problema originale **non è decidibile**.

---

#### **Domanda 2: Il codominio di fx è un sottoinsieme del codominio di fy? (Rfₓ ⊆ Rfᵧ)**

**Obiettivo:** Vogliamo decidere se ogni valore di output prodotto da `Mx` può essere prodotto anche da `My`.

**Ragionamento (seguendo la soluzione):**

1.  **Semplifichiamo il problema:** Anche qui, fissiamo una delle macchine. Questa volta, la soluzione fissa `My` in modo che sia una macchina di cui conosciamo perfettamente il codominio. La scelta più utile è una macchina che non produce **nessun output**.
    *   **Esempio:** Sia `My` una macchina che non termina mai, per nessun input. Ad esempio, `f_y(input) = ⊥` per ogni input.

2.  **Analizziamo il codominio di questa `My` specifica:** Poiché `f_y` non produce mai un risultato, non ci sono valori nel suo codominio. Il suo codominio `Rf_y` è l'**insieme vuoto (∅)**.
    *   `Rf_y = ∅`.

3.  **Riformuliamo la domanda originale:** La domanda era "È `Rf_x` ⊆ `Rf_y`?". Con la nostra `My` specifica, la domanda diventa:
    *   "È `Rf_x` ⊆ `∅`?"

4.  **Capiamo cosa significa questa nuova domanda:** L'unico insieme che può essere un sottoinsieme dell'insieme vuoto è l'insieme vuoto stesso. Quindi, la domanda è vera se e solo se `Rf_x = ∅`.
    *   Dire che `Rf_x = ∅` significa che la funzione `f_x` non produce **mai** un output. Questo accade se e solo se `Mx` non termina per nessun input, cioè se `f_x` è la **funzione indefinita ovunque**.

5.  **La Riduzione:** Abbiamo dimostrato che se fossimo in grado di risolvere il problema generale ("`Rf_x` ⊆ `Rf_y`?"), potremmo risolvere anche il problema "La funzione `f_x` è la funzione indefinita ovunque?". Per farlo, basterebbe:
    *   Prendere la macchina `Mx` di cui vogliamo testare questa proprietà.
    *   Creare la nostra macchina `My` che non termina mai.
    *   Dare `Mx` e `My` in pasto al nostro ipotetico algoritmo che decide l'inclusione dei codomini.
    *   Se l'algoritmo risponde "Sì", significa che `f_x` è la funzione indefinita ovunque. Se risponde "No", non lo è.

6.  **Conclusione:** Abbiamo "ridotto" il problema dell'inclusione dei codomini al problema di stabilire se una macchina calcola la **funzione indefinita ovunque**. Questo è un problema **indecidibile**, come si può dimostrare direttamente con il **Teorema di Rice**: la proprietà "essere la funzione indefinita ovunque" è non banale (alcune funzioni la possiedono, altre no). Poiché il nostro problema generale può essere usato per risolvere un problema indecidibile, concludiamo che anche il problema originale **non è decidibile**.

## Es 4

1.  Si consideri la seguente funzione e si dica se essa sia calcolabile o meno, motivando la risposta:
    $h(x,y) = \begin{cases} 1 & \text{se } f_{y+1}(x+1) > f_y(x) \\ \perp & \text{altrimenti} \end{cases}$
2.  Si consideri la seguente funzione e si dica se essa sia calcolabile o meno, motivando la risposta:
    $h'(x, y) = \begin{cases} 0 & \text{se } f_{y+1}(x+1) \le f_y(x) \\ \perp & \text{altrimenti} \end{cases}$
3.  Si considerino due generiche MT a nastro singolo, Mi e Mj. Si dica se è decidibile il problema di stabilire se $f_i(i) \le f_j(j)$.
    *Suggerimento: si può assumere che l’enumerazione E delle MT inizi con la macchina che calcola la funzione $f_0(x) = x$.*

---

### Spiegazione e Svolgimento Passo Passo

#### **Domanda 1: Calcolabilità di h(x, y)**

**Obiettivo:** Dobbiamo stabilire se esiste un algoritmo (una Macchina di Turing) che si comporta esattamente come `h`.

**Analisi della funzione `h`:**
*   `h` è una funzione **parziale**. Deve restituire un valore (`1`) solo se una condizione specifica è soddisfatta.
*   La condizione è `$f_{y+1}(x+1) > f_y(x)$`. Per verificare questa condizione, entrambe le computazioni, $f_{y+1}(x+1)$ e $f_y(x)$, devono **terminare** e produrre dei valori numerici confrontabili.
*   Il caso "altrimenti", in cui `h` deve restituire `⊥` (cioè non terminare), si verifica in tre scenari:
    1.  $f_{y+1}(x+1)$ non termina.
    2.  $f_y(x)$ non termina.
    3.  Entrambe terminano, ma il risultato del primo non è maggiore del secondo.

**Costruzione di un algoritmo per calcolare `h`:**
Possiamo costruire un algoritmo che simuli questo comportamento. La sfida è gestire il fatto che una delle due computazioni potrebbe non terminare, bloccando l'intero processo. La soluzione è la **simulazione in parallelo (dovetailing)**:

1.  Dati `x` e `y`, l'algoritmo deve simulare due macchine: la macchina `y` con input `x`, e la macchina `y+1` con input `x+1`.
2.  Si esegue un passo della simulazione di $f_y(x)$.
3.  Si esegue un passo della simulazione di $f_{y+1}(x+1)$.
4.  Si ripete dal passo 2, alternando i passi delle due simulazioni.

Questo processo si arresta **solo se e quando entrambe le simulazioni sono terminate**.
*   **Se l'alternanza non si arresta mai** (perché almeno una delle due computazioni non termina), il nostro algoritmo per `h` non terminerà. Questo è esattamente il comportamento richiesto da `h` in questi casi.
*   **Se l'alternanza si arresta**, significa che abbiamo ottenuto due valori: `risultato_y` e `risultato_y+1`. A questo punto:
    *   Confrontiamo i risultati: `if (risultato_y+1 > risultato_y)`.
    *   Se la condizione è **vera**, l'algoritmo termina e restituisce `1`.
    *   Se la condizione è **falsa**, l'algoritmo deve entrare deliberatamente in un loop infinito (es. `while(true){}`) per non terminare, come richiesto dalla specifica.

**Conclusione:**
Sì, la funzione `h` **è calcolabile**. Abbiamo descritto un algoritmo che si comporta esattamente come `h`, terminando e restituendo `1` nel caso specificato, e non terminando in tutti gli altri casi.

---

#### **Domanda 2: Calcolabilità di h'(x, y)**

**Analisi della funzione `h'`:**
Questa funzione è strutturalmente identica alla precedente. È una funzione parziale che restituisce un valore (`0`) solo se una certa condizione (`f_{y+1}(x+1) \le f_y(x)`) è verificata dopo che entrambe le computazioni sono terminate.

**Ragionamento:**
Il ragionamento è esattamente lo stesso del punto 1. Si può usare lo stesso algoritmo di simulazione in parallelo. Le uniche differenze sono:
*   La condizione da verificare sui risultati ( `≤` invece di `>` ).
*   Il valore da restituire in caso di successo ( `0` invece di `1` ).

**Conclusione:**
Sì, la funzione `h'` **è calcolabile** per le stesse ragioni di `h`.

---

#### **Domanda 3: Decidibilità del problema "fi(i) ≤ fj(j)"**

**Obiettivo:** Dobbiamo stabilire se il problema è **decidibile**. Questo è molto più restrittivo della calcolabilità di una funzione parziale. Un problema è decidibile se esiste un algoritmo che, per *qualsiasi* input (`i` e `j`), **termina sempre** e fornisce una risposta corretta ("sì" o "no").

**Analisi del problema:**
Decidere se $f_i(i) \le f_j(j)$ è equivalente a chiedere se la seguente funzione **totale** `t(i, j)` sia calcolabile:
$t(i, j) = \begin{cases} 1 & \text{se } f_i(i) \le f_j(j) \\ 0 & \text{altrimenti} \end{cases}$

Il caso "altrimenti" qui include il caso in cui una o entrambe le computazioni $f_i(i)$ o $f_j(j)$ non terminano. Un algoritmo per `t` dovrebbe essere in grado di rilevare la non terminazione per poter restituire `0`. Questo è un campanello d'allarme che ci fa pensare al Problema dell'Arresto.

**Dimostrazione tramite Riduzione (come suggerito):**
Usiamo la tecnica della riduzione. Mostriamo che se potessimo decidere questo problema, potremmo decidere un problema noto per essere indecidibile.

1.  **Semplifichiamo il problema:** Fissiamo uno degli input. Prendiamo `i = 0`, come suggerito. Il problema diventa: "È decidibile se $f_0(0) \le f_j(j)$?".

2.  **Usiamo il suggerimento:** Sappiamo che $f_0(x) = x$. Questa è una funzione totale che termina sempre. Quindi, $f_0(0) = 0$. Il problema si semplifica ulteriormente in: "È decidibile se $0 \le f_j(j)$?".

3.  **Analizziamo la condizione "0 ≤ fj(j)":**
    *   Quando è **vera**? È vera se e solo se la computazione $f_j(j)$ **termina** e produce un valore numerico (che, per convenzione, è un numero naturale, quindi sempre ≥ 0).
    *   Quando è **falsa**? È falsa se la computazione $f_j(j)$ **non termina**.

4.  **La Riduzione:** Abbiamo stabilito una diretta equivalenza:
    *   La risposta alla domanda "$0 \le f_j(j)$?" è "sì" **se e solo se** la macchina `j` termina sull'input `j`.
    *   La risposta è "no" **se e solo se** la macchina `j` non termina sull'input `j`.

5.  **Conclusione:** Un algoritmo che decide il nostro problema (anche nel caso semplificato con `i=0`) sarebbe un algoritmo che decide il **Problema dell'Arresto nella sua forma diagonale** ("`f_j(j)` termina?"). Poiché il Problema dell'Arresto è notoriamente **indecidibile**, anche il nostro problema originale deve essere **indecidibile**.
## Es 5
Si considerino le funzioni `g` e `h`:

$g(x) = \begin{cases} f_x(x) + 2 & \text{se } f_x(x) \neq \perp \\ 1 & \text{altrimenti (cioè, se } f_x(x) = \perp) \end{cases}$

$h(x) = \begin{cases} f_x(x) & \text{se } f_x(x) \neq \perp \\ 1 & \text{altrimenti (cioè, se } f_x(x) = \perp) \end{cases}$

*(Dove $f_x(x) \neq \perp$ significa "la x-esima Macchina di Turing, con input x, termina" e $f_x(x) = \perp$ significa "non termina")*

**Domande:**
a) `g` e `h` sono totali?
b) `g` è computabile?
c) `h` è computabile?

---

### **Spiegazione e Analisi della Soluzione**

#### **a) `g` e `h` sono totali?**

**Risposta:** Sì, entrambe le funzioni sono totali.

**Motivazione:**
Una funzione è **totale** se ha un valore di output ben definito per ogni possibile input `x` dall'insieme dei numeri naturali.
Analizziamo le definizioni:
*   Per ogni `x`, la computazione `f_x(x)` può avere solo due esiti: o termina o non termina.
*   **Funzione g:**
    *   Se `f_x(x)` termina, `g(x)` ha un valore (`f_x(x) + 2`).
    *   Se `f_x(x)` non termina, `g(x)` ha comunque un valore (`1`).
*   **Funzione h:**
    *   Se `f_x(x)` termina, `h(x)` ha un valore (il risultato di `f_x(x)`).
    *   Se `f_x(x)` non termina, `h(x)` ha comunque un valore (`1`).

Poiché in entrambi i casi la clausola "altrimenti" copre l'unico altro esito possibile (la non terminazione), le funzioni `g` e `h` sono definite per ogni `x`. Quindi, sono totali.

---

#### **b) `g` è computabile?**

**Risposta:** No, `g` non è computabile.

**Motivazione (Spiegazione della Riduzione):**
Per dimostrarlo, la soluzione usa una tecnica fondamentale chiamata **riduzione**. L'idea è: "Se potessimo calcolare `g`, allora potremmo risolvere un altro problema che sappiamo già essere impossibile da risolvere. Poiché ciò porta a una contraddizione, la nostra ipotesi iniziale (che `g` sia computabile) deve essere falsa."

1.  **Il Problema Impossibile:** Consideriamo la funzione `g'` che decide il **complemento del Problema dell'Arresto** (sulla diagonale):
    $g'(x) = \begin{cases} 1 & \text{se } f_x(x) \text{ non termina} \\ 0 & \text{se } f_x(x) \text{ termina} \end{cases}$
    Questa funzione `g'` è notoriamente **non computabile**. Non esiste un algoritmo che possa decidere per ogni `x` se la macchina `x` si ferma su `x`.

2.  **L'Ipotesi:** Supponiamo per assurdo che `g` **sia** computabile. Questo significa che esiste un algoritmo `Calcola_g(x)` che termina sempre e restituisce il valore di `g(x)`.

3.  **La Riduzione:** Mostriamo come usare `Calcola_g` per costruire un algoritmo per `g'`:
    ```
    Algoritmo Calcola_g_primo(x):
      // Per ipotesi, questo passo termina sempre
      risultato_g = Calcola_g(x)

      // Ora analizziamo il risultato di g(x)
      if (risultato_g == 1):
        // Dalla definizione di g, g(x) vale 1 solo se f_x(x) non termina.
        // In questo caso, g'(x) dovrebbe valere 1.
        return 1
      else: // Se risultato_g non è 1, allora f_x(x) deve essere terminato.
        // Dalla definizione di g, g(x) vale f_x(x)+2.
        // In questo caso, g'(x) dovrebbe valere 0.
        return 0
    ```
4.  **La Contraddizione:** Abbiamo appena costruito un algoritmo (`Calcola_g_primo`) che calcola perfettamente la funzione `g'`. Ma al punto 1 abbiamo detto che `g'` è non computabile. Questa è una contraddizione.

5.  **Conclusione:** L'unica assunzione fatta è stata che `g` fosse computabile. Poiché questa assunzione porta a una contraddizione, deve essere falsa. Pertanto, **`g` non è computabile**.

---

#### **c) `h` è computabile?**

**Risposta:** No, `h` non è computabile.

**Motivazione (Spiegazione dell'Estensione di Funzione):**
Anche qui la dimostrazione è per assurdo, ma usa un argomento leggermente più sottile basato sul concetto di "estensione di una funzione".

1.  **Una Funzione Parziale Nota:** Consideriamo la funzione `h_barra`:
    $\bar{h}(x) = \begin{cases} f_x(x) + 1 & \text{se } f_x(x) \text{ termina} \\ \perp & \text{altrimenti} \end{cases}$
    Questa è una funzione **parziale** (non è definita dove `f_x(x)` non termina) ma è **computabile** (basta simulare `f_x(x)` e, se termina, aggiungere 1).

2.  **Un Teorema Chiave:** Esiste un teorema in teoria della computabilità che afferma che la funzione `h_barra` (e altre simili) **non ammette alcuna estensione che sia sia totale sia computabile**.
    *   *Cos'è un'estensione?* Una funzione `F` è un'estensione di `f` se `F(x) = f(x)` per tutti gli `x` per cui `f` è definita. Una *estensione totale* è un'estensione che è definita per tutti gli `x`.

3.  **L'Ipotesi:** Supponiamo per assurdo che `h` **sia** computabile.

4.  **La Riduzione:** Se `h` fosse computabile, allora anche la funzione `h'(x) = h(x) + 1` sarebbe computabile (l'operazione di aggiungere 1 è banale). Vediamo com'è fatta `h'`:
    *   Se `f_x(x)` termina e restituisce `v`: `h(x) = v`, quindi `h'(x) = v + 1`.
    *   Se `f_x(x)` non termina: `h(x) = 1`, quindi `h'(x) = 1 + 1 = 2`.

5.  **La Contraddizione:** Analizziamo questa nuova funzione `h'`:
    *   È **totale**: è definita per ogni `x` (restituisce `v+1` o `2`).
    *   È un'**estensione** di `h_barra`: per ogni `x` in cui `h_barra` è definita (cioè dove `f_x(x)` termina), entrambe le funzioni valgono `f_x(x) + 1`.
    Abbiamo quindi trovato che `h'` è una **estensione totale di `h_barra`**.
    Se la nostra ipotesi al punto 3 fosse vera (`h` è computabile), allora anche `h'` sarebbe computabile. Ma questo significa che abbiamo trovato una "estensione totale e computabile" di `h_barra`, il che **contraddice il teorema** menzionato al punto 2.

6.  **Conclusione:** L'assunzione che `h` sia computabile ci ha portato a una contraddizione. Pertanto, **`h` non è computabile**.

## ES 6
Si considerino le seguenti funzioni e si dica se sono calcolabili, motivando esaurientemente la risposta:

1.  $h(x) = \begin{cases} 1 & \text{se } f_x(x) > x \\ 0 & \text{altrimenti} \end{cases}$
2.  $i(x,y,z) = f_y(x) + f_z(x)$

*(Nota: $f_k(n)$ è la funzione calcolata dalla k-esima Macchina di Turing con input n)*

---

### **1. Funzione `h(x)`: È Calcolabile?**

**Risposta:** No, la funzione `h` **non è calcolabile**.

**Motivazione (Spiegazione dettagliata della diagonalizzazione):**

Questo è un classico esempio di problema che si risolve con una **dimostrazione per assurdo tramite diagonalizzazione**, una tecnica potente e controintuitiva simile a quella usata per dimostrare l'indecidibilità del Problema dell'Arresto.

1.  **L'ipotesi di partenza (per assurdo):** Supponiamo che `h` **sia** calcolabile. Se fosse così, esisterebbe una Macchina di Turing in grado di calcolarla per qualsiasi input `x`.

2.  **Costruiamo una funzione "nemesi" `g(x)`:** Basandoci sulla nostra ipotetica capacità di calcolare `h`, costruiamo una nuova funzione `g(x)` progettata specificamente per creare una contraddizione. La definiamo come segue:
    $g(x) = \begin{cases} x+1 & \text{se } h(x) = 0 \\ \perp & \text{se } h(x) = 1 \end{cases}$
    *(dove `⊥` significa "non terminare")*

3.  **`g(x)` sarebbe calcolabile:** Se la nostra ipotesi è vera (cioè `h` è calcolabile), allora anche `g` deve essere calcolabile. Un algoritmo per `g(x)` sarebbe:
    *   Calcola `h(x)`. (Questo termina sempre, per ipotesi).
    *   Se il risultato è 0, calcola `x+1` e restituiscilo.
    *   Se il risultato è 1, entra in un loop infinito.
    Tutti questi passaggi sono eseguibili, quindi `g` è una funzione calcolabile.

4.  **Il paradosso della diagonalizzazione:** Poiché `g` è calcolabile, deve esistere nell'enumerazione di tutte le Macchine di Turing. Ciò significa che deve esistere un indice `i` tale che la i-esima Macchina di Turing calcola proprio la funzione `g`. In simboli: **`fᵢ(x) = g(x)` per ogni `x`**.
    Ora poniamoci la domanda cruciale: **Cosa succede quando eseguiamo questa macchina sul suo stesso indice `i`? Qual è il valore di `fᵢ(i)` (che è uguale a `g(i)`)?**

5.  **Analizziamo i due (unici) casi possibili:**
    *   **Caso A: `h(i) = 0`**.
        *   Dalla definizione di `g`, se `h(i)=0` allora `g(i) = i+1`. Quindi la macchina `i` termina e restituisce `i+1`.
        *   Ma guardiamo la definizione di `h`: `h(i)=0` significa che `fᵢ(i) ≤ i` OPPURE `fᵢ(i)` non termina.
        *   Abbiamo una **contraddizione**: `g(i)` ci dice che `fᵢ(i) = i+1` (che è ovviamente `> i`), ma la condizione `h(i)=0` che ha generato questo risultato ci dice che `fᵢ(i)` doveva essere `≤ i` (o non terminare). È impossibile.

    *   **Caso B: `h(i) = 1`**.
        *   Dalla definizione di `g`, se `h(i)=1` allora `g(i) = ⊥`. Quindi la macchina `i` non termina.
        *   Ma guardiamo la definizione di `h`: `h(i)=1` significa che `fᵢ(i) > i`.
        *   Abbiamo un'altra **contraddizione**: la condizione `h(i)=1` richiede che `fᵢ(i)` termini e produca un valore maggiore di `i`, ma il risultato di `g(i)` che ne deriva ci dice che `fᵢ(i)` non termina affatto. Una computazione che non termina non può avere un valore.

6.  **Conclusione:** Entrambi i possibili esiti portano a un'assurdità logica. L'unica cosa che può essere sbagliata è la nostra ipotesi iniziale. Pertanto, **`h` non può essere calcolabile**.

---

### **2. Funzione `i(x,y,z)`: È Calcolabile?**

**Risposta:** Sì, la funzione `i` **è calcolabile**.

**Motivazione:**

La differenza fondamentale rispetto al primo caso è che `i` è una **funzione parziale**. Un algoritmo per calcolarla non deve terminare sempre, ma deve terminare *se e solo se* la funzione stessa è definita.

1.  **Quando è definita `i(x,y,z)`?** La funzione è definita solo se **entrambe** le computazioni `fᵧ(x)` e `f₂(x)` terminano. Se anche solo una delle due non termina, la somma non è definita, e quindi anche `i(x,y,z)` non è definita (cioè, il suo valore è `⊥`).

2.  **Costruzione dell'algoritmo:** Possiamo descrivere un algoritmo (una Macchina di Turing) che calcola `i`:
    *   **Input:** `x`, `y`, `z`.
    *   **Passo 1:** Usando una Macchina di Turing Universale, simula l'esecuzione della macchina `y` sull'input `x`.
    *   **Passo 2:** Se la simulazione del passo 1 termina, salva il risultato (chiamiamolo `risultato_y`). Altrimenti, se non termina, anche il nostro algoritmo per `i` non terminerà, il che è corretto.
    *   **Passo 3:** Ora, simula l'esecuzione della macchina `z` sull'input `x`.
    *   **Passo 4:** Se la simulazione del passo 3 termina, salva il risultato (chiamiamolo `risultato_z`). Altrimenti, il nostro algoritmo si bloccherà qui, il che è di nuovo corretto.
    *   **Passo 5:** Se siamo arrivati fin qui, significa che entrambe le computazioni sono terminate. Calcola la somma `risultato_y + risultato_z` e restituiscila come output.

Questo algoritmo si comporta esattamente come la funzione `i`: termina e restituisce la somma corretta se e solo se entrambe le computazioni `fᵧ(x)` e `f₂(x)` terminano. Poiché esiste un algoritmo che la calcola, **la funzione `i` è calcolabile**.

## Es 7

Si considerino le seguenti funzioni e si dica se sono calcolabili, motivando esaurientemente la risposta:

1.  $f(x) = f_y(x) - 2$, con $y = x+2$
    *(Nota: se $f_y(x) = \perp$, chiaramente anche $f(x) = \perp$)*

2.  $g(x,y) = \begin{cases} f_{x+y}(y) + 1 & \text{se } M_{x+y} \text{ calcola una funzione totale} \\ 0 & \text{altrimenti} \end{cases}$

*(Nota: $M_k$ è la k-esima Macchina di Turing, e $f_k$ è la funzione da essa calcolata)*

---

### **1. Funzione `f(x)`: È Calcolabile?**

**Risposta:** Sì, la funzione `f(x)` **è calcolabile**.

**Motivazione:**

Questa è una funzione **parziale**: è definita solo se la computazione interna $f_{x+2}(x)$ termina. Un algoritmo che la calcola non deve terminare sempre, ma solo quando la funzione è definita.

Possiamo descrivere un algoritmo (una Macchina di Turing) che calcola `f(x)` nel modo seguente:

1.  **Input:** Prendi in input il numero `x`.
2.  **Calcola l'indice:** Calcola l'indice della macchina da simulare: `y = x + 2`. Questa è un'operazione aritmetica banale.
3.  **Trova la macchina:** Accedi all'enumerazione standard `E` di tutte le Macchine di Turing per ottenere la descrizione della macchina `M_y` (cioè `M_{x+2}`).
4.  **Simula:** Usa una Macchina di Turing Universale per simulare l'esecuzione di `M_{x+2}` sull'input `x`.
5.  **Gestisci i risultati:**
    *   **Se la simulazione termina** e produce un risultato `v`, l'algoritmo calcola `v - 2` e restituisce questo valore. Questo corrisponde esattamente alla definizione di `f(x)` nel caso in cui sia definita.
    *   **Se la simulazione non termina** (cioè $f_{x+2}(x) = \perp$), l'algoritmo che sta eseguendo la simulazione non terminerà a sua volta. Questo corrisponde esattamente alla definizione di `f(x)` nel caso in cui non sia definita (`f(x) = \perp`).

Poiché abbiamo descritto un algoritmo che si comporta esattamente come la funzione `f` in tutti i casi (sia di terminazione che di non terminazione), la funzione `f` è, per definizione, calcolabile.

---

### **2. Funzione `g(x,y)`: È Calcolabile?**

**Risposta:** No, la funzione `g(x,y)` **non è calcolabile**.

**Motivazione (Dimostrazione per Riduzione):**

Questa funzione è **totale** per definizione (restituisce sempre un valore), ma la sua definizione dipende da una proprietà **indecidibile**: stabilire se una generica Macchina di Turing calcola una funzione totale (il **Problema della Totalità**).

Dimostriamo che `g` non è calcolabile usando la tecnica della **riduzione**. Mostreremo che se `g` fosse calcolabile, potremmo usarla per risolvere il Problema della Totalità, il che è impossibile.

1.  **Il Problema Indecidibile Noto:** Il Problema della Totalità chiede: "Data una macchina di Turing `M_k`, la funzione `f_k` è totale (cioè termina per ogni input)?". Questo problema è notoriamente indecidibile.

2.  **Ipotesi per Assurdo:** Supponiamo che `g(x,y)` **sia** calcolabile. Ciò significa che esiste un algoritmo `Calcola_g(x,y)` che termina sempre e restituisce il valore corretto.

3.  **La Riduzione:** Vediamo come usare il nostro ipotetico `Calcola_g` per risolvere il Problema della Totalità.
    *   Supponiamo che ci venga dato un indice `k` e ci venga chiesto di decidere se la funzione `f_k` è totale.
    *   Dobbiamo scegliere `x` e `y` in modo intelligente affinché `x+y = k`. La scelta più semplice, come suggerito dalla soluzione, è:
        *   `y = 1`
        *   `x = k - 1`
        *(Questo funziona per ogni `k ≥ 1`. Il caso `k=0` può essere gestito separatamente, non inficia la dimostrazione generale).*
    *   Ora usiamo il nostro algoritmo `Calcola_g` con questi valori: `Calcola_g(k-1, 1)`.

4.  **Analisi del Risultato:**
    *   **Caso A:** Se `Calcola_g(k-1, 1)` restituisce `0`.
        *   Guardando la definizione di `g`, questo accade se e solo se la macchina `M_{(k-1)+1}` (cioè `M_k`) **non** calcola una funzione totale.
        *   Quindi, possiamo rispondere con certezza: "No, `f_k` non è totale".
    *   **Caso B:** Se `Calcola_g(k-1, 1)` restituisce un valore diverso da `0` (quindi un valore positivo).
        *   Guardando la definizione di `g`, questo accade se e solo se la macchina `M_k` **sì** calcola una funzione totale.
        *   Quindi, possiamo rispondere con certezza: "Sì, `f_k` è totale".

5.  **La Contraddizione:**
    Abbiamo appena descritto un metodo che, dato un qualsiasi `k`, decide in un tempo finito se `f_k` è totale, sfruttando l'ipotetico algoritmo `Calcola_g`. Questo metodo è un algoritmo che risolve il Problema della Totalità.
    Ma il Problema della Totalità è indecidibile. Questa è una contraddizione.

6.  **Conclusione:**
    L'unica assunzione che abbiamo fatto è stata che `g` fosse calcolabile. Poiché questa assunzione porta a una contraddizione, deve essere falsa. Pertanto, **`g(x,y)` non è calcolabile**.

## Es 8

Si consideri una macchina di Turing universale `M` fissata, a nastro singolo. Sia `Σ` l'alfabeto del nastro di `M`.

a) È calcolabile la funzione `f` che riceve in ingresso una qualunque stringa `s` appartenente a `⋃_{i=0}^{100} Σⁱ`?
$f(s) = \begin{cases} 1 & \text{se } M(s) \neq \perp \\ 0 & \text{se } M(s) = \perp \end{cases}$

b) È calcolabile la funzione `g` che riceve in ingresso una qualunque stringa `s` appartenente a `⋃_{i=2k, k∈N} Σⁱ`?
$g(s) = \begin{cases} 1 & \text{se } M(s) \neq \perp \\ \perp & \text{se } M(s) = \perp \end{cases}$

*(Nota: `M(s) ≠ ⊥` significa che la macchina M si arresta sull'input s, mentre `M(s) = ⊥` significa che non si arresta).*

---

### Soluzione e Spiegazione Dettagliata

#### **a) La funzione `f` è calcolabile? SÌ.**

**Analisi:**
*   **Cosa fa la funzione `f`?** Questa funzione decide il Problema dell'Arresto. Deve restituire `1` se `M` termina e `0` se `M` non termina. È una funzione **totale**: deve sempre fornire una risposta.
*   **Qual è il suo dominio?** Il dominio di `f` è l'insieme di tutte le stringhe `s` sull'alfabeto `Σ` la cui lunghezza va da 0 a 100.
*   **Il punto cruciale:** Questo dominio è **FINITO**. Anche se il numero di stringhe può essere molto grande, è un numero fisso e limitato.

**Motivazione:**
Il Problema dell'Arresto è indecidibile su un dominio *infinito* di input. Su un dominio **finito**, il problema diventa sempre decidibile.

Il motivo è che per ogni singola stringa `s` in questo insieme finito, la risposta alla domanda "M si ferma su s?" è una costante: è o "Sì" o "No". Poiché ci sono un numero finito di stringhe, possiamo immaginare di pre-calcolare (o semplicemente di postulare l'esistenza di) una gigantesca **tabella di ricerca (lookup table)**.

Un algoritmo per calcolare `f` potrebbe essere implementato così:
1.  Prendi in input la stringa `s`.
2.  Cerca `s` in una tabella predefinita che contiene tutte le stringhe di lunghezza da 0 a 100.
3.  Per ogni stringa, la tabella ha associato il valore corretto (1 o 0).
4.  Restituisci il valore trovato.

Questo algoritmo è garantito per terminare (la ricerca in una tabella finita è un'operazione finita) e per dare la risposta corretta. Poiché un tale algoritmo esiste, la funzione `f` è, per definizione, **calcolabile**.

---

#### **b) La funzione `g` è calcolabile? SÌ.**

**Analisi:**
*   **Cosa fa la funzione `g`?** Questa funzione restituisce `1` se `M` termina, ma **non termina** (`⊥`) se `M` non termina. È una funzione **parziale**.
*   **Qual è il suo dominio?** Il dominio di `g` è l'insieme di tutte le stringhe `s` di lunghezza pari (0, 2, 4, ...). Questo è un dominio **INFINITO**.

**Motivazione:**
A differenza del caso precedente, non possiamo più usare l'argomento della tabella di ricerca finita. Tuttavia, la natura *parziale* della funzione `g` è ciò che la rende calcolabile.

Un algoritmo per calcolare `g` è sorprendentemente semplice:
1.  Prendi in input la stringa `s`.
2.  **Simula l'esecuzione** della macchina universale `M` con l'input `s`.

Analizziamo il comportamento di questo algoritmo di simulazione:
*   **Se `M(s)` si arresta:** La nostra simulazione, dopo un numero finito di passi, si arresterà anch'essa. A quel punto, il nostro algoritmo può restituire `1`. Questo comportamento corrisponde esattamente alla definizione `g(s) = 1`.
*   **Se `M(s)` non si arresta (va in loop):** La nostra simulazione continuerà a girare all'infinito, senza mai fermarsi. Questo significa che il nostro algoritmo non termina. Questo comportamento corrisponde esattamente alla definizione `g(s) = ⊥`.

Poiché abbiamo descritto un algoritmo il cui comportamento specchia perfettamente quello della funzione `g` su tutti gli input del suo dominio (infinito), la funzione `g` è, per definizione, **calcolabile**.

## Es 9


### **Concetti Chiave**

*   **Funzione Computabile:** Esiste un algoritmo (una Macchina di Turing) che la calcola. Se la funzione è **totale** (definita per ogni input, come `g1`, `g3`, `g5`), l'algoritmo deve terminare sempre. Se è **parziale** (può essere indefinita `⊥`, come `g2`, `g4`, `g6`), l'algoritmo deve non terminare per gli input su cui la funzione è indefinita.
*   **Domanda Chiusa:** Una domanda la cui risposta è una costante "Sì" o "No", anche se non la conosciamo. Ad esempio, "Esiste vita su Marte?". La risposta è una, non dipende da un input. Un problema che si basa su una domanda chiusa è sempre decidibile.
*   **Teorema di Rice:** Qualsiasi proprietà **non banale** del **comportamento** di una Macchina di Turing è indecidibile. "Non banale" significa che almeno una macchina ha la proprietà e almeno una non ce l'ha.

---

### **a) g1(y) = 1 se f₁₀(10) > 10, 0 altrimenti**

**Risposta:** **Computabile.**

**Motivazione:**
La funzione `g1` prende un input `y`, ma il suo comportamento **non dipende affatto da `y`**. La condizione `f₁₀(10) > 10` è una "domanda chiusa". La computazione della decima macchina sull'input 10 o termina o non termina. Se termina, il suo risultato o è maggiore di 10 o non lo è.

Di conseguenza, la condizione `f₁₀(10) > 10` è o **sempre vera** o **sempre falsa**.
*   **Caso 1: La condizione è vera.** Allora `g1(y)` è la funzione costante `g1(y) = 1`. Questa è banalmente computabile (l'algoritmo è `return 1`).
*   **Caso 2: La condizione è falsa.** Allora `g1(y)` è la funzione costante `g1(y) = 0`. Anche questa è computabile (l'algoritmo è `return 0`).

Poiché, in entrambi gli scenari possibili, la funzione risultante è computabile, possiamo concludere che `g1` **è computabile**. Non abbiamo bisogno di sapere *quale* dei due casi sia vero, ci basta sapere che uno dei due algoritmi la calcola.

---

### **b) g2(y) = 1 se f₁₀(10) > 10, ⊥ altrimenti**

**Risposta:** **Computabile.**

**Motivazione:**
Il ragionamento è identico al punto (a). La condizione è sempre la stessa "domanda chiusa".
*   **Caso 1: La condizione è vera.** La funzione è `g2(y) = 1`. È computabile.
*   **Caso 2: La condizione è falsa.** La funzione è `g2(y) = ⊥` (la funzione ovunque indefinita). Anche questa è computabile: un algoritmo che la calcola è `while(true){}`.

Poiché la funzione è computabile in entrambi gli scenari, `g2` **è computabile**.

---

### **c) g3(y) = 1 se fᵧ(10) > 10, 0 altrimenti**

**Risposta:** **Non computabile.**

**Motivazione (Teorema di Rice):**
Qui la situazione cambia radicalmente: il comportamento della funzione dipende dall'input `y`. La funzione `g3` è **totale**, quindi per essere computabile, dovrebbe **decidere** una proprietà della macchina `Mᵧ`.

1.  **La Proprietà:** La proprietà in esame è "la funzione calcolata dalla macchina `Mᵧ` restituisce un valore maggiore di 10 per l'input 10".
2.  **Applichiamo il Teorema di Rice:**
    *   È una proprietà del **comportamento**? Sì, riguarda l'output della funzione, non la struttura della macchina.
    *   È **non banale**? Sì. Come dice la soluzione, la funzione costante `f(x) = 11` ha questa proprietà, mentre la funzione costante `f(x) = 9` non ce l'ha.
3.  **Conclusione:** Poiché è una proprietà non banale del comportamento, il Teorema di Rice ci dice che è **indecidibile**. Un algoritmo che calcola `g3` dovrebbe decidere questo problema. Poiché il problema è indecidibile, un tale algoritmo non può esistere.

---

### **d) g4(y) = 1 se fᵧ(10) > 10, ⊥ altrimenti**

**Risposta:** **Computabile.**

**Motivazione:**
Questa è la versione **parziale** di `g3`. Non deve decidere il problema, ma solo **semi-deciderlo**. Può non terminare se la condizione è falsa. Questo fa tutta la differenza.

Possiamo costruire un algoritmo che calcola `g4`:
1.  Prendi in input `y`.
2.  **Simula** la macchina `Mᵧ` con l'input `10`.
3.  **Analizza il risultato della simulazione:**
    *   **Se la simulazione termina** con un risultato `v`:
        *   Se `v > 10`, l'algoritmo si ferma e restituisce `1` (corretto).
        *   Se `v ≤ 10`, l'algoritmo entra in un loop infinito (`while(true){}`). Questo produce `⊥` (corretto).
    *   **Se la simulazione di `Mᵧ(10)` non termina**: Il nostro algoritmo di simulazione non terminerà a sua volta. Questo produce `⊥` (corretto).

Poiché abbiamo descritto un algoritmo che si comporta esattamente come `g4`, la funzione **è computabile**.

---

### **e) g5(y,x) = 1 se fᵧ(10) > x, 0 altrimenti**

**Risposta:** **Non computabile.**

**Motivazione (Riduzione):**
Questo problema è una generalizzazione di `g3`. Se potessimo risolvere questo problema, potremmo risolvere anche `g3`, che sappiamo essere irrisolvibile.

1.  **Ipotesi:** Supponiamo per assurdo che `g5` sia computabile.
2.  **La Riduzione:** Vogliamo calcolare `g3(y)`. Possiamo farlo usando `g5`? Sì.
    `g3(y)` è definito come `1` se `fᵧ(10) > 10` e `0` altrimenti.
    Basta calcolare `g5(y, 10)`. Per definizione, `g5(y, 10)` vale `1` se `fᵧ(10) > 10` e `0` altrimenti.
    Quindi, `g3(y) = g5(y, 10)`.
3.  **La Contraddizione:** Abbiamo appena mostrato che se `g5` fosse computabile, potremmo calcolare `g3` semplicemente fissando `x=10`. Ma abbiamo già dimostrato in (c) che `g3` **non è computabile**. Questa è una contraddizione.
4.  **Conclusione:** La nostra ipotesi iniziale deve essere falsa. `g5` non è computabile.

---

### **f) g6(y,x) = 1 se fᵧ(10) > x, ⊥ altrimenti**

**Risposta:** **Computabile.**

**Motivazione:**
Questa è la versione **parziale** di `g5`, e il ragionamento è identico a quello per `g4`. Possiamo costruire un algoritmo che la calcola.

1.  Prendi in input `y` e `x`.
2.  **Simula** la macchina `Mᵧ` con l'input `10`.
3.  **Analizza il risultato della simulazione:**
    *   **Se la simulazione termina** con un risultato `v`:
        *   Se `v > x`, l'algoritmo si ferma e restituisce `1` (corretto).
        *   Se `v ≤ x`, l'algoritomo entra in un loop infinito, producendo `⊥` (corretto).
    *   **Se la simulazione di `Mᵧ(10)` non termina**: Il nostro algoritmo non terminerà, producendo `⊥` (corretto).

Poiché esiste un algoritmo che si comporta esattamente come `g6`, la funzione **è computabile**.

## ES 10


1.  Si consideri la seguente funzione e si dica, motivando adeguatamente la risposta, se essa sia calcolabile:
    $w(x,y) = \begin{cases} f_y(x) & \text{se } f_y(y) = f_x(x) \\ \perp & \text{altrimenti} \end{cases}$
    *(Nota: `⊥` significa che la funzione non è definita / la computazione non termina)*

2.  Si dica, motivando adeguatamente la risposta, se il seguente insieme `T` è ricorsivo:
    `T = {i | la MT Mᵢ possiede i stati senza transizioni uscenti}`

---

### **1. La funzione `w(x,y)` è calcolabile?**

**Risposta:** Sì, la funzione `w(x,y)` **è calcolabile**.

**Motivazione:**

La chiave per capire questo problema è notare che `w(x,y)` è una **funzione parziale**. Un algoritmo per calcolarla non deve terminare sempre, ma deve terminare *se e solo se* le condizioni nella definizione della funzione sono soddisfatte.

Analizziamo le condizioni per cui `w(x,y)` è definita:
1.  La computazione `f_y(y)` deve terminare.
2.  La computazione `f_x(x)` deve terminare.
3.  I risultati delle due computazioni devono essere uguali.
4.  La computazione `f_y(x)` deve terminare (per poter restituire il suo valore).

Se anche solo una di queste condizioni non si verifica (ad esempio, `f_y(y)` non termina), la funzione `w(x,y)` deve restituire `⊥` (cioè, il nostro algoritmo non deve terminare).

**Costruzione dell'Algoritmo:**
Possiamo descrivere un algoritmo (una Macchina di Turing) che calcola `w(x,y)`. La sfida è gestire le computazioni che potrebbero non terminare. La soluzione è simulare le computazioni necessarie in modo sequenziale.

1.  **Input:** Prendi in input la coppia `(x,y)`.
2.  **Passo 1: Simula `f_y(y)`**.
    *   Usa una Macchina di Turing Universale per simulare l'esecuzione della macchina `M_y` sull'input `y`.
    *   **Se questa simulazione non termina**, il nostro algoritmo per `w` non terminerà. Questo è corretto, perché siamo nel caso "altrimenti".
    *   Se termina, salva il risultato: `risultato_yy`.
3.  **Passo 2: Simula `f_x(x)`**.
    *   Simula l'esecuzione della macchina `M_x` sull'input `x`.
    *   **Se questa simulazione non termina**, il nostro algoritmo non terminerà. Anche questo è corretto.
    *   Se termina, salva il risultato: `risultato_xx`.
4.  **Passo 3: Confronta i risultati**.
    *   Controlla se `risultato_yy == risultato_xx`.
    *   **Se non sono uguali**, il nostro algoritmo entra deliberatamente in un loop infinito (`while(true){}`). Questo è corretto, perché siamo nel caso "altrimenti".
5.  **Passo 4: Calcola il valore finale**.
    *   Se i risultati erano uguali, ora simula l'esecuzione della macchina `M_y` sull'input `x`.
    *   **Se questa simulazione non termina**, il nostro algoritmo non terminerà. Questo è un caso sottile: la funzione è definita (la condizione `f_y(y) = f_x(x)` è vera), ma il valore da restituire (`f_y(x)`) è `⊥`. Quindi, il comportamento è corretto.
    *   **Se la simulazione termina** con un valore `v`, il nostro algoritmo restituisce `v`.

Poiché abbiamo descritto un algoritmo che si comporta esattamente come la funzione `w` in tutti i casi, la funzione `w` **è calcolabile**.

---

### **2. L'insieme `T` è ricorsivo?**

**Risposta:** Sì, l'insieme `T` **è ricorsivo** (decidibile).

**Motivazione:**

La chiave qui è capire che la proprietà che definisce l'insieme `T` è **sintattica**, non semantica. Non ci interessa cosa fa la macchina `Mᵢ` (il suo comportamento), ma solo **come è fatta** (la sua struttura, la sua descrizione formale).

Un insieme è ricorsivo (decidibile) se esiste un algoritmo che termina sempre e risponde correttamente "sì" o "no".

**Costruzione dell'Algoritmo di Decisione:**

1.  **Input:** Prendi in input un indice `i`.
2.  **Passo 1: Ottieni la descrizione della Macchina**.
    *   Usa l'enumerazione standard di Gödel `E` per "decodificare" l'indice `i` e ottenere la descrizione formale della Macchina di Turing `Mᵢ`. Questa descrizione è una tupla finita che elenca gli stati, l'alfabeto, le transizioni, ecc. Questa operazione termina sempre.
3.  **Passo 2: Ispeziona la Descrizione**.
    *   La descrizione di una MT è un oggetto finito. L'algoritmo può ora analizzare questa descrizione.
    *   Inizializza un contatore `stati_senza_uscite = 0`.
    *   Itera su ogni stato `q` nell'insieme (finito) degli stati di `Mᵢ`.
    *   Per ogni stato `q`, controlla la lista (finita) delle transizioni. Verifica se esiste almeno una transizione che parte dallo stato `q`.
    *   Se non esiste nessuna transizione che parte da `q`, incrementa il contatore `stati_senza_uscite`.
4.  **Passo 3: Confronta e Decidi**.
    *   Dopo aver controllato tutti gli stati, confronta il valore finale del contatore `stati_senza_uscite` con l'input originale `i`.
    *   Se `stati_senza_uscite == i`, l'algoritmo si ferma e risponde **"sì"** (`i` appartiene a `T`).
    *   Se `stati_senza_uscite != i`, l'algoritmo si ferma e risponde **"no"** (`i` non appartiene a `T`).

Poiché ogni passo di questo algoritmo è un'operazione su dati finiti (decodifica, iterazione su un insieme finito di stati e transizioni, confronto di numeri), l'algoritmo **termina sempre** e fornisce la risposta corretta. Pertanto, l'insieme `T` è **ricorsivo**.
# DATA FORMULA DESCRIVO LINGUAGGIO


## Es1

La formula è il cuore del problema. Analizziamola per capire cosa significa in linguaggio naturale.

`F: ∀x∀y∀z (a(x)∧a(y)∧a(z)∧x < y ∧y < z) → (∃x′(x < x′ ∧x′ < y)∨∃y′(y < y′ ∧y′ < z))`

Questa è un'implicazione logica del tipo `P → Q`. Una stringa appartiene al linguaggio `L(F)` se la formula `F` è vera per quella stringa.

**Analizziamo la parte `P` (l'antecedente):**
*   `∀x∀y∀z`: "Per ogni tre posizioni `x`, `y`, e `z` nella stringa..."
*   `x < y ∧ y < z`: "...tali che `x` viene prima di `y`, e `y` viene prima di `z`..."
*   `a(x)∧a(y)∧a(z)`: "...e in tutte e tre queste posizioni c'è il carattere 'a'..."

Quindi, la parte `P` significa: **"Se nella stringa esistono tre 'a' in tre posizioni distinte e ordinate..."**

**Analizziamo la parte `Q` (il conseguente):**
*   `∃x′(x < x′ ∧x′ < y)`: "...allora deve esistere almeno una posizione `x'` tra la posizione della prima 'a' (`x`) e la seconda 'a' (`y`)." Questo significa che la prima e la seconda 'a' **non sono adiacenti**.
*   `∨`: "OPPURE"
*   `∃y′(y < y′ ∧y′ < z)`: "...deve esistere almeno una posizione `y'` tra la posizione della seconda 'a' (`y`) e la terza 'a' (`z`)." Questo significa che la seconda e la terza 'a' **non sono adiacenti**.

Quindi, la parte `Q` significa: **"...allora o le prime due 'a' non sono adiacenti, o le seconde due 'a' non sono adiacenti."**

**Mettendo tutto insieme (P → Q):**
La formula F dice: "Per ogni occorrenza di tre 'a' in ordine nella stringa, non è possibile che siano tutte e tre consecutive."
In modo ancora più semplice, una stringa rende vera la formula `F` se e solo se **non contiene la sottostringa "aaa"**. Se una stringa non ha tre 'a', l'antecedente `P` è falso, e l'implicazione `Falso → QualsiasiCosa` è sempre vera. Se ha tre 'a', ma non sono consecutive, l'antecedente `P` è vero e anche il conseguente `Q` è vero, quindi `Vero → Vero` è vero. L'unico caso in cui la formula è falsa è quando `P` è vero e `Q` è falso (`Vero → Falso`), cioè quando esistono tre 'a' e sono tutte consecutive.

**Conclusione chiave:** `L(F)` è il linguaggio di tutte le stringhe che **non contengono la sottostringa "aaa"**.

---

### Domanda 1: Linguaggio L' con Σ = {a}

*   **Descrizione del linguaggio:** Dobbiamo trovare tutte le stringhe composte solo da 'a' che non contengono "aaa".
    *   `ε` (stringa vuota): non contiene "aaa". OK.
    *   `a`: non contiene "aaa". OK.
    *   `aa`: non contiene "aaa". OK.
    *   `aaa`: contiene "aaa". NO.
    *   `aaaa`: contiene "aaa". NO.
*   Le uniche stringhe possibili sono `ε`, `a`, e `aa`. Questo è l'insieme di tutte le stringhe sull'alfabeto {a} di **lunghezza inferiore a 3**.
*   **Soluzione:** `L' = {w ∈ Σ* | |w| < 3}`. Questo corrisponde alla soluzione fornita.

---

### Domanda 2: Linguaggio L'' con Σ = {a, b}

*   **Descrizione del linguaggio:** Dobbiamo trovare tutte le stringhe composte da 'a' e 'b' che non contengono "aaa".
*   Questo è semplicemente il complemento del linguaggio di tutte le stringhe che *contengono* "aaa". Il linguaggio delle stringhe contenenti "aaa" può essere descritto dall'espressione regolare `(a|b)*aaa(a|b)*`.
*   Usando la notazione della soluzione, `Σ*` è `(a|b)*` e `a³` è `aaa`. Quindi il linguaggio da escludere è `Σ*a³Σ*`.
*   **Soluzione:** `L'' = ¬(Σ*a³Σ*)`. Questo corrisponde alla soluzione fornita.

---

### Domanda 3: Automi o Grammatiche a Potenza Minima

#### Per L' = {ε, a, aa}
*   **Tipo di linguaggio:** È un linguaggio **finito**. Tutti i linguaggi finiti sono **regolari**.
*   **Modello a potenza minima:** Automa a Stati Finiti (FSA) o Grammatica Regolare.
*   **Grammatica Regolare:**
    *   Dobbiamo generare `ε`, `a`, `aa`.
    *   `S → ε` (per la stringa vuota)
    *   `S → a` (per la stringa "a")
    *   Per "aa", non possiamo scrivere `S → aa` in una grammatica regolare. Introduciamo un altro stato (variabile non terminale):
    *   `S → aA` (genera la prima 'a' e passa allo stato `A`)
    *   `A → a` (genera la seconda 'a' e termina)
    *   Unendo tutto: `S → ε | a | aA` e `A → a`. La soluzione `S → ε | aA | a` e `A → a` è una variante equivalente e corretta.

#### Per L'' = ¬(Σ*a³Σ*)
*   **Tipo di linguaggio:** È il complemento di un linguaggio regolare (`Σ*a³Σ*`). I linguaggi regolari sono chiusi rispetto all'operazione di complemento, quindi `L''` è anch'esso **regolare**.
*   **Modello a potenza minima:** Automa a Stati Finiti (FSA) o Grammatica Regolare.
*   **Costruzione (intuizione tramite automa):** Possiamo costruire un automa che riconosce `L''`. L'idea è tenere traccia di quante 'a' consecutive abbiamo appena letto.
    *   **Stato S (start):** Non abbiamo 'a' consecutive (o l'ultima lettera era 'b'). Stato accettante.
    *   **Stato A:** Abbiamo appena letto una 'a'. Stato accettante.
    *   **Stato B:** Abbiamo appena letto due 'a' consecutive. Stato accettante.
    *   **(Stato C, non necessario nella grammatica):** Uno stato "trappola" non accettante in cui si finisce dopo aver letto la terza 'a' consecutiva.
*   **Grammatica Regolare (traducendo l'automa):**
    *   Da `S` (zero 'a'):
        *   Se leggo `b`, resto in `S`: `S → bS`.
        *   Se leggo `a`, vado in `A`: `S → aA`.
        *   Poiché S è accettante, posso terminare: `S → ε | b | a`.
    *   Da `A` (una 'a'):
        *   Se leggo `b`, torno a `S`: `A → bS`.
        *   Se leggo `a`, vado in `B`: `A → aB`.
        *   Poiché A è accettante, posso terminare: `A → b | a`.
    *   Da `B` (due 'a'):
        *   Se leggo `b`, torno a `S`: `B → bS`.
        *   Se leggo `a`, andrei nello stato trappola (derivazione fallisce, non c'è una regola).
        *   Poiché B è accettante, posso terminare: `B → b`.
*   La grammatica fornita nella soluzione `S → ε | bS | b | aA | a`, `A→bS |b|aB |a`, `B →bS|b` è una formalizzazione di questa logica ed è corretta.

# DATO AUTOMA(DISEGNO)
![enter image description here](https://github.com/Tiopio01/API/blob/master/image.png)
![enter image description here](https://github.com/Tiopio01/API/blob/master/Cattura.JPG)

# Indefinito

## Es 1

Sia `L` un linguaggio **decidibile** definito sull’alfabeto `A` e `L̄` il suo complemento. Barrare le caselle opportune e motivare la propria risposta con esempi o dimostrazioni che la supportino.

**a) `L` è infinito.**
Necessariamente □ Possibilmente □ Mai □

**b) `L̄` è infinito.**
Necessariamente □ Possibilmente □ Mai □

**c) Se `L` è fissato, il problema di stabilire se `L` è infinito è deciso.**
Vero □ Falso □ Dipende da L □

---

### Spiegazione e Analisi della Soluzione

#### **a) `L` è infinito.**

**Risposta Corretta:** Possibilmente.

**Motivazione:**
Un linguaggio è **decidibile** se esiste un algoritmo che, per qualsiasi stringa, termina sempre e dice correttamente se la stringa appartiene o meno al linguaggio. La domanda è: un linguaggio con questa proprietà deve essere per forza infinito? O non può mai esserlo? O a volte sì e a volte no?

Per dimostrare che la risposta è "Possibilmente", dobbiamo fornire due esempi di linguaggi decidibili: uno che sia infinito e uno che sia finito.

1.  **Esempio di linguaggio decidibile e infinito:**
    *   Consideriamo il linguaggio `L₁ = A*`, cioè l'insieme di **tutte** le stringhe possibili sull'alfabeto `A`.
    *   Questo linguaggio è chiaramente **infinito** (se `A` non è vuoto).
    *   È **decidibile**? Sì. L'algoritmo per deciderlo è banale: "Data una stringa `w`, rispondi sempre 'Sì'". Questo algoritmo termina sempre ed è sempre corretto.

2.  **Esempio di linguaggio decidibile e finito:**
    *   Consideriamo il linguaggio `L₂ = ∅`, cioè il **linguaggio vuoto**, che non contiene alcuna stringa.
    *   Questo linguaggio è chiaramente **finito** (contiene 0 stringhe).
    *   È **decidibile**? Sì. L'algoritmo per deciderlo è altrettanto banale: "Data una stringa `w`, rispondi sempre 'No'".

Poiché abbiamo trovato esempi validi per entrambi i casi (finito e infinito), la proprietà non è né necessaria né impossibile. Quindi, è **possibile**.

---

#### **b) `L̄` è infinito.**

**Risposta Corretta:** Possibilmente.

**Motivazione:**
Qui la domanda è la stessa, ma applicata al complemento `L̄`. Un teorema fondamentale della teoria della computabilità afferma che **se un linguaggio `L` è decidibile, anche il suo complemento `L̄` è decidibile**. (L'algoritmo per `L̄` è: esegui l'algoritmo per `L` e inverti la risposta).

Quindi, possiamo usare i complementi degli esempi precedenti:


1.  **Esempio in cui il complemento è finito:**
   *   Prendiamo `L = A*`. Abbiamo visto che è decidibile.
    *   Il suo complemento `L̄` è l'insieme di tutte le stringhe che non sono in `A*`, cioè `∅` (il linguaggio vuoto).
    *   `L̄ = ∅` è **finito**.

2.  **Esempio in cui il complemento è infinito:**
    *   Prendiamo `L = ∅`. Abbiamo visto che è decidibile.
    *   Il suo complemento `L̄` è l'insieme di tutte le stringhe che non sono nel linguaggio vuoto, cioè `A*`.
    *   `L̄ = A*` è **infinito**.

Ancora una volta, abbiamo trovato esempi validi per entrambi i casi, quindi la risposta è **possibile**.

---

#### **c) Se `L` è fissato, il problema di stabilire se `L` è infinito è deciso.**

**Risposta Corretta:** Dipende da L.

**Motivazione:**
Questa è la domanda più sottile e interessante. Analizziamola attentamente.
*   "**`L` è fissato**": Non stiamo parlando di un linguaggio generico, ma di uno specifico, ad esempio "il linguaggio di tutte le stringhe con un numero pari di 'a'".
*   "**Il problema è deciso**": Un problema è "deciso" se la sua risposta è una costante booleana ("Sì" o "No"), anche se noi non sappiamo quale sia. Un problema con una risposta costante è, per definizione, decidibile (l'algoritmo è semplicemente `return true` o `return false`).

Per un qualsiasi `L` specifico, la proprietà "essere infinito" è una caratteristica intrinseca di `L`. O `L` è infinito (la risposta è "Sì"), o è finito (la risposta è "No"). Non può essere entrambe le cose. Quindi, tecnicamente, per ogni `L` fissato, la risposta è una costante, e il problema è deciso.

Tuttavia, la soluzione "Dipende da L" e l'esempio dei numeri primi gemelli evidenziano un punto cruciale: **potremmo non essere in grado di determinare quale sia la risposta**.

**Spiegazione dell'esempio dei numeri primi gemelli:**
1.  **Definizione:** Una coppia di primi gemelli è una coppia di numeri primi `(p, p+2)`, come (11, 13).
2.  **La Congettura:** La Congettura dei Primi Gemelli afferma che esistono infinite coppie di primi gemelli. Questa è una delle domande più famose e **irrisolte** della matematica.
3.  **Costruiamo il linguaggio `L`:**
    `L = {n | esiste una coppia di primi gemelli (p, p+2) con p > n}`.
    Cioè, `L` contiene un numero `n` se da qualche parte dopo `n` c'è un'altra coppia di primi gemelli.

4.  **`L` è decidibile? SÌ.** Sembra strano, ma lo è. Ci sono solo due possibilità per come è fatto l'universo:
    *   **Caso A: La congettura è vera.** Esistono infinite coppie di primi gemelli. In questo caso, per *qualsiasi* `n`, troveremo sempre una coppia più grande. Quindi `L` contiene tutti i numeri naturali (`L = ℕ`). Il linguaggio `ℕ` è decidibile.
    *   **Caso B: La congettura è falsa.** Esiste una coppia di primi gemelli più grande di tutte, `(p_max, p_max+2)`. In questo caso, `L` contiene tutti i numeri `n < p_max`. Per qualsiasi `n ≥ p_max`, non ci sono coppie più grandi. Quindi `L` è un insieme **finito**. Ogni linguaggio finito è decidibile.

    Poiché in entrambi gli scenari possibili `L` risulta essere un linguaggio decidibile, possiamo concludere che `L` **è decidibile**, anche se non sappiamo quale dei due scenari sia quello vero.

5.  **Il problema "L è infinito?" è deciso?**
    *   Se il Caso A è vero, `L` è infinito. La risposta è "Sì".
    *   Se il Caso B è vero, `L` è finito. La risposta è "No".

La risposta è una costante ("Sì" o "No"), ma **allo stato attuale delle conoscenze matematiche, non sappiamo quale sia**. Ecco perché la soluzione dice "Dipende da L": anche se per questo `L` fissato il problema è teoricamente deciso, noi non possiamo scrivere l'algoritmo (`return true` o `return false`) perché non sappiamo quale dei due sia quello corretto.
## Es 2
### Concetti Chiave Preliminari

-   **Decidibile (o Ricorsivo):** Un insieme di indici è decidibile se esiste un algoritmo (una MT) che, dato un qualsiasi indice i, termina **sempre** e risponde correttamente "sì" (se i è nell'insieme) o "no" (se i non è nell'insieme).
    
-   **Semi-decidibile (o Ricorsivamente Enumerabile):** Un insieme di indici è semi-decidibile se esiste un algoritmo che, dato un indice i, termina e risponde "sì" se i è nell'insieme. Se i non è nell'insieme, l'algoritmo può rispondere "no" oppure **non terminare mai**.
    
-   **Teorema di Rice:** Afferma che qualsiasi proprietà **non banale** del **linguaggio** riconosciuto da una MT è indecidibile.
    
    -   **Proprietà del linguaggio:** Riguarda ciò che la macchina accetta (L(M)), non come è fatta (numero di stati, ecc.).
        
    -   **Non banale:** Esiste almeno una MT che ha la proprietà e almeno una che non ce l'ha.
        

----------

### **1. S1: L'insieme di indici delle MT che accettano almeno una stringa di lunghezza k.**

#### **S1 è decidibile? NO.**

-   **Motivazione (Teorema di Rice):** Applichiamo il Teorema di Rice.
    
    1.  La proprietà "accettare almeno una stringa di lunghezza k" è una proprietà del linguaggio riconosciuto dalla macchina? **Sì**.
        
    2.  È una proprietà non banale? **Sì**, perché:
        
        -   Esiste una MT con questa proprietà (es. una macchina che accetta tutte le stringhe, A*).
            
        -   Esiste una MT senza questa proprietà (es. una macchina che non accetta nessuna stringa, riconoscendo il linguaggio vuoto ∅).  
            Poiché entrambe le condizioni sono soddisfatte, per il Teorema di Rice, l'insieme S1  **non è decidibile**.
            

#### **S1 è semi-decidibile? SÌ.**

-   **Motivazione (Ricerca Esaustiva):** La struttura della domanda ("almeno una") ci suggerisce che se la risposta è "sì", possiamo trovarne la prova. Dobbiamo costruire un algoritmo che termini e dica "sì" per ogni i ∈ S1.
    
    -   **Algoritmo:**
        
        1.  Dato un indice i, elenca tutte le stringhe di lunghezza k. Poiché k è un intero fissato e A è un alfabeto finito, questo è un **insieme finito** di stringhe.
            
        2.  Simula l'esecuzione della macchina Mᵢ su **tutte** queste stringhe "in parallelo" (usando la tecnica del **dovetailing** o interleaving, per evitare di rimanere bloccati su una computazione che non termina).
            
        3.  **Se anche solo una di queste simulazioni si ferma e accetta**, l'algoritmo si arresta immediatamente e restituisce "sì".
            
    -   **Comportamento:** Se Mᵢ accetta almeno una stringa di lunghezza k, questo algoritmo la troverà prima o poi e terminerà. Se Mᵢ non accetta nessuna stringa di lunghezza k, l'algoritmo non terminerà mai. Questo è esattamente il comportamento richiesto per un problema semi-decidibile.
        

----------

### **2. S2: L'insieme di indici delle MT che accettano al più una stringa di lunghezza k.**

#### **S2 è decidibile? NO.**

-   **Motivazione (Teorema di Rice):** Il ragionamento è identico a quello per S1.
    
    1.  La proprietà "accettare al più una stringa di lunghezza k" (cioè 0 o 1 stringhe) è una proprietà del linguaggio. **Sì**.
        
    2.  È non banale? **Sì**, perché:
        
        -   Una MT che riconosce ∅ ha questa proprietà.
            
        -   Una MT che riconosce A* non ha questa proprietà (se |A|ᵏ > 1).  
            Per il Teorema di Rice, l'insieme S2  **non è decidibile**.
            

#### **S2 è semi-decidibile? NO.**

-   **Motivazione (Uso del Complemento):** Per dimostrare che un insieme non è semi-decidibile, una tecnica standard è dimostrare che il suo **complemento è semi-decidibile**. Esiste un teorema fondamentale: Se un insieme S e il suo complemento S̄ sono entrambi semi-decidibili, allora S è decidibile.  
    Poiché abbiamo già stabilito che S2 è indecidibile, se riusciamo a dimostrare che S̄2 è semi-decidibile, allora S2 non può esserlo.
    
    1.  **Definiamo il complemento S̄2:** È l'insieme degli indici delle MT che **non** accettano al più una stringa di lunghezza k. Questo significa: l'insieme di indici delle MT che accettano **almeno due** stringhe di lunghezza k.
        
    2.  **Dimostriamo che S̄2 è semi-decidibile:** La logica è la stessa usata per S1.
        
        -   **Algoritmo per S̄2:**
            
            1.  Dato i, elenca tutte le stringhe di lunghezza k.
                
            2.  Simula Mᵢ su tutte queste stringhe in parallelo.
                
            3.  Tieni un contatore delle stringhe accettate.
                
            4.  **Non appena il contatore raggiunge 2**, l'algoritmo si arresta e restituisce "sì".
                
        -   Questo algoritmo termina se e solo se Mᵢ accetta almeno due stringhe di lunghezza k. Quindi, S̄2  **è semi-decidibile**.
            
    3.  **Conclusione:** Poiché S2 è indecidibile e il suo complemento S̄2 è semi-decidibile, S2  **non può essere semi-decidibile**.
        

----------

### **3. S3: L'insieme di indici delle MT che calcolano la funzione caratteristica di S2.**

#### **S3 è decidibile? SÌ.**

#### **S3 è semi-decidibile? SÌ.**

-   **Motivazione (Conseguenza della non decidibilità):**
    
    1.  Cos'è la "funzione caratteristica" di un insieme S? È una funzione totale che restituisce 1 se l'input è in S e 0 altrimenti.
        
    2.  Per definizione, un insieme è **decidibile** se e solo se la sua funzione caratteristica è **calcolabile** (cioè, esiste una MT che la calcola).
        
    3.  Nel punto precedente, abbiamo dimostrato in modo definitivo che l'insieme S2 è **indecidibile**.
        
    4.  Questo significa, per definizione, che **non esiste alcuna MT** in grado di calcolare la sua funzione caratteristica.
        
    5.  Quindi, l'insieme S3, che dovrebbe contenere gli indici di tali macchine, è necessariamente l'**insieme vuoto (∅)**.
        
    
    -   **Il problema si riduce a: "L'insieme vuoto è decidibile?"** La risposta è **sì**. L'algoritmo per deciderlo è banale: "Dato un qualsiasi indice i, rispondi sempre 'no'". Questo algoritmo termina sempre ed è sempre corretto.
        
    -   Poiché S3 è decidibile, è anche, per definizione, semi-decidibile.
  
  ## Es 3



Si consideri il linguaggio L = {0ⁿ | n ∈ N e 0ⁿ appare nell’espansione decimale di π}.
Il linguaggio L è regolare? Si motivi esaurientemente la risposta.

---



Il linguaggio `L` è un insieme di stringhe. Le uniche stringhe che possono appartenere a `L` sono quelle composte solo da zeri (es. "0", "00", "00000", e anche la stringa vuota ε, che corrisponde a n=0, cioè una sequenza di zero zeri).

La condizione per cui una di queste stringhe appartiene a `L` è che quella sequenza di zeri deve apparire da qualche parte nei decimali di π (3.14159...).

*   **Esempio 1:** La stringa "0" appartiene a L? Dobbiamo cercare se c'è almeno uno "0" nei decimali di π. Sì, c'è (la 32ª cifra decimale è uno 0). Quindi "0" ∈ L.
*   **Esempio 2:** La stringa "000000" appartiene a L? Sì, è famoso il "punto di Feynman", una sequenza di sei 9 consecutivi che inizia alla 762ª cifra decimale. Allo stesso modo, si sa che esistono sequenze di zeri.
*   **Esempio 3:** La stringa "0000000000" (dieci zeri) appartiene a L? E una stringa con un miliardo di zeri?

Qui sta il punto cruciale: **la matematica non sa ancora con certezza se π sia un "numero normale"**, cioè un numero la cui espansione decimale contiene ogni possibile sequenza finita di cifre. Si sospetta di sì, ma non è stato dimostrato.

---

### **Spiegazione della Soluzione: Il Ragionamento per Casi**

Poiché non conosciamo la risposta definitiva sulla natura di π, l'unico modo per risolvere il problema è considerare **tutte le possibilità logiche**. Per la sequenza di zeri in π, ci sono solo due scenari possibili nell'universo:

#### **Caso 1: Esiste una sequenza "massima" di zeri.**

*   **Cosa significa:** Immaginiamo che un giorno un matematico scopra che la più lunga sequenza di zeri consecutivi che appare in π abbia, ad esempio, lunghezza 15 (`k=15`). Questo significherebbe che la stringa `0¹⁵` si trova in π, ma la stringa `0¹⁶` non si troverà mai, per quanto si continui a calcolare le cifre.
*   **Come sarebbe fatto `L` in questo caso?** Se esistesse un tale limite `k`, il nostro linguaggio `L` sarebbe composto da un numero **finito** di stringhe:
    `L = {ε, "0", "00", "000", ..., "0ᵏ"}`
*   **Questo linguaggio è regolare? SÌ.** Un teorema fondamentale della teoria dei linguaggi formali afferma che **tutti i linguaggi finiti sono regolari**. Un linguaggio finito può sempre essere descritto da un'espressione regolare semplicemente elencando tutte le sue stringhe, separate dal simbolo di unione `|`. Come dice la soluzione:
    `Espressione Regolare: ε | 0 | 00 | ... | 0ᵏ`
    Poiché in questo scenario `L` è un linguaggio finito, `L` sarebbe regolare.

#### **Caso 2: Non esiste una sequenza "massima" di zeri.**

*   **Cosa significa:** Questo scenario corrisponde alla credenza (non provata) che π sia un numero normale. Significherebbe che per qualsiasi lunghezza `n` tu possa immaginare (un milione, un miliardo, un trilione), prima o poi, se calcoli abbastanza cifre di π, troverai una sequenza di `n` zeri consecutivi.
*   **Come sarebbe fatto `L` in questo caso?** Il nostro linguaggio `L` conterrebbe tutte le possibili stringhe di zeri, di qualsiasi lunghezza:
    `L = {ε, "0", "00", "000", "0000", ...}` (un insieme infinito)
*   **Questo linguaggio è regolare? SÌ.** Questo insieme è esattamente il linguaggio descritto dalla famosissima espressione regolare:
    `Espressione Regolare: 0*`
    (che significa "zero o più occorrenze del simbolo 0").
    Poiché in questo scenario `L` può essere descritto da un'espressione regolare, `L` sarebbe regolare.

---

### **Conclusione Finale**

Abbiamo analizzato i due unici scenari logicamente possibili per la natura del linguaggio `L`:
1.  O `L` è un linguaggio finito (se c'è un limite agli zeri in π).
2.  O `L` è il linguaggio `0*` (se non c'è un limite).

In **entrambi i casi**, il linguaggio risultante è **regolare**.

Poiché, indipendentemente dalla verità matematica su π, il linguaggio `L` è destinato a essere regolare, possiamo concludere con certezza che **SÌ, il linguaggio L è regolare**.

La parte affascinante e controintuitiva è che, sebbene possiamo dimostrare che `L` *è* regolare, allo stato attuale non siamo in grado di dire *quale* dei due automi finiti o delle due espressioni regolari sia quella corretta per descriverlo.
## Es 4
Certamente! Questo è un esercizio molto interessante che esplora la relazione tra linguaggi regolari, logica monadica del primo ordine (MFO) e la classe dei linguaggi "star-free". Analizziamolo in dettaglio.

### **Traccia dell'Esercizio (formattata e chiarita)**

Si consideri il linguaggio `L1` tale che `L1ᶜ = L2`, dove `L2 = (ab)⁺`.
L'alfabeto è `{a, b}`.

a) Si definisca `L1` nella logica MFO, se possibile, altrimenti se ne motivi l'impossibilità.
b) **Bonus:** Con riferimento alle proprietà dei linguaggi star-free, si chiarisca se è possibile fornire un'espressione insiemistica per `L1` facendo uso solo di `{∅}`, `{a}`, `{b}`, unione `∪`, intersezione `∩`, complemento `ᶜ` e concatenamento `⋅`, **senza** usare gli operatori di Kleene (`*` e `+`).

---

### **Analisi Preliminare: Capire i Linguaggi `L2` e `L1`**

*   **Linguaggio `L2 = (ab)⁺`:**
    *   **Descrizione:** Questo è il linguaggio delle stringhe che consistono in una o più ripetizioni della sequenza "ab".
    *   **Esempi:** `ab`, `abab`, `ababab`, ...
    *   **Proprietà:** È un linguaggio **regolare**. Tuttavia, **non è star-free**. Un linguaggio è star-free se la sua espressione regolare non richiede "essenzialmente" l'operatore stella di Kleene. `(ab)⁺` non può essere riscritto senza un operatore di ripetizione. Formalmente, questo linguaggio ha una proprietà di "conteggio modulo 2" (la lunghezza è sempre pari, e i caratteri si alternano), che è una caratteristica dei linguaggi non star-free.

*   **Linguaggio `L1 = L2ᶜ = ((ab)⁺)ᶜ`:**
    *   **Descrizione:** `L1` è il **complemento** di `L2`. Contiene tutte le stringhe sull'alfabeto `{a, b}` che **non** sono della forma `(ab)ⁿ` con `n≥1`.
    *   **Proprietà:** I linguaggi regolari sono chiusi rispetto al complemento. Poiché `L2` è regolare, anche `L1` è **regolare**.
    *   **La domanda chiave:** Se `L2` non è star-free, cosa possiamo dire di `L1`? Anche `L1` **non è star-free**. La classe dei linguaggi star-free è chiusa rispetto al complemento. Se `L1` fosse star-free, allora anche il suo complemento `(L1)ᶜ = L2` dovrebbe esserlo, ma sappiamo che non è così.

---

### **a) Definizione di `L1` in MFO**

La domanda chiede di definire `L1` in MFO. Ma c'è un teorema fondamentale:
**Un linguaggio è definibile in MFO se e solo se è star-free.**

Come abbiamo appena stabilito, `L1` **non è star-free**.

**Conclusione:** Non è possibile definire `L1` nella logica MFO.

**Motivazione dell'impossibilità:**
Il linguaggio `L1 = ((ab)⁺)ᶜ` non è star-free. Un linguaggio è definibile in MFO se e solo se è star-free, pertanto non esiste una formula MFO che caratterizzi `L1`. La logica MFO non ha la capacità di esprimere proprietà di "conteggio modulo k", come l'alternanza richiesta per definire (o escludere) `(ab)⁺`.

*(Nota: La soluzione fornita nell'immagine è **errata**. La formula che viene data non descrive correttamente il linguaggio `L1` e, più in generale, una tale formula non può esistere. La formula fornita sembra descrivere il linguaggio delle stringhe che iniziano con 'a', finiscono con 'b' e in cui ogni 'a' è seguita da una 'b' e ogni 'b' è seguita da una 'a', ma questo è proprio il linguaggio `(ab)⁺` (più forse `a(ba)*`), non il suo complemento).*

---

### **b) Bonus: Espressione Insiemistica per `L1` senza Operatori di Kleene**

La domanda chiede se è possibile scrivere `L1` usando solo operazioni di base (unione, intersezione, complemento, concatenazione) senza `*` o `+`.

Questo è un altro modo per chiedere: "**È `L1` un linguaggio star-free?**".
La definizione formale di un linguaggio star-free è proprio quella di un linguaggio che può essere costruito a partire dagli insiemi finiti usando solo le operazioni booleane (unione, intersezione, complemento) e la concatenazione.

Come abbiamo già stabilito, `L1` **non è star-free**.

**Conclusione:** No, non è possibile fornire una tale espressione per `L1`.

**Motivazione:**
Fornire un'espressione per `L1` che non usi gli operatori di Kleene (`*` e `+`) è, per definizione, la prova che il linguaggio è star-free. Tuttavia, il linguaggio `L1` non è star-free. Il motivo è che il suo complemento, `L2 = (ab)⁺`, possiede una struttura ciclica intrinseca (un "conteggio modulo 2") che non può essere "spezzata" o descritta senza un qualche tipo di operatore di chiusura/ripetizione. La classe dei linguaggi star-free è chiusa per complemento, quindi se `L2` non è star-free, neanche `L1` può esserlo.

*(Nota: Anche la soluzione fornita per il punto (b) nell'immagine è **errata**. L'espressione data descrive un sottoinsieme di `L1`. Ad esempio, esclude `aa` e `bb` (corretto), ma esclude anche la stringa `b` (inizia con `b` e non finisce con `b`), e `b` non è in `L2`, quindi dovrebbe essere in `L1`. L'espressione fornita è un tentativo di "rompere il ciclo" di `(ab)⁺` elencando i "fallimenti" possibili, ma non riesce a catturare la natura infinita e periodica del linguaggio da escludere).*

## ES 5
Si definisce **Riconoscitore ad Automi Gemelli (RAG)** un meccanismo di calcolo ottenuto facendo operare due automi sullo stesso nastro di ingresso. Gli automi operano indipendentemente, ognuno con la propria testina. La parola in ingresso si considera riconosciuta se e solo se **entrambi** gli automi la riconoscono.

Si consideri il caso dei RAG costruiti come segue e si dica se il loro potere riconoscitore è **maggiore, minore o uguale** a quello delle loro componenti:

a) RAG costituito da un automa a stati finiti **deterministico (DFA)** e uno **non deterministico (NFA)**.
b) RAG costituito da un automa a stati finiti **deterministico (DFA)** ed un automa a pila **deterministico (DPDA)**.
c) RAG costituito da due automi a pila **non deterministici (NPDA)**.

---

### **Il Concetto Chiave: Intersezione dei Linguaggi**

Prima di analizzare i singoli punti, è fondamentale capire cosa fa un RAG. La definizione dice che una stringa `w` è accettata dal RAG se e solo se:
*   L'automa 1 (`A1`) accetta `w`.
*   **E** l'automa 2 (`A2`) accetta `w`.

Questo significa che il linguaggio riconosciuto dal RAG, `L(RAG)`, è l'**intersezione** dei linguaggi riconosciuti dai due automi componenti:

`L(RAG) = L(A1) ∩ L(A2)`

Ora, per ogni punto, la domanda si riduce a: "Cosa succede quando intersechiamo i linguaggi di questi tipi di automi? Il linguaggio risultante appartiene alla stessa classe, a una classe meno potente o a una classe più potente?" Questo ci porta al concetto di **proprietà di chiusura** delle classi di linguaggi.

---

### **a) RAG = DFA + NFA**

*   **Linguaggi Coinvolti:**
    *   `L(DFA)` è un linguaggio **Regolare**.
    *   `L(NFA)` è anch'esso un linguaggio **Regolare**. (Un teorema fondamentale afferma che DFA e NFA hanno lo stesso potere espressivo e riconoscono la stessa classe di linguaggi).
*   **Operazione:** Stiamo calcolando l'intersezione di due linguaggi regolari: `Regolare ∩ Regolare`.
*   **Proprietà di Chiusura:** La classe dei linguaggi regolari **è chiusa** rispetto all'operazione di intersezione. Questo significa che se prendi due linguaggi regolari qualsiasi e fai la loro intersezione, il risultato è garantito essere ancora un linguaggio regolare.
*   **Conclusione:** Il linguaggio `L(RAG)` è regolare. Il potere riconoscitivo del RAG non supera quello di un singolo DFA o NFA.

**Risposta:** Il potere riconoscitore è **UGUALE** a quello delle sue componenti.

---

### **b) RAG = DFA + DPDA**

*   **Linguaggi Coinvolti:**
    *   `L(DFA)` è un linguaggio **Regolare**.
    *   `L(DPDA)` è un linguaggio **Libero dal Contesto Deterministico (DCFL)**.
*   **Operazione:** Stiamo calcolando `Regolare ∩ DCFL`.
*   **Proprietà di Chiusura:** La classe dei linguaggi liberi dal contesto deterministici (DCFL) **è chiusa** rispetto all'intersezione con un linguaggio regolare. Il risultato è sempre un DCFL.
*   **Spiegazione Alternativa (Costruttiva):** Come suggerisce la soluzione, possiamo immaginare di costruire un nuovo DPDA che simuli i due automi contemporaneamente. I suoi stati sarebbero coppie `(q_dfa, q_dpda)`, dove `q_dfa` è uno stato del DFA e `q_dpda` è uno stato del DPDA. Per ogni mossa, il nuovo automa aggiorna sia la componente di stato del DFA che quella del DPDA, usando la pila come farebbe il DPDA originale. L'accettazione avviene solo se entrambe le componenti si trovano in uno stato finale. Poiché questa "macchina prodotto" è ancora un DPDA, il linguaggio risultante è un DCFL.
*   **Conclusione:** Il potere del RAG è uguale a quello del suo componente più potente, il DPDA.

**Risposta:** Il potere riconoscitore è **UGUALE** a quello di un automa a pila deterministico.

---

### **c) RAG = NPDA + NPDA**

*   **Linguaggi Coinvolti:**
    *   `L(NPDA)` è un linguaggio **Libero dal Contesto (CFL)**.
    *   Anche il secondo `L(NPDA)` è un CFL.
*   **Operazione:** Stiamo calcolando `CFL ∩ CFL`.
*   **Proprietà di Chiusura:** La classe dei linguaggi liberi dal contesto **NON è chiusa** rispetto all'intersezione. Questo è un risultato famosissimo e fondamentale. Significa che l'intersezione di due CFL può produrre un linguaggio che non è più libero dal contesto (e che quindi non può essere riconosciuto da un singolo NPDA).
*   **L'Esempio Classico:**
    *   Sia `L(A1) = {aⁿbⁿcᵐ | n, m ≥ 1}`. Questo è un CFL (conta le `a` e le `b` con la pila, poi ignora le `c`).
    *   Sia `L(A2) = {aᵐbⁿcⁿ | n, m ≥ 1}`. Anche questo è un CFL (ignora le `a`, poi conta le `b` e le `c` con la pila).
    *   La loro intersezione `L(A1) ∩ L(A2)` è il linguaggio `{aⁿbⁿcⁿ | n ≥ 1}`.
    *   Questo linguaggio (`aⁿbⁿcⁿ`) è l'esempio "modello" di un linguaggio che **non è libero dal contesto**, ma è **sensibile al contesto**. Richiede più memoria di una semplice pila per essere riconosciuto.
*   **Conclusione:** Poiché il RAG può riconoscere `{aⁿbⁿcⁿ}`, che nessun singolo NPDA può riconoscere, il potere del RAG è superiore a quello di un singolo NPDA.

**Risposta:** Il potere riconoscitore è **MAGGIORE** di quello di un automa a pila non deterministico.