diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json
index f0f6920..62145ca 100644
--- a/.obsidian/workspace.json
+++ b/.obsidian/workspace.json
@@ -4,34 +4,18 @@
     "type": "split",
     "children": [
       {
-        "id": "9d91d379fdd97b34",
+        "id": "ee1680277f6a0d97",
         "type": "tabs",
         "children": [
           {
-            "id": "973769883c6ae443",
+            "id": "8d8de4cd4c80f0f8",
             "type": "leaf",
             "state": {
-              "type": "diff-view",
+              "type": "markdown",
               "state": {
                 "file": "Biometric Systems/notes/2. Performance indexes.md",
-                "staged": false
-              }
-            }
-          }
-        ]
-      },
-      {
-        "id": "708a5933e5de1e88",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "b95c6a3bd8dada7d",
-            "type": "leaf",
-            "state": {
-              "type": "diff-view",
-              "state": {
-                "file": "Biometric Systems/final notes/2. Performance indexes.md",
-                "staged": false
+                "mode": "source",
+                "source": false
               }
             }
           }
@@ -101,6 +85,7 @@
             "state": {
               "type": "backlink",
               "state": {
+                "file": "Biometric Systems/notes/2. Performance indexes.md",
                 "collapseAll": false,
                 "extraContext": false,
                 "sortOrder": "alphabetical",
@@ -117,6 +102,7 @@
             "state": {
               "type": "outgoing-link",
               "state": {
+                "file": "Biometric Systems/notes/2. Performance indexes.md",
                 "linksCollapsed": false,
                 "unlinkedCollapsed": true
               }
@@ -138,7 +124,9 @@
             "type": "leaf",
             "state": {
               "type": "outline",
-              "state": {}
+              "state": {
+                "file": "Biometric Systems/notes/2. Performance indexes.md"
+              }
             }
           },
           {
@@ -171,10 +159,11 @@
       "obsidian-git:Open Git source control": false
     }
   },
-  "active": "973769883c6ae443",
+  "active": "8d8de4cd4c80f0f8",
   "lastOpenFiles": [
     "Biometric Systems/slides/LEZIONE2_Indici_di_prestazione.pdf",
     "Biometric Systems/notes/2. Performance indexes.md",
+    "Biometric Systems/notes/1. Introduction.md",
     "Autonomous Networking/notes/4 WSN Routing.md",
     "Autonomous Networking/slides/4 WSN2.pdf",
     "Autonomous Networking/images/Pasted image 20241012174130.png",
@@ -201,7 +190,6 @@
     "Autonomous Networking/notes/2 RFID.md",
     "Autonomous Networking/images",
     "Autonomous Networking/notes",
-    "Biometric Systems/notes/1. Introduction.md",
     "Biometric Systems/slides/lezione1 notes.md",
     "prova per obsidian.md",
     "Senza nome.canvas"
diff --git a/Biometric Systems/notes/2. Performance indexes.md b/Biometric Systems/notes/2. Performance indexes.md
index fbbdd55..7116a88 100644
--- a/Biometric Systems/notes/2. Performance indexes.md	
+++ b/Biometric Systems/notes/2. Performance indexes.md	
@@ -133,4 +133,168 @@ We define
 
 #### Closed set
 We don't have thresholds!
-The only possible error is that the correct identity does not appear at rank 1.
\ No newline at end of file
+The only possible error is that the correct identity does not appear at rank 1.
+
+L’identificazione closed-set è un caso speciale in cui si assume che il soggetto
+associato a ogni probe ha sicuramente una corrispondenza nella gallery. Questo
+caso, seppur applicabile in pochi contesti, va comunque tenuto in considerazione.
+Possiamo utilizzare le seguenti metriche:
+- Cumulative Match Score a rango k ( **CMS(k)** ): probabilità di identificare un soggetto entro il rango k
+- Cumulative Match Characteristic (**CMC**): curva che mostra per ogni rango k il valore $CMS(k)$
+- Recognition Rate (**RR**): $CMS(1)$
+
+## Organizzazione del dataset
+Una cosa da tenere bene a mente è che in fase di sviluppo e test del modello noi abbiamo sempre a disposizione il “ground truth” (la verità) di ogni template, nel momento in cui invece un modello viene utilizzato poi in situazioni reali, questa informazione è ovviamente non disponibile.
+
+Per una buona valutazione di un sistema è molto importante avere una buona suddivisione del dataset. Questa avviene su diversi livelli.
+
+##### Suddivisione Training Set / Testing Set
+L'obiettivo è quello di consentire una fase di training che possa garantire la generalità, deve quindi comprendere esempi molto differenziati tra loro.
+Non tutti i sistemi richiedono necessariamente training in senso lato (ML), ma il training set può essere usato in ogni caso per impostare parametri da usare poi in fase di testing.
+Si possono inserire nel TS soggetti non presenti nel TR per testare meglio la generalità del sistema.
+
+##### Suddivisione probe vs gallery
+Suddivisione effettuata per sample, condizione fondamentale $P ∩ G = ∅$
+Nel gallery è buona norma inserire template catturati in condizioni controllate, in quanto nella realtà è la condizione più frequente.
+
+##### Suddivisione probe set
+Si sceglie quanti probe enrolled e quanti probe non enrolled selezionare
+- $P = P_{G}∩P_{N}$ potrebbe condizionare i risultati di valutazione nel caso di identificazione open-set
+- in identificazione closed-set, l'unica scelta possibile è chiaramente $P = P_{G}$
+- in fase di verifica la scelta non condiziona i risultati
+
+In generale, per evitare il più possibile di avere bias, bisognerebbe partizionare il dataset in diversi modi, ripetere l'evaluation e considerare le prestazioni medie.
+## Probe vs All gallery
+Possiamo costruire una matrice di distanze (es. distanza euclidea) tra coppie di template probe-gallery
+- Per ogni coppia probe/gallery è possibile calcolare in anticipo una matrice di distanza probe-vs-all gallery, memorizzando le distanze tra coppie di template (probe template vs gallery template)
+- La matrice può essere usata come strumento di valutazione per diversi tipi di applicazioni
+- Ogni riga corrisponde a un'operazione di riconoscimento su un probe in input (con o senza claim di identità)
+	- le colonne i gallery template
+	- le righe rappresentano i probe template
+- Si possono avere più di un sample per soggetto, e sarebbero rappresentati in colonne diverse della matrice
+	- avere più sample diminuisce il FRR ma aumenta il FAR!
+
+##### Verifica
+- in caso di verifica, viene l'identità reale viene associata a quella claimed
+- è importante considerare la claimed identity piuttosto che quella reale
+- per una buona valutazione bisogna fare test con suddivisioni probe/gallery diverse
+- per una buona valutazione bisogna fare test con diverse distribuzioni di probe genuine e probe di impostori
+
+##### Identificazione open set
+come prima, ma non abbiamo identity claim. Inoltre possono esistere probe non appartenenti a nessun'identità.
+- per una buona valutazione bisogna fare test con suddivisioni probe/gallery diverse
+- per una buona valutazione bisogna fare test con diverse distribuzioni di probe genuine e impostori
+
+##### Identificazione closed set
+come prima, ma non abbiamo impostori né threshold.
+- per una buona valutazione bisogna fare test con suddivisioni probe/gallery diverse
+
+## All-against-All
+Metodo alternativo al precedente. Consiste nel calcolare una matrice di distanze tra tutti i possibili template, ognuno dei quali giocherà entrambi i ruoli di "probe" e "gallery template".
+
+Pro:
+- facile da programmare
+- mette sotto stress il sistema (ci saranno più tentativi da impostore rispetto a quelli da utente genuino)
+
+Contro:
+- calcolo della matrice dispendioso
+- impossibilità di calcolare diverse distribuzioni tra probe e gallery
+
+Tutti gli algoritmi riportati di seguito hanno in comune i seguenti elementi:
+- M = matrice delle distanze
+- N = numero di soggetti
+- S = numero di template per soggetto
+- G = numero totale di sample = numero di righe/colonne di M ($|G|=SxN$)
+- i = indice righe
+- j = indice colonne
+- $label(x)$ = vera identità di x
+
+Ovviamente ad ogni riga escludo sempre un'operazione, perché non testo un template con se stesso.
+##### Verifica, template singolo
+ ogni riga è un set di |G| − 1 operazioni, con S − 1 test genuini e (N − 1) × (S) test da impostore.
+```js
+for each threshold t
+	for each cell Mi,j with i != j
+		if Mi,j <= t then
+			if label(i) = label(j) then GA++
+			else FA++
+		else if label(i) = label(j) then FR++
+		else GR++
+GAR(t)=GA/TG //TG = |G| * (S-1) total genuine attempts
+FAR(t)=FA/TI //TI = |G| * (N-1) * S total impostor attempts
+FRR(t)=FR/TG
+GRR(t)=GR/TI
+```
+
+##### Verifica, template multipli
+invece di testare ogni coppia di template, testo un template nelle righe con tutto il gruppo di template che hanno la stessa identità nelle colonne, considerando però solo quello con distanza minore.
+Per cui, ogni riga è un set di N operazioni (una per utente), con 1 test genuino e N − 1 test da impostore.
+
+```js
+for each threshold t
+	for each row i
+		for each group Mlabel of cells Mi,j with same label(j) excluding Mi,i
+			diff = min(Mlabel)
+			if diff <= t then
+				if label(i) = label(Mlabel) then GA++
+				else FA++
+			else if label(i) = label(Mlabel) then FR++
+			else GR++
+GAR(t)=GA/TG
+FAR(t)=FA/TI
+FRR(t)=FR/TG
+GRR(t)=GR/TI
+```
+
+##### Identificazione open-set, template multipli
+ogni riga è un set di due operazioni, una da impostore e una da utente genuino.
+```js
+for each threshold t
+	for each row i
+		{Li,m| m=1 … |G|-1} =
+		{Mi,j |j=1, … |G|} \ {Mi,i} ordered by increasing value
+		// the identical element is excluded
+		if Li,1 <= t then // potential accept
+			if label(i) = label(Li,j) then
+				DI(t, 1)++ // genuine case detected+identified
+
+				// parallel impostor case:
+				// jump the templates belonging to label(i) since i not in G
+				find first Li,k such that label(Li,k) != label(i) and Li,k <= t
+				if this k exists, then FA++
+				// the first template != label(i) has a distance <= t
+				else GR++ // impostor is correctly not detected
+			else find first Li,k such that label(i) = label(Li,k) and Li,k <= t
+			//if genuine yet not the first, look for higher ranks
+				if this k exists, then
+					DI(t, k)++ //end of genuine
+				FA++ //impostor in parallel, distance below t but different label. No need to jump since the first label is not the «impostor»
+		else GR++ // impostor case counted directly, FR computed through DIR
+
+DIR(t, 1) = DI(t, 1)/TG
+FRR(t) = 1 - DIR(t,1)
+FAR(t) = FA/TI
+GRR(t)=GR/TI
+k=2 //higher ranks
+while DI(t, k) != 0
+	DIR(t, k) = (DI(t, k) / TG) + DIR(t, k-1) //we have to compute rates
+	k++
+```
+
+##### Identificazione closed-set, template multipli
+ogni riga è un'operazione da utente genuino, non ci sono impostori e non c'è threshold.
+TA è il numero totale di attempts = |G|
+```js
+for each row i
+	{Li,m| m=1 … |G|} = {Mi,j |j=1, …|G|} ordered by increasing value
+	find the first Li,k such that label(i)=label(Li,k)
+	CMS(k)++
+	
+CMS(1) = CMS(1) / TA
+RR = CMS(1)
+
+k=2
+while k < |G| - 1
+	CMS(k) = CMS(k) / TA + CMS(k - 1)
+	k++
+```
\ No newline at end of file