deleted history

BSc(italian)/Algoritmi e Principi dell'Informatica/Algoritmi e Principi dell'Informatica.md

@@ -0,0 +1,34 @@
+[Linguaggi](src/01.Linguaggi.md)
+
+[Automi a stati finiti](src/02.Automi%20a%20stati%20finiti.md)
+
+[Automi a Pila](src/03.Automi%20a%20Pila.md)
+
+[Macchina di Touring](src/04.Macchina%20di%20Touring.md)
+
+[Grammatiche Formali](src/05.Grammatiche%20Formali.md)
+
+[Formulazione con Logica](src/06.Formulazione%20con%20Logica.md) 
+
+[Computabilità](src/07.Computabilità.md)
+
+---
+
+[Analisi complessità](src/08.Analisi%20complessità.md)
+
+[RAM](src/09.RAM.md)
+
+[Sorting](src/10.Sorting.md) 
+
+[Strutture dati](src/11.Strutture%20dati.md)
+
+[Alberi e grafi](src/12.Alberi%20e%20grafi.md)
+
+[Seminario Api](src/13.Seminario%20Api.md) 
+
+
+
+
+
+
+

BSc(italian)/Algoritmi e Principi dell'Informatica/buildAPI.sh

@@ -0,0 +1,2 @@
+echo $(pandoc --resource-path=src:src/images src/*.md -o api.pdf -f markdown-implicit_figures)
+echo "PDF generated for Algoritmi e Principi dell'Informatica"

BSc(italian)/Algoritmi e Principi dell'Informatica/src/00.Header.md

@@ -0,0 +1,16 @@
+---
+title: "Algoritmi e Principi dell'Informatica"
+author: "github.com/martinopiaggi/polimi-notes"
+date: "2020-2021"
+numbersections: true
+geometry: 
+- top=30mm
+- left=23mm
+- right=23mm
+- bottom=30mm
+---
+
+\maketitle
+\newpage
+\tableofcontents
+\newpage

BSc(italian)/Algoritmi e Principi dell'Informatica/src/01.Linguaggi.md

@@ -0,0 +1,10 @@
+# Linguaggi
+'Ma cos''è un linguaggio? Un oggetto matematico formato da: 
+
+- alfabeto (segni/simboli)
+- stringhe formate dagli elementi del alfabeto (sequenze ordinate)
+
+Linguaggi come estrema astrazione. Ad esempio le stringhe possono essere formate non da lettere, ma simboli che rappresentano ad esempio le azioni che fa un programma. Altro esempio è scrivere un problema che ci affligge in un determinato linguaggio e cercare le soluzioni-stringhe appartenenti al linguaggio delle soluzioni corrette. 
+Dobbiamo poi definire la concatenazione di stringhe, la quale nella sua versione generalizzata si identifica come concatenazione di linguaggi. 
+
+**Stella di Kleene** : (x)* è l'insieme di tutte le stringhe ottenibili concatenando x a sè stessa, arbitrariamente (anche 0 volte).

BSc(italian)/Algoritmi e Principi dell'Informatica/src/02.Automi a stati finiti.md

@@ -0,0 +1,66 @@
+
+# Automi a stati finiti
+
+## FSA o ASF
+Astrazione del calcolo, che opera su un certo linguaggio e le sue stringhe. 
+Tempo discreto, cioè quantizzato a passi.
+Passi che ci permettono di spostarci in un sistema finito di stati. 
+Qualsiasi problema/comportamento scrivibile come una sequenza finita di stati può essere modellizzato da un FSA (Finite State Automaton).
+Un FSA è una tupla $<Q,I,\delta,q_0,F>$: 
+
+- Q , un insieme di stati finito
+- I , un alfabeto d'ingresso
+- $\delta$ , una funzione $\delta (Q,I) \rightarrow Q$
+- $q_0$ , stato iniziale (unico)
+- F, l'insieme di stati finali
+
+**Formalmente** le stringhe appartenenti al linguaggio sono $$\forall x (x \in L \leftrightarrow \delta (q_0,x) \in F)$$
+Se l'FSA è un traduttore/trasduttore di linguaggi avrà anche una funzione $\gamma (Q,I) \rightarrow O^*$  dove O è un linguaggio di uscita. 
+> Ricordati che l'automa si ferma solo quando la stringa è finita. Dopo di che controllerà se si trova in uno stato di accettazione. 
+
+### Automa a stati finiti che riconosce numeri divisibili per 3 in base 10
+
+Si basa sul concetto di tenere il conto delle cifre modulo 3. Ragionamento applicabile per qualsiasi altro ASF in cui bisogna valutare la divisibilità per un certo numero. 
+
+![](images/3af18de0db62f9b6af4034e90814234e.png){width=75%}
+
+
+
+### Pumping Lemma
+
+Importante teorema che ci dice che se digerisco una stringa S, la quale $|S| > |Q|$ (dove |Q| è la cardinalità/numero degli stati della FSA) , allora posso digerire digerire un linguaggio infinito (fatto cioè di infinite stringhe di lunghezza finita). 
+
+![](images/a63e780f1753e8232b61e6db932ce683.png){width=60%}
+
+Se $x \in  L \wedge |x| \ge |Q|$, allora esistono uno stato $q \in Q$ e una stringa $w \in I$  tali che: 
+$$x = ywz$$ con $\delta(q,w) = q$ Perciò vale anche quanto segue: 
+$$\forall n \ge 0 \space yw^nz \in L$$Cioé si può “pompare” w. 
+Con il Pumping Lemma si puó ad esempio dimostrare che il linguaggio $L = {a^nb^n | n > 0}$ non è riconosciuto da nessun FSA. 
+Ma ci permette anche di sapere se un FSA riconosce un linguaggio infinito con questa condizione: 
+$$\exists x \in L |Q| \le |x| < 2|Q|$$
+O se un FSA riconosce un linguaggio non vuoto tramite questa condizione: 
+$$\exists x \in L \leftrightarrow \exists y \in L |y| < |Q|$$
+
+### Operazioni insiemistiche su FSA 
+Possiamo fare complemento (negazione), unione,  intersezione di automi a stati finiti.
+**Complemento:**
+Riconoscere tutte le stringhe che non appartengono al linguaggio, e quindi non riconoscere neanche una stringa che apparteniene al linguaggio.
+- scrivere la FSA completa (totale), cioè esplicitare tutti gli stati pozzo (cioè di errore)
+- invertire gli stati finali con quelli di non accettazione della stringa
+
+**Intersezione:**
+Riconoscere le stringhe che appartengono ad entrambi i linguaggi.
+- Si fa il prodotto cartesiano degli stati dei due automi.
+ - Lo stato iniziale è quello deteterminato dal prodotto cartesiano dei due stati iniziali.
+    Sono invece stati finali tutti quegli stati prodotti dagli stati finali. 
+
+**Unione**:
+Riconoscere le stringhe che appartengono o ad uno o all'altro linguaggio. 
+- Si realizza sfruttando de Morgan: $A \cup B = \neg (\neg A \cap \neg B)$
+ ovvero: due complementi, la loro intersezione e un altro complemento in serie.
+
+
+### FSA belli fino a quando non bisogna riconoscere $a^nb^n$
+
+Linguaggi dove viene richiesta 'una memoria' creano problemi. 
+

BSc(italian)/Algoritmi e Principi dell'Informatica/src/03.Automi a Pila.md

@@ -0,0 +1,22 @@
+# Automi a Pila
+
+Un AP è una tupla $<Q, I, \Gamma, \delta, q_0, Z_0, F>$: 
+
+- Q , un insieme di stati finito
+- I , un alfabeto d'ingresso
+- $\Gamma$ alfabeto di pila
+- $\delta$ , una funzione $\delta (Q,I) \rightarrow Q$
+- $q_0$ , stato iniziale (unico)
+- $Z_0$ inizio pila
+- F, l'insieme di stati finali
+
+
+Stessa cosa degli FSA ma dotati di una pila infinita con però un inizio. Possiamo impilare quello che vogliamo, ma possiamo operare solo sulla cima. Una memoria così distruttiva.. lettura = distruzione. 
+
+AP $\leftarrow$ PDA = Push-Down Automaton 
+
+L'AP non è chiuso rispetto nè l'unione nè l'intersezione. Però il complemento è chiuso(procedura analoga al FSA, ma più complicata causa la possibilità, con gli AP, di poter accettare le $\epsilon$  stringhe, cioè elementi vuoti).
+
+### La pila può fare $a^nb^nc^md^m$ e $a^n b^mc^md^n$  ma non $a^nb^nc^n$ poichè ha una memoria distruttiva.
+
+Questo è gran sbatti ed è dovuto al funzionamento della pila. L'approccio per risolvere questo genere di problemi è impilare tutti 'i placeholders' che indicana la 'a' e poi nel momento in cui leggo le b far saltare i vari placeholders. Il problema è che se poi ho anche da contare un eventuale carattere c non riesco: ho distrutto tutta la memoria per assicurarmi che b fossero presenti nella stessa quantità delle a. Pazienza abbiamo le **Macchine di Touring.

BSc(italian)/Algoritmi e Principi dell'Informatica/src/04.Macchina di Touring.md

@@ -0,0 +1,53 @@
+# Macchina di Touring
+## Un modello per elaborarli tutti
+Una MT è una tupla $<Q,I,\Gamma,\delta,q_0,Z_0,F>$:
+
+- OC, Organo di Controllo analogo a FSA e AP che mi permette di spostarmi tra i vari stati
+- Q , un insieme di stati **finito**
+- I , solito alfabeto d'ingresso, in realtà ce ne potrebbe essere uno per ciascun nastro
+- $\Gamma$ alfabeto dei nastri
+- $\delta$ , una funzione $\delta (Q,I) \rightarrow Q$
+- $q_0$ , stato iniziale (unico)
+- $Z_0$ simbolo iniziale della memoria 
+- F, l'insieme di stati finali
+
+Per convenzione nelle MT, negli stati finali non ci sono archi uscenti.
+Sostituisco la pila con 3 nastri (input, memoria, output). Non sono 3 pile distruttive, sono 3 nastri su cui posso 'navigare'. 
+Le mosse della MT diventano quindi più articolate poichè leggo un carattere in input, posso sostituire un carattere nei vari nastri e posso spostare la testina (sx, dx, stop).
+
+Per convenzione gli stati finali sono tutti pozzo, cioè non ci sono transizioni che ci fanno uscire dagli stati finali. 
+
+Un bel esempio di MT, oltre a poter risolvere problemi quali $a^nb^nc^n$  è 'l'incrementatore decimale' . La unione, intersezione e il complemento per MT ci sono e sono chiuse eccetto l'ultima. Il complemento infatti può essere fatto solo se non ci sono cicli. Nel caso non ci fossero faccio il solito scambio: iniziali $\leftrightarrow$ finali.
+
+L'unione la posso vedere come 'il parallelo' di due macchine di Touring, l'intersezione come 'la serie'. 
+
+La MT è **completa**, non ci sono problemi non esprimibili e modellizzabili con una MT. Inoltre una MT a singolo nastro è potente tanto quanto la MT con 3 nastri ... di base suddivido il mio nastro infinito in 3 zone, delimitate da un carattere a piacere non presente nell'alfabeto su cui sto operando. La complicanza sta solo nella gestione dei movimenti della testina, la quale tutte le volte si deve 'orientare'.
+Di fatto una la macchina di Von Neumann , scritta come macchina che si serve di una RAM è completamente equivalente a una MT a singolo nastro. 
+[video MT costruita](https://www.youtube.com/watch?v=E3keLeMwfHY)
+[video di Computerphile su MT](https://www.youtube.com/watch?v=DILF8usqp7M)
+
+esempi di linguaggi eseguibili su MT:
+
+- $a^nb^nc^n$
+- $a^{2n}b^{2n}c^nd^n$
+- $a^n b^{n^2}$ , idea: scorrere tutte le a ad ogni b in input. 
+
+
+
+## Determinismo e non determinismo.
+
+Una sequenza di mosse non deterministiche, implica che non sappiamo stabilire l'ordine in cui vengono fatte. Ci sono MT non deterministiche, e sono utili per risolvere tutti i problemi nel quale non ha importanza 'l'ordine' delle mosse. 
+Il Non Determinismo è quindi il pilastro fondamentale per il **parallelismo**.
+Ci sono anche FSA non deterministiche. Formalmente la differenza sta che la funzione $\delta (Q,I)$ non  mappa  uno stato ma un  insieme $\{ q_0,q_1,q_2...\}$, cioè una mossa ci manda in un insieme di stati possibili, i quali eventualmente possono essere percorsi parallelamente. 
+
+### Una FSA D è potente tanto quanto una FSA ND
+
+### Una AP D è meno potente rispetto a una AP ND
+
+Esatto! Un automa a pila non deterministico ha più espressività.. è come se aumentassi le pile. Ma non diventa potente tanto quanto una MT. 
+
+### Una MT ND è potente tanto quanto una MT D
+
+## Operazioni su linguaggi 
+
+![](images/e51838f5de722efe4be88b0650ea7336.png)

BSc(italian)/Algoritmi e Principi dell'Informatica/src/05.Grammatiche Formali.md

@@ -0,0 +1,42 @@
+# Grammatiche Formali
+
+Le grammatiche formali sono un insieme di regole. Hanno 2 alfabeti, un assioma (o simbolo iniziale) e un insieme di regole dette **produzioni sintattiche**.
+
+## Relazione di derivazione
+
+Produzione sintattica che produce da una stringa un'altra. Posso anche eseguirle in sequenza ottenendo quindi un linguaggio. Da L(G) ottengono il linguaggio L1.
+
+Ci sono 4 tipi di grammatiche: 
+
+*(stringa a è di partenza, stringa b è di arrivo a->b)*
+
+- Tipo 0 = nessuna limitazione
+- Tipo 1 = |a|<|b| 
+- Tipo 2 = |a| = 1 (**Context Free**)
+- Tipo 3 = **regolari**
+
+Regole delle **Grammatiche Regolari**:
+
+- |a| = 1
+- b $\in V_t . V_n \cup V_t$  *(nota che $.$ intende la concatenzazione di stringhe)*
+- b = $\epsilon$ sono nel caso in cui la stringa vuota è presente nel linguaggio
+
+![grammatiche](images/26396012fc57438123aa39321df813ff.png)
+
+Le grammatiche sono modelli generativi di linguaggi, possiamo associare ciascuna grammatica al rispettivo automa riconoscitore del linguaggio generato:
+
+- Tipo 0 $\rightarrow$ nessuna limitazione $\rightarrow$ MT
+- Tipo 1 $\rightarrow$ limitazione cardinalità $\rightarrow$ MT
+- Tipo 2 $\rightarrow$ context free $\rightarrow$ **AP ND**!
+- Tipo 3 $\rightarrow$ grammatiche regolari $\rightarrow$ FSA
+
+Una roba utile negli esercizi è proprio ricordarsi di queste relazioni per generare i linguaggi. Infatti il tipico esercizio 'trova la grammatica a potenza minima per generare questo linguaggio' può essere affrontato come *'che tipo di automa è in grado di riconoscere questo linguaggio? A questo tipo di automa che grammatica corrisponde?'*. 
+
+Possiamo emulare una MT con una grammatica. Come? Ogni mossa è una derivazione, la derivazione ''finale'' verrà effettuata solo se la MT riconosce la stringa. 
+Utilizzeremo la 'losanga' $\diamond$ per separare la stringa input con quella output:
+input $\diamond$ output
+
+> Non è obbligatorio che la regola di derivazione $A \rightarrow B$  sia applicata a tutte le ‘A’ contemporaneamente. Si può applicare la regola $A \rightarrow B$  a tutte le ‘A’, ma si può anche non farlo.  L’idea delle grammatiche è che sono un formalismo non-deterministico: tutte le possibili combinazioni di produzioni vengono provate, se si arriva ad una stringa formata da soli caratteri terminali, allora quella stringa viene detta generata dalla grammatica. 
+
+### Palindromi
+E' possibile dimostrare che se un linguaggio è palindromo, allora esiste una grammatica che lo genera.

BSc(italian)/Algoritmi e Principi dell'Informatica/src/06.Formulazione con Logica.md

@@ -0,0 +1,55 @@
+
+Formalizzare i problemi con un linguaggio.
+La FOL (Logica del primo ordine) é utilizzata in AI e in altri campi.. nei nostri esercizi, per definire linguaggi, utilizzeremo logiche più ristrette di FOL:
+
+- MFO (Logica Monadica del Prim'ordine)= come FOL ma con quantificatori solo su variabili. 
+- MSO (Logica Monadica del Second'ordine)=con quantificatori anche sui predicati. 
+
+### MFO 
+
+- come logica proposizionale ma con variabili che rappresentano posizioni all'interno della stringa
+- in genere nei nostri esercizi possiamo utilizzare abbreviazioni. Esempi di abbreviazioni: (succ(x,y) per dire y=x+1)(last(x))
+- **strettamente meno potente degli FSA**
+- I linguaggi definiti da MFO non sono chiusi rispetto alla $*$ di Kleen. Quindi diciamo che riconosce i cosidetti linguaggi **star-free**, cioè linguaggi definibili come unione, concatenazione,intersezione, complemento di linguaggi finiti.
+
+MFO non sa riconoscere $$L = \{ a^{2n} , n \in \mathbb N \}$$
+
+#### Esempi MFO
+Scrivere una formula di MFO che descrive parole in cui tra 2 simboli $a$ ci deve essere almeno un simbolo $b$. 
+
+$$\forall x,y( x < y \wedge a(x) \cup a(y) \implies \exists z( x < z \wedge z < y \wedge b(z)))$$
+
+Scrivere una formula di MFO che descrive parole in cui i simboli al massimo compaiono una volta sola. 
+$$\forall x( a(x) \implies \forall y( x < y \rightarrow \not a(y)))$$
+Scrivere una formula di MFO che descrive parole in cui, ogni 10 simboli, al massimo 1 puó essere a. 
+$$\forall x,y( y = x + 9 \implies \neg (\exists z1,z2( x \le z1 \wedge z1 < z2 \wedge z2 \le y \wedge a(z1) \wedge a(z2)))$$
+
+### MSO
+- identico a MFO ma con la possibilità di quantificare anche i predicati.
+- **potente tanto quanto gli FSA e quindi le Grammatiche Regolari**
+
+E' possibile utilizzare la logica anche in maniera ricorsiva, l'importante ovviamente è che non vada in loop all'infinito. 
+
+![](images/eeb41aa98d2779ff44e69a7bb940284c.png){width=65%}
+
+### Logica di Hoare
+La notazione di Hoare serve per specificare opportune **pre-condizioni** e **post-condizioni** per un programma. (In questo caso usiamo FOL).
+
+## Tesi di  Church - Turing
+
+> L'insieme delle funzioni calcolabili coincide con quello delle funzioni calcolabili da una macchina di Turing.
+
+Nessun algoritmo, indipendentemente dallo strumento utilizzato per l'implementazione, può risolvere un problema che non sia risolvibile dalla Macchina di Touring. 
+In 80 anni non abbiamo trovato controesempi di questa tesi (che non ha dimostrazione).
+NB: **esistono problemi non risolvibili algoritmicamente.**
+*Enumerazione algoritmica*: un algoritmo che mi trova tutte le corrispondenze biunivoche tra un certo insieme e l'insieme $\mathbb{N}$.  Cioè mi enumera gli elementi di un certo insieme. 
+L'insieme di tutte le MT è enumerabile algoritmicamente: infatti fissati il \#stati e il \#nastri , l'unica cosa che distingue le MT è la funzione $\sigma$ (transizione).
+Quindi da ora in poi vedremo le finite MT come delle funzioni $f_i$ .
+Utilizzeremo il simbolo $\bot$ per indicare 'l'indefinito' , cioè quando una MT non si ferma/è indefinita per un certo ingresso x. 
+
+### Macchina di Touring Universale
+
+La MTU è una MT che può emulare qualsiasi altra MT. Essendo le MT finite, e fissato il \# stati e il \# nastri , ricevendo il numero corrispondente della MT, la MTU può identificare la corrispondente funzione di transizione e quindi emulare la $MT_i$ . 
+MTU calcola quindi $f(y,x)=g_y(x)$ . 
+*Possiamo vedere il computer come una MTU, e una scheda già programmata come una MT.*
+MTU nidificate -> macchine virtuali