Refine and unify terms

.obsidian/plugins/obsidian-file-color/data.json

@@ -273,10 +273,6 @@
       "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing",
       "color": "fc3lLaITDn62PYbzBhqxl"
     },
-    {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election",
-      "color": "fc3lLaITDn62PYbzBhqxl"
-    },
     {
       "path": "steffo-file-index.json",
       "color": "me4XBNQC4rwzQFLlvIAn0"
@@ -378,7 +374,7 @@
       "color": "7j7Pqog0VHMVVAfazMNlb"
     },
     {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computation in trees.canvas",
+      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
       "color": "7j7Pqog0VHMVVAfazMNlb"
     },
     {
@@ -389,17 +385,17 @@
       "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti",
       "color": "fc3lLaITDn62PYbzBhqxl"
     },
-    {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal+ protocol.md",
-      "color": "fc3lLaITDn62PYbzBhqxl"
-    },
-    {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal protocol.md",
-      "color": "fc3lLaITDn62PYbzBhqxl"
-    },
     {
       "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md",
       "color": "fc3lLaITDn62PYbzBhqxl"
+    },
+    {
+      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md",
+      "color": "fc3lLaITDn62PYbzBhqxl"
+    },
+    {
+      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md",
+      "color": "fc3lLaITDn62PYbzBhqxl"
     }
   ]
 }

0 - Generale/albero.md

@@ -0,0 +1 @@
+[[grafo aciclico]] con [[radice di un albero|radice]] specificata.

0 - Generale/grafo aciclico.md

@@ -0,0 +1 @@
+[[grafo]] in cui non esistono [[ciclo|cicli]].

8 - Crittografia applicata/4 - Controllo dell'accesso/4 - Distribuzione di chiavi/public key infrastructure.md

@@ -4,4 +4,4 @@ aliases: ["PKI"]
 
 Approccio [[centralizzazione|centralizzato]] alla [[delegated verification]].
 
-[[Albero]] delle relazioni di [[fiducia]] tra alcuni [[user agent]], la cui [[trust anchor]] è detta [[certification authority]].
+[[albero]] delle relazioni di [[fiducia]] tra alcuni [[user agent]], la cui [[trust anchor]] è detta [[certification authority]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità parziale.md

@@ -1,3 +1,6 @@
 [[restrizione di affidabilità]].
 
-Specifica che da un certo momento in poi non ci saranno ulteriori [[guasto|guasti]], ma che potrebbero esserci stati in passato.
+Specifica che ***da un certo momento in poi non ci saranno ulteriori [[guasto|guasti]]***.
+
+> [!Tip]
+> Potrebbero essere avvenuti in passato, però!

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità totale.md

@@ -1,3 +1,3 @@
 [[restrizione di affidabilità]].
 
-Specifica che non potranno mai avvenire [[guasto|guasti]].
+Specifica che non potranno ***mai*** avvenire [[guasto|guasti]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/assioma dell'orientamento locale.md

@@ -4,6 +4,8 @@ Un'[[entità]] può sempre distinguere nel suo [[vicinato]]:
 - quanti sono i vicini
 - quali sono i vicini
 
+==Perchè si chiama così? Abbiamo usato "orientamento locale" anche in altri modi...==
+
 > [!EXAMPLE]
 > Conoscono l'indirizzo IP dei loro vicini, ma non quello di tutti gli altri.
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/consegna garantita.md

@@ -1,3 +1,3 @@
 [[restrizione di affidabilità]].
 
-Specifica che tutti i [[messaggio|messaggi]] inviati sono ricevuti senza [[guasto|guasti]].
+Specifica che tutti i [[messaggio|messaggi]] inviati saranno ricevuti senza [[guasto|guasti]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entità.md

@@ -13,3 +13,6 @@ Ha:
 - [[stato di un'entità|stato]]: **[[individuale]]**
 - [[comportamento]]: **[[condiviso]]**
 - [[output]]: **[[condiviso]]**
+
+> [!Tip]
+> Nell'analogia [[sistema distribuito]]-[[grafo]], un'entità è un [[nodo di un grafo|nodo]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/full-duplex.md

@@ -3,6 +3,6 @@ aliases:
   - grafo indiretto
 ---
 
-[[restrizione di topologia]] applicabile a un [[canale di comunicazione]].
+[[restrizione di comunicazione]] applicabile a un [[canale di comunicazione]].
 
 Determina che entrambe le [[entità]] possono inviare e ricevere [[messaggio|messaggi]] in esso.

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/half-duplex.md

@@ -3,6 +3,6 @@ aliases:
   - grafo diretto
 ---
 
-[[restrizione di topologia]] applicabile a un [[canale di comunicazione]].
+[[restrizione di comunicazione]] applicabile a un [[canale di comunicazione]].
 
 Determina che una sola delle due [[entità]] può inviare [[messaggio|messaggi]] in esso, e che l'altra può solo riceverli.

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/iniziatore singolo.md

@@ -1,3 +0,0 @@
-[[restrizione di comunicazione]].
-
-Prevede che sia già stato selezionato un singolo [[leader]] che dia il via all'[[algoritmo]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/iniziatori multipli.md

@@ -1,3 +0,0 @@
-[[restrizione di comunicazione]].
-
-Prevede che qualsiasi [[entità]] possa dare il via all'algoritmo, anche se un'altra lo ha già fatto.

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/no failure detection.md

@@ -0,0 +1,3 @@
+[[restrizione di affidabilità]].
+
+Specifica che le [[entità]] non hanno modo di determinare quando avviene un [[guasto]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio parziale.md

@@ -0,0 +1,8 @@
+---
+aliases:
+  - iniziatori multipli
+---
+
+[[restrizione di tempo]].
+
+Specifica che, ai fini della risoluzione del [[problema]], la computazione necessaria all'avvio dell'esecuzione di un [[algoritmo]] è ***ignorata per determinate [[entità]]***, dette *iniziatrici*.

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio singolo.md

@@ -0,0 +1,8 @@
+---
+aliases:
+  - iniziatore singolo
+---
+
+[[restrizione di tempo]].
+
+Specifica che, ai fini della risoluzione del [[problema]], la computazione necessaria all'avvio dell'esecuzione di un [[algoritmo]] è ***ignorata per una singola [[entità]]***, detta [[leader]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio totale.md

@@ -0,0 +1,3 @@
+[[restrizione di tempo]].
+
+Specifica che, ai fini della risoluzione del [[problema]], la computazione necessaria all'avvio dell'esecuzione di un [[algoritmo]] è ***ignorata***.

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md

@@ -1,5 +1,6 @@
 [[restrizione di tempo]].
 
-Specifica che le [[entità]] partecipanti vengono a conoscenza di quando l'algoritmo è terminato per tutti i partecipanti.
+Specifica che, ai fini della risoluzione del [[problema]], il [[algoritmo corretto|requisito di terminazione di un algoritmo]] è soddisfatto quando ***tutte le [[entità]] partecipanti conoscono quando l'intera computazione è terminata***.
 
-È un problema a sè stante, il [[termination detection problem]].
+> [!Example]
+> L'abbiamo visto in [[★ sistemi complessi]]: la [[sincronizzazione del plotone di esecuzione]]!

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione ignorata.md

@@ -0,0 +1,6 @@
+[[restrizione di tempo]].
+
+Specifica che, ai fini della risoluzione del [[problema]], il [[algoritmo corretto|requisito di terminazione di un algoritmo]] è ***ignorato***.
+
+> [!Warning]
+> In tal caso, sarebbe più una [[procedura]] che un [[algoritmo]]...

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md

@@ -1,3 +1,6 @@
 [[restrizione di tempo]].
 
-Specifica che le [[entità]] partecipanti conoscono quando la loro partecipazione è terminata, ma non quando è terminata quella di tutte le altre.
+Specifica che, ai fini della risoluzione del [[problema]], il [[algoritmo corretto|requisito di terminazione di un algoritmo]] è soddisfatto quando ***tutte le [[entità]] partecipanti conoscono quando la loro partecipazione individuale è terminata***.
+
+> [!Tip]
+> È quello usato più di frequente!

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/vicini di un'entità.md

@@ -0,0 +1,8 @@
+---
+aliases:
+  - vicino
+  - vicinato
+  - vicini
+---
+
+Relativamente ad una data [[entità]], sono *vicini* tutte le altre [[entità]] a cui è direttamente [[rete di comunicazione|connessa]] attraverso un [[canale di comunicazione]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas

@@ -1,6 +1,6 @@
 {
 	"nodes":[
-		{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2860,"width":2440,"height":2480,"label":"Restrizioni del modello"},
+		{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2300,"width":2440,"height":1920,"label":"Restrizioni del modello"},
 		{"id":"de6e2a65c63084c7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/stato di un'entità.md","x":800,"y":-160,"width":400,"height":400},
 		{"id":"7126bfdd6ead22a9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/insieme degli stati di un'entità.md","x":1360,"y":-160,"width":400,"height":400},
 		{"id":"c986480451be1efe","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entità.md","x":240,"y":-160,"width":400,"height":400},
@@ -8,7 +8,6 @@
 		{"id":"40f55b66f9214ecd","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema distribuito.md","x":-320,"y":-1360,"width":400,"height":400},
 		{"id":"97624a26a3c7d126","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema sequenziale.md","x":-320,"y":-2480,"width":400,"height":400},
 		{"id":"97d5f142a5c95ce3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema parallelo.md","x":-320,"y":-1920,"width":400,"height":400},
-		{"id":"961e2a0551edc3c5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di comunicazione.md","x":800,"y":-2840,"width":400,"height":200},
 		{"id":"bdeb2e85bcb32f7e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizioni al modello dei sistemi distribuiti.md","x":240,"y":-800,"width":400,"height":400},
 		{"id":"d8754617f38feb06","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/canale di comunicazione.md","x":-320,"y":400,"width":400,"height":400},
 		{"id":"afa296d887da4394","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/evento.md","x":-600,"y":1520,"width":400,"height":400},
@@ -35,25 +34,30 @@
 		{"id":"7307a3e6d21d094d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo asincrono.md","x":-2000,"y":-1120,"width":400,"height":200},
 		{"id":"3c2d2701a7095e82","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo sincrono.md","x":-2000,"y":-1400,"width":400,"height":200},
 		{"id":"9abf440226d21d98","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/assioma dell'orientamento locale.md","x":-880,"y":-160,"width":400,"height":400},
-		{"id":"5f79f222c02d34a4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/iniziatore singolo.md","x":1280,"y":-2840,"width":400,"height":200},
-		{"id":"8feba6ce763a0898","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/iniziatori multipli.md","x":1760,"y":-2840,"width":400,"height":200},
-		{"id":"55006dcc3b515353","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md","x":1280,"y":-1160,"width":400,"height":200},
-		{"id":"d12cedf357c12705","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md","x":1760,"y":-1160,"width":400,"height":200},
-		{"id":"4a1b9354e73b16bc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/identificatori univoci.md","x":1280,"y":-1440,"width":400,"height":200},
 		{"id":"2d21a7ed903a16e7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di tempo.md","x":800,"y":-1160,"width":400,"height":760},
-		{"id":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-880,"width":400,"height":200},
+		{"id":"dbe3b5d5f2baeb7f","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione illimitato.md","x":1280,"y":-600,"width":400,"height":200,"color":"3"},
-		{"id":"dbe3b5d5f2baeb7f","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione illimitato.md","x":1280,"y":-600,"width":400,"height":200},
+		{"id":"472610beeef20101","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione limitato.md","x":1760,"y":-600,"width":400,"height":200,"color":"2"},
-		{"id":"472610beeef20101","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione limitato.md","x":1760,"y":-600,"width":400,"height":200},
+		{"id":"fc4c48607c9ae580","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md","x":2240,"y":-600,"width":400,"height":200,"color":"1"},
-		{"id":"ca6adc368f6aed21","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/channel failure detection.md","x":1280,"y":-2560,"width":400,"height":200},
+		{"id":"02d82dc7842e6fc9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/vicini di un'entità.md","x":-880,"y":400,"width":400,"height":400},
-		{"id":"887f1f52394b3721","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità parziale.md","x":1280,"y":-2280,"width":400,"height":200},
+		{"id":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-160,"width":400,"height":400},
-		{"id":"b69def8d92ba28df","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/consegna garantita.md","x":1280,"y":-2000,"width":400,"height":200},
+		{"id":"d58b2d089a2e67be","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione ignorata.md","x":1280,"y":-880,"width":400,"height":200,"color":"3"},
-		{"id":"281bcf7f0a4b5be1","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md","x":800,"y":-2560,"width":400,"height":760},
+		{"id":"e61c5ee7f8dd35a5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md","x":1760,"y":-880,"width":400,"height":200,"color":"2"},
-		{"id":"7d0f048f4b43f33d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/full-duplex.md","x":1760,"y":-1720,"width":400,"height":200},
+		{"id":"6dc8e5e24bfa2114","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md","x":2240,"y":-880,"width":400,"height":200,"color":"1"},
-		{"id":"ce3d37417ee5bf4d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/half-duplex.md","x":1280,"y":-1720,"width":400,"height":200},
+		{"id":"5a382d3822a5736e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio totale.md","x":1280,"y":-1160,"width":400,"height":200,"color":"3"},
-		{"id":"0951993b4f64f1b4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di topologia.md","x":800,"y":-1720,"width":400,"height":480},
+		{"id":"00b0016663a07f0b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio parziale.md","x":1760,"y":-1160,"width":400,"height":200,"color":"2"},
-		{"id":"fc4c48607c9ae580","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md","x":2240,"y":-600,"width":400,"height":200},
+		{"id":"aa511f4700f8c6f7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio singolo.md","x":2240,"y":-1160,"width":400,"height":200,"color":"1"},
-		{"id":"a16e77231955a7a3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entity failure detection.md","x":1760,"y":-2560,"width":400,"height":200},
+		{"id":"4a1b9354e73b16bc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/identificatori univoci.md","x":1760,"y":-1440,"width":400,"height":200,"color":"2"},
-		{"id":"6b3170059dad55ef","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità totale.md","x":1760,"y":-2280,"width":400,"height":200}
+		{"id":"0951993b4f64f1b4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di topologia.md","x":800,"y":-1440,"width":400,"height":200},
+		{"id":"887f1f52394b3721","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità parziale.md","x":1280,"y":-1720,"width":400,"height":200,"color":"3"},
+		{"id":"6b3170059dad55ef","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/affidabilità totale.md","x":2240,"y":-1720,"width":400,"height":200,"color":"1"},
+		{"id":"1ab217c2b661bb7d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/consegna garantita.md","x":1760,"y":-1720,"width":400,"height":200,"color":"2"},
+		{"id":"281bcf7f0a4b5be1","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md","x":800,"y":-2000,"width":400,"height":480},
+		{"id":"093e569da1a08d91","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/entity failure detection.md","x":2240,"y":-2000,"width":400,"height":200,"color":"1"},
+		{"id":"5888f088a7849b69","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/channel failure detection.md","x":1760,"y":-2000,"width":400,"height":200,"color":"2"},
+		{"id":"7862502b2075f0a7","x":1280,"y":-2000,"width":400,"height":200,"color":"3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/no failure detection.md"},
+		{"id":"4f299bd36fec0431","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/half-duplex.md","x":1280,"y":-2280,"width":400,"height":200,"color":"3"},
+		{"id":"961e2a0551edc3c5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di comunicazione.md","x":800,"y":-2280,"width":400,"height":200},
+		{"id":"7bf268e3d7b311a7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/full-duplex.md","x":1760,"y":-2280,"width":400,"height":200,"color":"2"}
 	],
 	"edges":[
 		{"id":"1bb35cb60ca4ea15","fromNode":"afa296d887da4394","fromSide":"bottom","toNode":"904bb8e648bdcb90","toSide":"top"},
@@ -87,14 +91,8 @@
 		{"id":"4e22445bef4f3751","fromNode":"9ff0a423dbb281a0","fromSide":"bottom","toNode":"d8754617f38feb06","toSide":"top"},
 		{"id":"c0e7edefcb021bbe","fromNode":"d8754617f38feb06","fromSide":"bottom","toNode":"6b49f0fc996cb192","toSide":"top"},
 		{"id":"5956ff40fae387a3","fromNode":"c986480451be1efe","fromSide":"left","toNode":"d8754617f38feb06","toSide":"right"},
-		{"id":"e25ad17df986933d","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"ca6adc368f6aed21","toSide":"left"},
-		{"id":"d17369530cedcf91","fromNode":"ca6adc368f6aed21","fromSide":"right","toNode":"a16e77231955a7a3","toSide":"left"},
-		{"id":"bd17cdba235c81af","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"b69def8d92ba28df","toSide":"left"},
 		{"id":"d56cbf4dce71a7f3","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"887f1f52394b3721","toSide":"left"},
-		{"id":"d75e4e97c723ecbb","fromNode":"887f1f52394b3721","fromSide":"right","toNode":"6b3170059dad55ef","toSide":"left"},
-		{"id":"2e95c9b13ce50fd0","fromNode":"472610beeef20101","fromSide":"top","toNode":"83b3be69f6f3d497","toSide":"bottom"},
 		{"id":"d63be18341405890","fromNode":"472610beeef20101","fromSide":"right","toNode":"fc4c48607c9ae580","toSide":"left"},
-		{"id":"17033b6f222151a8","fromNode":"fc4c48607c9ae580","fromSide":"top","toNode":"83b3be69f6f3d497","toSide":"bottom"},
 		{"id":"b9abeefc64ec5360","fromNode":"806b3a8cfb46e427","fromSide":"bottom","toNode":"ce14b5c90fd5e953","toSide":"top"},
 		{"id":"26e0891ec4447f53","fromNode":"40f55b66f9214ecd","fromSide":"left","toNode":"0663141369318ae1","toSide":"right"},
 		{"id":"ec682837ca5406eb","fromNode":"0663141369318ae1","fromSide":"left","toNode":"5cb928eebbce8c85","toSide":"right"},
@@ -104,14 +102,24 @@
 		{"id":"4e6bc2efe53e4e17","fromNode":"0663141369318ae1","fromSide":"left","toNode":"68d2646884fe10e3","toSide":"right"},
 		{"id":"11e3f0f7f9977138","fromNode":"68d2646884fe10e3","fromSide":"left","toNode":"7307a3e6d21d094d","toSide":"right"},
 		{"id":"0a39548d5dde3f7e","fromNode":"68d2646884fe10e3","fromSide":"left","toNode":"3c2d2701a7095e82","toSide":"right"},
-		{"id":"459233fc20cad1e7","fromNode":"961e2a0551edc3c5","fromSide":"right","toNode":"5f79f222c02d34a4","toSide":"left"},
-		{"id":"862f0a43ddf5a87a","fromNode":"5f79f222c02d34a4","fromSide":"right","toNode":"8feba6ce763a0898","toSide":"left"},
-		{"id":"92889f0a7be5f7d4","fromNode":"55006dcc3b515353","fromSide":"right","toNode":"d12cedf357c12705","toSide":"left"},
-		{"id":"02d76934b8ed7603","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"55006dcc3b515353","toSide":"left"},
 		{"id":"7b82b81786037fe6","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"dbe3b5d5f2baeb7f","toSide":"left"},
 		{"id":"13ecf8445dea426a","fromNode":"dbe3b5d5f2baeb7f","fromSide":"right","toNode":"472610beeef20101","toSide":"left"},
 		{"id":"81615994263f9203","fromNode":"0951993b4f64f1b4","fromSide":"right","toNode":"4a1b9354e73b16bc","toSide":"left"},
-		{"id":"946800279c546347","fromNode":"ce3d37417ee5bf4d","fromSide":"right","toNode":"7d0f048f4b43f33d","toSide":"left"},
+		{"id":"883f51fdca0cae63","fromNode":"d8754617f38feb06","fromSide":"left","toNode":"02d82dc7842e6fc9","toSide":"right"},
-		{"id":"60e9ac87e9ce4fc1","fromNode":"0951993b4f64f1b4","fromSide":"right","toNode":"ce3d37417ee5bf4d","toSide":"left"}
+		{"id":"524c88f5c49126c8","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"d58b2d089a2e67be","toSide":"left"},
+		{"id":"8edd4cd421b796c6","fromNode":"d58b2d089a2e67be","fromSide":"right","toNode":"e61c5ee7f8dd35a5","toSide":"left"},
+		{"id":"ca3addc3261f366b","fromNode":"e61c5ee7f8dd35a5","fromSide":"right","toNode":"6dc8e5e24bfa2114","toSide":"left"},
+		{"id":"b9d158fea7f2db64","fromNode":"2d21a7ed903a16e7","fromSide":"right","toNode":"5a382d3822a5736e","toSide":"left"},
+		{"id":"b0b6bca60aa9b551","fromNode":"5a382d3822a5736e","fromSide":"right","toNode":"00b0016663a07f0b","toSide":"left"},
+		{"id":"77a97e5a4f4671bd","fromNode":"00b0016663a07f0b","fromSide":"right","toNode":"aa511f4700f8c6f7","toSide":"left"},
+		{"id":"6c788cd758713395","fromNode":"4f299bd36fec0431","fromSide":"right","toNode":"7bf268e3d7b311a7","toSide":"left"},
+		{"id":"50384fcf0b6d5450","fromNode":"961e2a0551edc3c5","fromSide":"right","toNode":"4f299bd36fec0431","toSide":"left"},
+		{"id":"24c8ccec6bcc6278","fromNode":"887f1f52394b3721","fromSide":"right","toNode":"1ab217c2b661bb7d","toSide":"left"},
+		{"id":"652ed21c4a649f54","fromNode":"1ab217c2b661bb7d","fromSide":"right","toNode":"6b3170059dad55ef","toSide":"left"},
+		{"id":"e360a93b41662c61","fromNode":"5888f088a7849b69","fromSide":"right","toNode":"093e569da1a08d91","toSide":"left"},
+		{"id":"e49aefbf6eb92718","fromNode":"281bcf7f0a4b5be1","fromSide":"right","toNode":"7862502b2075f0a7","toSide":"left"},
+		{"id":"a3aca459de8a94ba","fromNode":"7862502b2075f0a7","fromSide":"right","toNode":"5888f088a7849b69","toSide":"left"},
+		{"id":"675055018ef6483c","fromNode":"472610beeef20101","fromSide":"bottom","toNode":"83b3be69f6f3d497","toSide":"top"},
+		{"id":"ac5fdc2d569502ff","fromNode":"fc4c48607c9ae580","fromSide":"bottom","toNode":"83b3be69f6f3d497","toSide":"top"}
 	]
 }

9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/broadcast problem.md

@@ -12,14 +12,14 @@ Una [[entità]] vuole comunicare un'informazione a tutto il resto del [[sistema
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- [[iniziatore singolo]]
+	- [[half-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
-	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
+	- [[risveglio singolo]]
 	- [[terminazione locale]]
 
 ## [[algoritmo|Algoritmi]]
@@ -29,7 +29,7 @@ Una [[entità]] vuole comunicare un'informazione a tutto il resto del [[sistema
 	- [[flooding v2]] ([[algoritmo corretto|corretto]].)
 	- [[flooding v3]] (ottimizzato!)
 
-## [[notazione Ω-grande|Lower bound]] [[costo computazionale|costo computazionale]]
+## [[costo computazionale|Costo computazionale]]
 
 ### [[Comunicazione]]
 
@@ -59,7 +59,7 @@ $$
 \Large Nodes
 $$
 
-### [[tempo]]
+### [[Tempo]]
 
 #### In un [[grafo]] qualsiasi
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v1.md

@@ -1,38 +1,24 @@
-[[algoritmo]] ***[[algoritmo corretto|incorretto]]*** di [[broadcast problem]].
+[[algoritmo]] di [[broadcast problem]].
+
+## [[Comportamento]]
 
 > [!Summary]
 > Il [[leader]] invia il suo messaggio iniziale a tutti i vicini, e loro lo inoltrano a loro volta ai loro vicini.
 
-## [[Comportamento]]
+Il [[leader]] è inizializzato allo stato `LEADER`, mentre tutti gli altri sono inizializzati allo stato `SLEEPING`.
 
 ### `LEADER`
 
-All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo messaggio:
+All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]] a tutti i vicini.
-```rust
-spontaneously! {
-	send!(*, Message {...});
-}
-```
 
-Se lo riceve indietro, non fa niente:
+Ignora qualsiasi altra cosa riceva.
-```rust
-on_receive! {
-	_ => {},
-}
-```
 
 ### `SLEEPING`
 
-Se riceve il messaggio, lo inoltra a tutti i suoi vicini:
+Se riceve il [[messaggio]] del `LEADER`, lo inoltra a tutti i vicini.
-```rust
-on_receive! {
-	_ => send!(*, msg)
-}
-```
 
 ## [[algoritmo corretto|Correttezza]]
 
-> [!DANGER] Algoritmo incorretto
+> [!Failure]
 > 
-> Questo algoritmo non termina mai!  
+> Questo algoritmo potrebbe non terminare mai, in quanto due [[entità]] potrebbero inoltrarsi il [[messaggio]] del [[#`LEADER`]] all'infinito.
-> È riportato qui solo come base per le due versioni successive.

9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v2.md

@@ -1,51 +1,37 @@
 [[algoritmo]] di [[broadcast problem]] che risolve l'incorrettezza del [[flooding v1]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Il [[leader]] invia il suo messaggio iniziale a tutti i vicini, e, ***se è la prima volta che lo ricevono***, loro lo inoltrano a loro volta ai loro vicini.
 
-## [[Comportamento]]
+Il [[leader]] è inizializzato allo stato `LEADER`, mentre tutti gli altri sono inizializzati allo stato `SLEEPING`.
 
 ### `LEADER`
 
-All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo messaggio:
+All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]] a tutti i vicini, ***poi passa allo stato `DONE`***.
-```rust
-spontaneously! {
-	send!(*, Message {...});
-	state!(DONE);
-}
-```
-
-Se lo riceve indietro, non fa niente:
-```rust
-on_receive! {
-	_ => {},
-}
-```
 
 ### `SLEEPING`
 
-Se riceve il messaggio, lo inoltra a tutti i suoi vicini, poi passa allo stato `DONE`:
+Se riceve il [[messaggio]] del `LEADER`, lo inoltra a tutti i vicini, ***poi passa allo stato `DONE`***.
-```rust
-on_receive! {
-	_ => {
-		send!(*, msg);
-		state!(DONE);
-	},
-}
-```
 
-### `DONE`
+### ***`DONE`***
 
-Non fa niente.
+***Ignora qualsiasi cosa riceva.***
 
 ## [[algoritmo corretto|Correttezza]]
 
-Per via dell'ipotesi di [[grafo connesso]], tutte le [[entità]] riceveranno eventualmente il [[messaggio]] inviato.
+> [!Success]
-
+> 
-Con la ricezione del [[messaggio]], eventualmente tutte le [[entità]] diventeranno `DONE`, raggiungendo [[terminazione locale]].
+> Per via dell'ipotesi di [[grafo connesso]], tutte le [[entità]] eventualmente riceveranno e inoltreranno il [[messaggio]] del [[leader]], diventando `DONE`.
 
 ## [[costo computazionale distribuito|Costo computazionale]]
 
+| Costo | [[notazione O-grande]] | 
+|-|-|
+| [[comunicazione]] | $O(Channels)$ |
+| [[tempo]] | $O(Channels)$ |
+
 ### [[Comunicazione]]
 
 Attraverso ogni [[canale di comunicazione|canale]] passeranno al massimo due [[messaggio|messaggi]]:
@@ -63,13 +49,12 @@ $$
 \Large O(Channels)
 $$
 
-### [[Spazio]]
+### [[Tempo]]
 
-Un multiplo del [costo di comunicazione](#Comunicazione), sempre [[notazione asintotica|asintotico]] a:
+Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
 $$
 \Large O(Channels)
 $$
 
-### [[Tempo]]
+> [!Note]
-
+> Coincide con il lower bound del [[broadcast problem]].
-Coincide con il lower bound del [[broadcast problem]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md

@@ -1,38 +1,19 @@
 [[algoritmo]] di [[broadcast problem]] che riduce il [[comunicazione|numero di messaggi]] rispetto al [[flooding v2]].
 
+## [[Comportamento]]
+
 > [!Summary]
 >  Il [[leader]] invia il suo [[messaggio]] iniziale a tutti i vicini, e, se è la prima volta che lo ricevono, loro lo inoltrano a loro volta ai loro vicini ***tranne quello che gliel'ha inviato***.
 
-## [[Comportamento]]
+Il [[leader]] è inizializzato allo stato `LEADER`, mentre tutti gli altri sono inizializzati allo stato `SLEEPING`.
 
 ### `LEADER`
 
-All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]]:
+All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]] a tutti i vicini, poi passa allo stato `DONE`***.
-```rust
-spontaneously! {
-	send!(*, Message {...});
-	state!(DONE);
-}
-```
-
-Se lo riceve indietro, non fa niente:
-```rust
-on_receive! {
-	_ => {},
-}
-```
 
 ### `SLEEPING`
 
-Se riceve il [[messaggio]], lo inoltra a tutti i suoi vicini, poi passa allo stato `DONE`:
+Se riceve il [[messaggio]] del `LEADER`, lo inoltra a tutti i vicini ***tranne quello che gliel'ha inviato***, poi passa allo stato `DONE`.
-```rust
-on_receive! {
-	_ => {
-		send!(!sender, msg);
-		state!(DONE);
-	},
-}
-```
 
 ### `DONE`
 
@@ -40,13 +21,20 @@ Non fa niente.
 
 ## [[algoritmo corretto|Correttezza]]
 
-Vedi [[flooding v2]].
+> [!Success]
+> 
+> Per via dell'ipotesi di [[grafo connesso]], tutte le [[entità]] eventualmente riceveranno e inoltreranno il [[messaggio]] del [[leader]], diventando `DONE`.
 
 ## [[costo computazionale distribuito|Costo computazionale]]
 
+| Costo | [[notazione O-grande]] |
+|-|-|
+| [[comunicazione]] | $O(Channels)$ |
+| [[tempo]] | $O(Channels)$ |
+
 ### [[Comunicazione]]
 
-Il costo computazionale è lo stesso del [[flooding v2]], ma con un trasferimento in meno per ogni [[entità]] che non è il [[leader]]:
+Il costo computazionale è lo stesso del [[flooding v2]], ma ***con un trasferimento in meno per ogni [[entità]] che non è il [[leader]]***:
 $$
 2 \cdot Channels - (Entities - 1)
 $$
@@ -56,13 +44,16 @@ $$
 \Large O(Channels)
 $$
 
-### [[Spazio]]
+> [!Note]
+> 
+> ***Coincide con il lower bound del [[broadcast problem]].***
 
-Un multiplo del [costo di comunicazione](#Comunicazione), sempre [[notazione asintotica|asintotico]] a:
+### [[Tempo]]
+
+Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
 $$
 \Large O(Channels)
 $$
 
-### [[Tempo]]
+> [!Note]
-
+>Coincide con il lower bound del [[broadcast problem]].
-Vedi [[flooding v2]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/wake-up problem.md

@@ -7,14 +7,14 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- ***[[iniziatori multipli]]***
+	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
-	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
+	- ***[[risveglio parziale]]***
 	- [[terminazione locale]]
 
 ## [[algoritmo|Algoritmi]]
@@ -24,7 +24,7 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
 	- [[flooding v2]] ([[algoritmo corretto|corretto]].)
 	- [[flooding v3]] (ottimizzato!)
 
-## [[notazione Ω-grande|Lower bound]] [[costo computazionale|costo computazionale]]
+## [[costo computazionale|Costo computazionale]]
 
 ### [[Comunicazione]]
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/★ broadcast.canvas

@@ -1,6 +1,6 @@
 {
 	"nodes":[
-		{"id":"1ae79343ecdc2ecf","type":"group","x":1040,"y":540,"width":1640,"height":1000,"color":"5","label":"Flooding"},
+		{"id":"1ae79343ecdc2ecf","type":"group","x":1040,"y":540,"width":1640,"height":1000,"label":"Flooding"},
 		{"id":"1bf892659093d611","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v1.md","x":1060,"y":560,"width":480,"height":960},
 		{"id":"a1841455be06b505","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v2.md","x":1620,"y":560,"width":480,"height":960},
 		{"id":"ea39c9f9c9d31ba6","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md","x":2180,"y":560,"width":480,"height":960},

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/broadcast tree construction.md

@@ -7,14 +7,14 @@ Si vuole ***minimizzare il [[diametro di un grafo|diametro]]*** di uno [[spannin
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- [[iniziatore singolo]]
+	- [[full-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
-	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
+	- [[risveglio singolo]]
 	- [[terminazione locale]]
 
 ## Idea degli [[algoritmo|algoritmi]]

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/multiple spanning tree construction.md

@@ -7,15 +7,15 @@ Si vuole [[problema di ricerca|determinare]] uno [[spanning tree]] per il [[sist
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- ***[[iniziatori multipli]]***
+	- [[full-duplex]]
-	- ***[[identificatori univoci]]***
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
-	- [[full-duplex|grafo indiretto]]
+	- ***[[identificatori univoci]]***
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione unitario]]
+	- ***[[risveglio parziale]]***
 	- [[terminazione locale]]
 
 ### [[Algoritmo|Algoritmi]]

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/shout protocol.md

@@ -1,117 +1,76 @@
 [[algoritmo]] di [[spanning tree construction]], basato sul [[flooding v3]].
 
-> [!Summary]
-> Ciascuna [[entità]] chiede ai propri vicini se può entrare a fare parte dello [[spanning tree]], e loro ***rispondono sì oppure no***.
-
 ## [[Comportamento]]
 
+> [!Summary]
+> Ciascuna [[entità]] chiede ai propri vicini se può entrare a fare parte dello [[spanning tree]], e loro ***rispondono di sì oppure di no***.
+
 Il [[leader]] viene inizializzato a `LEADER`, le altre [[entità]] vengono inizializzate a `IDLE`.
 
 ### `LEADER`
 
-Il [[leader]] chiede [[impulso spontaneo|spontaneamente]] alle [[entità]] se possono entrare a fare parte dello [[spanning tree]], poi si attiva in attesa di risposte:
+[[messaggio|Chiede]] [[impulso spontaneo|spontaneamente]] ai suoi [[vicini di un'entità|vicini]] se possono entrare a fare parte dello [[spanning tree]] con `Question`, poi diventa `ACTIVE`.
-```rust
-spontaneously!({
-	self.received = 0;
-	send!(*, Question);
-	state!(ACTIVE);
-})
-```
 
 ### `IDLE`
 
-Un'[[entità]] `IDLE` è in attesa di domande.
+In attesa di ricevere `Question`.
 
-Quando ne riceve una, risponde positivamente, poi ripete la domanda e si attiva a sua volta:
+Quando ne riceve una, risponde `Yes`, poi ripete `Question` ai propri [[vicini di un'entità|vicini]] (tranne il mittente) e diventa `ACTIVE`.
-```rust
-on_receive!(
-	Question => {
-		self.received = 1;
-		self.parent = sender;
-		send!(sender, Answer::Yes);
-		send!(!sender, Question);
-		if self.neighbours.length() > self.received {
-			state!(DONE)
-		}
-		else {
-			state!(ACTIVE)
-		};
-	},
-)
-```
 
 ### `ACTIVE`
 
-Un [[entità]] `ACTIVE` è in attesa di risposte.
+In attesa di risposte `Yes` o `No`.
 
-Se la risposta è positiva, aggiunge il mittente allo spanning tree: 
+Se la risposta è `Yes`, aggiunge il mittente allo [[spanning tree]].
-```rust
-on_receive!(
-	Answer::Yes => {
-		self.neighbours_in_tree.insert(sender);
-	}
-)
-```
 
-E poi la conteggia:
+Inoltre, [[contatore|conta]] tutte le risposte che ha ricevuto, passando a `DONE` quando sono tante quante i vicini a cui ha inviato la domanda.
-```rust
-on_receive!(
-	Answer => {
-		self.received += 1
-		if self.neighbours.length() > self.received {
-			state!(DONE);
-		}
-	},
-)
-```
 
-Inoltre, risponde alle domande con `Answer::No`:
+Essendo già parte dello [[spanning tree]], risponde alle `Question` con `No`.
-```rust
-on_receive!(
-	Question => {
-		send!(sender, Answer::No);
-	}
-)
-```
 
 ### `DONE`
 
-Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
-
 Non fa nient'altro.
 
+
 ## [[algoritmo corretto|Correttezza]]
 
-Dato che:
+> [!Success]
-1. Tutte le [[entità]] tranne il [[leader]] inviano esattamente un `Answer::Yes`.
+> 
-2. L'invio e la ricezione di `Answer::Yes` [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
+> Dato che:
-
+> 1. Tutte le [[entità]] tranne il [[leader]] rispondono affermativamente una sola volta.
-Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
+> 2. Una domanda e una risposta affermativa [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
+> 
+> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
 
 ## [[costo computazionale distribuito|Costo computazionale]]
 
-Questo protocollo è equivalente al [[flooding v3]], ma con le ***[[entità]] raggiunte che inviano anche una risposta***.
+| Costo | [[notazione O-grande]] | 
+|-|-|
+| [[comunicazione]] | $O(Channels)$ |
+| [[tempo]] | $O(Channels)$ |
 
 ### [[Comunicazione]]
 
-#### Singoli scambi di messaggi
+Si osserva che questo [[algoritmo]] è simile al [[flooding v3]], ma con le ***[[entità]] raggiunte che inviano anche una risposta***.
+
+#### Singoli scambi di [[messaggio|messaggi]]
 
 Controlliamo che e quanti messaggi attraversano i [[canale di comunicazione|canali]].
 
-##### Scoperta di un nuovo nodo
+##### Scoperta di una nuova [[entità]]
 
-Un nodo invia `Question`, l'altro risponda con `Answer::Yes`:
+Un'[[entità]] invia `Question`, l'altra risponde con `Yes`:
 $$
 \color{LightCoral} (2 \cdot (Entities - 1))
 $$ 
-##### Incontro di due nodi conosciuti
+##### Incontro di due [[entità]] conosciute
 
-Entrambi i nodi inviano `Question` in tutti i casi che non sono quello precedente:
+Entrambe inviano `Question` in tutti i casi che non sono quello precedente:
 $$
 \color{SpringGreen} (2 \cdot (Channels - (Entities - 1)))
 $$
 
-Entrambi i nodi poi rispondono `Answer::No`:
+Entrambe poi rispondono `Answer::No`:
 $$
 \color{SkyBlue} (2 \cdot (Channels - (Entities - 1)))
 $$
@@ -150,3 +109,11 @@ In [[notazione asintotica]], è sempre:
 $$
 \Large O(Channels)
 $$
+
+### [[Tempo]]
+
+Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
+$$
+\Large O(Channels)
+$$
+

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/shout+ protocol.md

@@ -1,117 +1,73 @@
 [[algoritmo]] di [[spanning tree construction]] che migliora lo [[shout protocol]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Ciascuna [[entità]] chiede ai propri vicini se può entrare a fare parte dello [[spanning tree]], e loro rispondono sì ***oppure nulla***.
 
-## [[Comportamento]]
-
 Il [[leader]] viene inizializzato a `LEADER`, le altre [[entità]] vengono inizializzate a `IDLE`.
 
 ### `LEADER`
 
-Il [[leader]] chiede [[impulso spontaneo|spontaneamente]] alle [[entità]] se possono entrare a fare parte dello [[spanning tree]], poi si attiva in attesa di risposte:
+[[messaggio|Chiede]] [[impulso spontaneo|spontaneamente]] ai suoi [[vicini di un'entità|vicini]] se possono entrare a fare parte dello [[spanning tree]] con `Question`, poi diventa `ACTIVE`.
-```rust
-spontaneously!({
-	self.received = 0;
-	send!(*, Question);
-	state!(ACTIVE);
-})
-```
 
 ### `IDLE`
 
-Un'[[entità]] `IDLE` è in attesa di domande.
+In attesa di ricevere `Question`.
 
-Quando ne riceve una, risponde positivamente, poi ripete la domanda e si attiva a sua volta:
+Quando ne riceve una, risponde `Yes`, poi ripete `Question` ai propri [[vicini di un'entità|vicini]] (tranne il mittente) e diventa `ACTIVE`.
-```rust
-on_receive!(
-	Question => {
-		self.received = 1;
-		self.parent = sender;
-		send!(sender, Answer::Yes);
-		send!(!sender, Question);
-		if self.neighbours.length() > self.received {
-			state!(DONE)
-		}
-		else {
-			state!(ACTIVE)
-		};
-	},
-)
-```
 
 ### `ACTIVE`
 
-Un [[entità]] `ACTIVE` è in attesa di risposte.
+In attesa di risposte `Yes`.
 
-Se la risposta è positiva, aggiunge il mittente allo spanning tree: 
+Se la risposta è `Yes`, aggiunge il mittente allo [[spanning tree]].
-```rust
-on_receive!(
-	Answer::Yes => {
-		self.neighbours_in_tree.insert(sender);
-	}
-)
-```
 
-E poi la conteggia:
+Inoltre, [[contatore|conta]] ***tutti i messaggi*** che ha ricevuto, passando a `DONE` quando sono tante quante i vicini a cui ha inviato la domanda.
-```rust
-on_receive!(
-	Answer => {
-		self.received += 1
-		if self.neighbours.length() > self.received {
-			state!(DONE);
-		}
-	},
-)
-```
 
-***Invece che rispondere alle domande, esse vengono interpretate come una risposta negativa***:
+> [!Tip]
-```rust
+> Le `Question` provenienti dai vicini sono considerate dei `No`.
-on_receive!(
-	Question => {
-		self.received += 1
-		if self.neighbours.length() > self.received {
-			state!(DONE);
-		}
-	}
-)
-```
 
 ### `DONE`
 
-Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
-
 Non fa nient'altro.
 
 ## [[algoritmo corretto|Correttezza]]
 
-Dato che:
+> [!Success]
-1. Tutte le [[entità]] tranne il [[leader]] inviano esattamente un `Answer::Yes`.
+> 
-2. L'invio e la ricezione di `Answer::Yes` [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
+> Dato che:
-
+> 1. Tutte le [[entità]] tranne il [[leader]] rispondono affermativamente una sola volta.
-Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
+> 2. Una domanda e una risposta affermativa [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
+> 
+> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
 
 ## [[costo computazionale distribuito|Costo computazionale]]
 
-Questo protocollo è equivalente al [[flooding v3]], ma con le [[entità]] raggiunte che inviano anche una risposta.
+| Costo | [[notazione O-grande]] |
+|-|-|
+| [[comunicazione]] | $O(Channels)$ |
+| [[tempo]] | $O(Channels)$ |
 
 ### [[Comunicazione]]
 
+Si osserva che questo [[algoritmo]] è simile al [[flooding v3]], ma con le ***[[entità]] raggiunte che inviano anche una risposta***.
+
 #### Singoli scambi di messaggi
 
 Controlliamo che e quanti messaggi attraversano i [[canale di comunicazione|canali]].
 
-##### Scoperta di un nuovo nodo
+##### Scoperta di una nuova [[entità]]
 
-Un nodo invia `Question`, l'altro risponda con `Answer::Yes`.
+Un'[[entità]] invia `Question`, l'altra risponde con `Yes`.
 
 Si verifica in:
 $$
 \color{LightCoral} (2 \cdot (Entities - 1))
 $$ 
-##### Incontro di due nodi conosciuti
+##### Incontro di due [[entità]] conosciute
 
-Entrambi i nodi inviano `Question` in tutti i casi che non sono quello precedente:
+Entrambe inviano `Question` in tutti i casi che non sono quello precedente:
 $$
 \color{SpringGreen} (2 \cdot (Channels - (Entities - 1)))
 $$
@@ -144,6 +100,14 @@ $$
 \Large O(Channels)
 $$
 
-## Duale
 
-Il duale di questo algoritmo è la [[leader election su grafo aciclico]].
+### [[Tempo]]
+
+Il [[grafo]] potrebbe essere un [[cammino]], che richiederebbe che ogni arco venisse attraversato, quindi sicuramente:
+$$
+\Large O(Channels)
+$$
+
+## [[Duale]]
+
+- [[leader election su grafo aciclico]]

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/spanning tree construction.md

@@ -7,19 +7,21 @@ Si vuole determinare uno [[spanning tree]] per il [[sistema distribuito]] in mod
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- [[iniziatore singolo]]
+	- [[full-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
-	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
+	- [[risveglio singolo]]
 	- [[terminazione locale]]
 
 ## [[algoritmo|Algoritmi]]
 
-- [[shout protocol]]
+- **Flooding-based**
-- [[shout+ protocol]]
+	- [[shout protocol]]
-- [[traversal protocol]]
+	- [[shout+ protocol]]
-- [[traversal+ protocol]]
+- **Depth-first-search-based**
+	- [[traversal protocol]]
+	- [[traversal+ protocol]]

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/token metaforico.md

@@ -0,0 +1,6 @@
+---
+aliases:
+  - token
+---
+
+[[Privilegio]] [[trasferibile]] posseduto da un'[[entità]] di un [[sistema distribuito]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal protocol.md

@@ -1,101 +1,62 @@
 [[algoritmo]] di [[spanning tree construction]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Le [[entità]] del grafo vengono visitate sequenzialmente attraverso una [[depth-first search]].
 > 
 > In ogni momento, a solo una [[entità]] è permesso eseguire codice, e questo permesso è tracciato attraverso un [[token metaforico]].
 
-## [[Comportamento]]
+Il [[leader]] viene inizializzato a `LEADER`, le altre [[entità]] vengono inizializzate a `IDLE`.
-
-L'[[entità]] [[iniziatore singolo|iniziatrice]] viene inizializzata a `LEADER`, mentre le altre vengono inizializzate a `IDLE`.
-
-==Questo modello è brutto...==
-
-### `visit_next(self)`
-
-Definiamo una funzione che si ripeterà più volte che invia il token al primo nodo non visitato dal nodo attuale, e quando non rimangono più token, notifica il nodo genitore.
-```rust
-impl Entity {
-	fn visit_next(self) {
-		if self.unvisited.length() > 0 {
-			state!(VISITED);
-			let entity = self.unvisited.pop();
-			send!(entity, Token::Forward);
-		}
-		else {
-			if(self.parent) {
-				send!(self.parent, Token::Finished);
-			}
-			state!(DONE);
-		}
-	}
-}
-```
 
 ### `LEADER`
 
-L'[[entità]] `LEADER` inizia la visita:
+Inizia possedendo il [[token metaforico]].
-```rust
+
-spontaneously!({
+Inizia la visita inviando il [[token metaforico|token]] al primo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`, diventando `VISITED`.
-	self.unvisited = self.neighbours.clone();
-	self.parent = null;
-	self.children = vec![];
-	state!(VISITED);
-	self.visit_next();
-})
-```
 
 ### `IDLE`
 
-Una [[entità]] `IDLE` è in attesa di ricevere il [[token metaforico]]:
+In attesa di ricevere il [[token metaforico]].
-```rust
+
-on_receive!(
+Quando riceve il token `Forward`:
-	Token::Forward => {
+1. memorizza il mittente come genitore;
-		self.parent = sender;
+2. procede con la visita inviando il [[token metaforico|token]] al primo suo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`;
-		self.unvisited.remove(sender);
+3. diventa `VISITED`.
-		state!(VISITED);
-		self.visit_next();
-	}
-)
-```
 
 ### `VISITED`
 
-Una [[entità]] `VISITED` ha già ricevuto il [[token metaforico]] in precedenza, e se lo riceve, lo rifiuta con `Token::BackEdge`, che porta a una nuova visita da parte del mittente:
+Ha già ricevuto il [[token metaforico]] in precedenza.
-```rust
-on_receive!(
-	Token::Forward => {
-		self.unvisited.remove(sender);
-		send!(sender, Token::BackEdge);
-	}
-	Token::BackEdge => {
-		self.visit_next();
-	}
-)
-```
 
-Può anche ricevere un `Token::Finished`, che indica che l'[[entità]] mittente ha terminato l'elaborazione; essa viene aggiunta all'albero, e poi la visita continua:
+Se lo riceve con il tag `Forward`, lo rimanda al mittente con il tag `AlreadyVisited`.
-```rust
+
-on_receive!(
+Se lo riceve con il tag `AlreadyVisited`, invia il [[token metaforico|token]] al prossimo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`.
-	Token::Finished => {
+
-		self.children.push(sender);
+Se lo riceve con il tag `Backward`, aggiunge all'[[albero]] il mittente, e poi invia il [[token metaforico|token]] al prossimo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`.
-		self.visit_next();
+
-	}
+Se riceve nuovamente il [[token metaforico|token]], e non ha altri vicini da visitare, restituisce il [[token metaforico|token]] al genitore, poi diventa `DONE`.
-)
-```
 
 ### `DONE`
 
-Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
-
 Non fa nient'altro.
 
 ## [[algoritmo corretto|Correttezza]]
 
-==...==
+> [!Success]
+> 
+> Dato che:
+> 1. Tutte le [[entità]] tranne il [[leader]] inviano `Finished` una sola volta.
+> 2. Un `Forward` e un `Backward`  [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
+> 
+> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
 
 ## [[costo computazionale distribuito|Costo computazionale]]
 
+| Costo | [[notazione O-grande]] | 
+|-|-|
+| [[comunicazione]] | $O(Channels)$ |
+| [[tempo]] | $O(Channels)$ |
+
 ### [[Comunicazione]]
 
 Tutti i [[canale di comunicazione|canali]] vengono visitati due volte, uno da `Token::Forward`, e uno da `Token::BackEdge` o `Token::Finished`:
@@ -108,9 +69,6 @@ $$
 \Large O(Channels)
 $$
 
-> [!Note]
-> Coincide strettamente con il lower bound.
-
 ### [[Tempo]]
 
 Essendo la visita del grafo sequenziale, il tempo richiesto coincide con il costo di comunicazione:
@@ -122,6 +80,3 @@ In [[notazione asintotica]], è:
 $$
 \Large O(Channels)
 $$
-
-> [!Warning]
-> Non coincide con il lower bound!

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal+ protocol.md

@@ -1,126 +1,66 @@
 [[algoritmo]] di [[spanning tree construction]] che migliora il [[traversal protocol]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Le [[entità]] del grafo vengono visitate sequenzialmente attraverso una [[depth-first search]].
 > 
 > In ogni momento, a solo una [[entità]] è permesso ***visitarne altre***, e questo permesso è tracciato attraverso un [[token metaforico]].
 
-## [[Comportamento]]
-
-L'[[entità]] [[iniziatore singolo|iniziatrice]] viene inizializzata a `LEADER`, mentre le altre vengono inizializzate a `IDLE`.
-
-==Questo modello è brutto e sbagliato nel caso ci sia un grafo di un nodo solo...==
-
-### `visit_next(self)`
-
-Definiamo una funzione che si ripeterà più volte che invia il token al primo nodo non visitato dal nodo attuale, e quando non rimangono più token, notifica il nodo genitore.
-```rust
-impl Entity {
-	fn visit_next(self) {
-		if self.unvisited.length() > 0 {
-			state!(VISITED);
-			let entity = self.unvisited.pop();
-			send!(entity, Token::Forward);
-		}
-		else {
-			if(self.parent) {
-				send!(self.parent, Token::Finished);
-			}
-			state!(DONE);
-		}
-	}
-}
-```
-
 ### `LEADER`
 
-L'[[entità]] `LEADER` ***notifica tutti i suoi vicini che è stata visitata***:
+Inizia possedendo il [[token metaforico]].
-```rust
-spontaneously!({
-	self.unacknowledged = self.neighbours.clone();
-	self.unvisited = self.neighbours.clone();
-	self.parent = null;
-	self.children = vec![];
-	send!(self.unvisited, Visited::Sender);
-})
-```
 
-***Quando tutti i vicini hanno risposto, inizia la visita:***
+***Parte notificando tutti i suoi [[vicini di un'entità|vicini]] di possedere il token con il tag `Own`.***
-```rust
+
-on_receive!(
+Poi, inizia la visita inviando il [[token metaforico|token]] al primo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`, diventando `VISITED`.
-	Visited::Receiver => {
-		self.unacknowledged.remove(sender);
-		if self.unacknowledged.length() == 0 {
-			state!(VISITED);
-			self.visit_next();
-		}
-	}
-)
-```
 
 ### `IDLE`
 
-Una [[entità]] `IDLE` è in attesa di ricevere il [[token metaforico]].  
+In attesa di ricevere il [[token metaforico]], ***e in ascolto per notifiche `Own`***.
-***Quando lo riceve, notifica tutti i vicini della cosa, come fatto dal leader***:
-```rust
-spontaneously!({
-	self.unacknowledged = self.neighbours.clone();
-	self.unvisited = self.neighbours.clone();
-	self.children = vec![];
-})
 
-on_receive!(
+***Quando riceve una notifica `Own`***:
-	Token::Forward => {
+1. ***esclude il mittente dai [[vicini di un'entità|vicini]] da visitare.***
-		self.parent = sender;
-		self.unvisited.remove(sender);
-		send!(self.unvisited, Visited::Sender);
-	}
 
-	Visited::Receiver => {
+Quando riceve il token `Forward`:
-		self.unacknowledged.remove(sender);
+1. memorizza il mittente come genitore;
-		if self.unacknowledged.length() == 0 {
+2. notifica tutti i [[vicini di un'entità|vicini]] con il tag `Own`;
-			state!(VISITED);
+3. procede con la visita inviando il [[token metaforico|token]] al primo suo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`;
-			self.visit_next();
+4. diventa `VISITED`.
-		}		
-	}
-
-	Visited::Sender => {
-		self.unvisited.remove(sender);
-		send!(sender, Visited::Receiver);
-	}
-)
-```
 
 ### `VISITED`
 
-Una [[entità]] `VISITED` ha già ricevuto il [[token metaforico]] in precedenza.
+Ha già ricevuto il [[token metaforico]] in precedenza.
 
-Può ricevere ***solo*** un `Token::Finished`, che indica che l'[[entità]] mittente ha terminato l'elaborazione; essa viene aggiunta all'albero, e poi la visita continua:
+> [!Note]
-```rust
+> ***È impossibile che riceva `Forward` o `AlreadyVisited` per via del meccanismo di `Own`.***
-on_receive!(
-	Token::Finished => {
-		self.children.push(sender);
-		self.visit_next();
-	}
-)
-```
 
-***Non è possibile che riceva `Visited::Sender`, in quanto è già stata rimossa da `self.unvisited`.***
+Se lo riceve con il tag `Backward`, aggiunge all'[[albero]] il mittente, e poi invia il [[token metaforico|token]] al prossimo [[vicini di un'entità|vicino]] non visitato con il tag `Forward`.
 
-***Per lo stesso motivo, `Token::BackEdge` sono stati rimossi dall'algoritmo.***
+Se riceve nuovamente il [[token metaforico|token]], e non ha altri vicini da visitare, restituisce il [[token metaforico|token]] al genitore, poi diventa `DONE`.
 
 ### `DONE`
 
-Un [[entità]] `DONE` sa tutte le informazioni possibili sui suoi vicini.
-
 Non fa nient'altro.
 
+
 ## [[algoritmo corretto|Correttezza]]
 
-==...==
+> [!Success]
+> 
+> Dato che:
+> 1. Tutte le [[entità]] tranne il [[leader]] inviano `Finished` una sola volta.
+> 2. Un `Forward` e un `Backward`  [[arco di un grafo|collegano]] le due [[entità]] coinvolte.
+> 
+> Allora, il [[grafo]] risultante è un [[albero]] [[grafo connesso|connesso]].
 
 ## [[costo computazionale distribuito|Costo computazionale]]
 
+| Costo | [[notazione O-grande]] | 
+|-|-|
+| [[comunicazione]] | $O(Channels)$ |
+| [[tempo]] | $O(Channels)$ |
+
 ### [[Comunicazione]]
 
 Tutti i [[canale di comunicazione|canali]] vengono visitati due volte, uno da `Visited::Sender`, e uno da `Visited::Receiver`:
@@ -156,7 +96,7 @@ $$
 $$
 
 > [!Note]
-> Coincide ***asintoticamente*** con il lower bound.
+> Coincide ***asintoticamente*** con il [[notazione Ω-grande|lower bound]] della [[spanning tree construction]].
 
 ### [[Tempo]]
 
@@ -185,4 +125,4 @@ $$
 $$
 
 > [!Note]
-> ***Coincide asintoticamente*** con il lower bound.
+> ***Coincide asintoticamente*** con il [[notazione Ω-grande|lower bound]] della [[spanning tree construction]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/★ spanning tree.canvas

@@ -1,22 +1,20 @@
 {
 	"nodes":[
-		{"id":"f48243a62762bc6a","type":"group","x":780,"y":-1300,"width":920,"height":1000,"color":"5","label":"shout protocol"},
+		{"id":"f48243a62762bc6a","type":"group","x":780,"y":-1300,"width":920,"height":1000,"label":"shout protocol"},
-		{"id":"a7b374601b504754","type":"group","x":780,"y":-180,"width":920,"height":1000,"color":"5","label":"traversal protocol"},
+		{"id":"a7b374601b504754","type":"group","x":780,"y":-180,"width":920,"height":1000,"label":"traversal protocol"},
 		{"id":"e4db85d4dd9cb928","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/spanning tree construction.md","x":-320,"y":-1280,"width":960,"height":2080},
 		{"id":"42f2908da34c9d4d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/spanning tree.md","x":-40,"y":-1840,"width":400,"height":400},
 		{"id":"975c4e916151d0da","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/shout protocol.md","x":800,"y":-1280,"width":400,"height":960},
-		{"id":"6affd8da4f6f750a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md","x":800,"y":-1840,"width":400,"height":400},
 		{"id":"1942e37fcdb3b040","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/shout+ protocol.md","x":1280,"y":-1280,"width":400,"height":960},
 		{"id":"7f269696427c2c8e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal protocol.md","x":800,"y":-160,"width":400,"height":960},
 		{"id":"b59b4cc2872c280d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/broadcast tree construction.md","x":-320,"y":960,"width":960,"height":960},
 		{"id":"1ccd23a5dd951996","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/multiple spanning tree construction.md","x":-320,"y":2080,"width":960,"height":960},
-		{"id":"899da42b0ed0d514","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/selective spanning tree transform.md","x":800,"y":2080,"width":400,"height":400},
 		{"id":"e12fb2819e6c8318","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/traversal+ protocol.md","x":1280,"y":-160,"width":400,"height":960},
+		{"id":"899da42b0ed0d514","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/selective spanning tree transform.md","x":800,"y":2080,"width":400,"height":400},
 		{"id":"289f00f041183fee","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/multiple spanning tree transform.md","x":800,"y":2640,"width":400,"height":400}
 	],
 	"edges":[
 		{"id":"0b872430734f1f17","fromNode":"42f2908da34c9d4d","fromSide":"bottom","toNode":"e4db85d4dd9cb928","toSide":"top"},
-		{"id":"0987f6cc5f169aff","fromNode":"6affd8da4f6f750a","fromSide":"bottom","toNode":"975c4e916151d0da","toSide":"top"},
 		{"id":"1def3d7fb4e72c80","fromNode":"975c4e916151d0da","fromSide":"right","toNode":"1942e37fcdb3b040","toSide":"left"},
 		{"id":"d6cdc039af788cc2","fromNode":"e4db85d4dd9cb928","fromSide":"right","toNode":"f48243a62762bc6a","toSide":"left"},
 		{"id":"10b12980f5c61ace","fromNode":"e4db85d4dd9cb928","fromSide":"right","toNode":"a7b374601b504754","toSide":"left"},

9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/computazione in alberi.md

@@ -7,16 +7,17 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- ***[[iniziatore singolo]]***
+	- [[full-duplex]]
-	- ***[[identificatori univoci]]***
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
-	- [[full-duplex|grafo indiretto]]
 	- [[grafo connesso]]
+	- ***[[identificatori univoci]]***
 	- ***[[albero]]***
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
+	- [[risveglio singolo]]
+	- [[terminazione locale]]
 
 ## [[algoritmo|Algoritmi]]
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/computazione in grafi aciclici.md

@@ -7,15 +7,16 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- ***[[iniziatori multipli]]***
+	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
-	- [[full-duplex|grafo indiretto]]
 	- [[grafo connesso]]
 	- ***[[grafo aciclico]]***
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
+	- ***[[risveglio parziale]]***
+	- [[terminazione locale]]
 
 ## [[algoritmo|Algoritmi]]
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per alberi.md

@@ -1,12 +1,14 @@
-[[algoritmo]] di [[computazione in grafi aciclici]].
+[[algoritmo]] di [[computazione in alberi]].
-
-> [!Summary]
-> Si distribuisce un dato a ogni [[entità]], che effettua la computazione per i dati dei suoi figli e ne invia il risultato al genitore.  
-> 
-> Processati tutti i dati, viene effettuato un [[broadcast problem|broadcast]] ***dalla radice-[[leader]]*** per distribuire i risultati dell'algoritmo a tutti.
 
 ## [[Comportamento]]
 
+> [!Summary]
+> Si distribuisce un dato a ogni [[entità]].
+> 
+> Ogni [[entità]] effettua la computazione richiesta con il suo dato, più i dati ricevuti dai figli, inviando successivamente il risultato al genitore.
+> 
+> Una volta che la [[radice di un albero|radice]] ha processato i propri dati, effettua un [[broadcast problem|broadcast]] per distribuire il [[risultato]] a tutti.
+
 ### ***`LEADER`***
 
 Invia un ***[[broadcast problem|broadcast]]*** a tutte le altre [[entità]], poi tutte passano ad `ACTIVE`.

9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas

@@ -1,21 +1,14 @@
 {
 	"nodes":[
-		{"id":"f10431539991943d","type":"group","x":620,"y":-500,"width":440,"height":2040,"color":"5","label":"Saturazione"},
+		{"id":"f10431539991943d","type":"group","x":620,"y":-500,"width":440,"height":2040,"label":"Saturazione"},
 		{"id":"d9e8c63362870000","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/computazione in grafi aciclici.md","x":-480,"y":-480,"width":960,"height":960},
 		{"id":"eac3f8232a170480","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per grafi aciclici.md","x":640,"y":-480,"width":400,"height":960},
 		{"id":"da6b01f674dba080","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/computazione in alberi.md","x":-480,"y":560,"width":960,"height":960},
-		{"id":"c217a97b6c1f113a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per alberi.md","x":640,"y":560,"width":400,"height":960},
+		{"id":"c217a97b6c1f113a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/tecnica di saturazione per alberi.md","x":640,"y":560,"width":400,"height":960}
-		{"id":"39e8d6989eaff333","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/★ broadcast.canvas","x":-1280,"y":80,"width":400,"height":400},
-		{"id":"4295118739ed5400","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/★ spanning tree.canvas","x":-1280,"y":560,"width":400,"height":400},
-		{"id":"810c6eab5eed44f9","type":"text","text":"# +","x":-720,"y":480,"width":80,"height":80}
 	],
 	"edges":[
 		{"id":"3cc5d31160347382","fromNode":"d9e8c63362870000","fromSide":"bottom","toNode":"da6b01f674dba080","toSide":"top","fromEnd":"arrow"},
 		{"id":"a42fc5dd73c9697e","fromNode":"d9e8c63362870000","fromSide":"right","toNode":"eac3f8232a170480","toSide":"left"},
-		{"id":"a4aa89137c417d7c","fromNode":"da6b01f674dba080","fromSide":"right","toNode":"c217a97b6c1f113a","toSide":"left"},
+		{"id":"a4aa89137c417d7c","fromNode":"da6b01f674dba080","fromSide":"right","toNode":"c217a97b6c1f113a","toSide":"left"}
-		{"id":"e8ceea408a7b8113","fromNode":"39e8d6989eaff333","fromSide":"right","toNode":"810c6eab5eed44f9","toSide":"left"},
-		{"id":"9af232a35509d74c","fromNode":"4295118739ed5400","fromSide":"right","toNode":"810c6eab5eed44f9","toSide":"left"},
-		{"id":"081976471054dfad","fromNode":"810c6eab5eed44f9","fromSide":"right","toNode":"d9e8c63362870000","toSide":"left"},
-		{"id":"b970bd9a8d0081cd","fromNode":"810c6eab5eed44f9","fromSide":"right","toNode":"da6b01f674dba080","toSide":"left"}
 	]
 }

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su albero.md

@@ -1,4 +1,6 @@
 [[algoritmo]] di [[leader election]] per [[albero|alberi]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > La radice diventa automaticamente il [[leader]].

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello all-the-way.md

@@ -1,15 +1,17 @@
 [[algoritmo]] di [[leader election]] su [[anello]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Ogni [[entità]] invia il suo [[identificatore]] alla successiva, e gli inoltra gli identificatori ricevuti dalla precedente, tenendo traccia dell'identificatore minimo ricevuto.
 
 ## [[algoritmo corretto|Correttezza]]
 
-> [!Error]
+> [!Failure]
 > 
 > L'algoritmo non giungerà mai a termine!
 > 
-> Sono necessarie restrizioni aggiuntive, vedi:
-> - [[leader election su anello di dimensione conosciuta all-the-way]]
-> - [[leader election su anello first-in-first-out all-the-way]]
 
+Sono necessarie restrizioni aggiuntive, vedi:
+- [[leader election su anello di dimensione conosciuta all-the-way]]
+- [[leader election su anello first-in-first-out all-the-way]]

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md

@@ -1,5 +1,7 @@
 [[algoritmo]] di [[leader election]] su [[anello]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > 
 > Ogni [[entità]] riceve identificatori dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla successiva qualsiasi cambiamento al proprio minimo.

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md

@@ -1,5 +1,7 @@
 [[algoritmo]] di [[leader election]] su [[anello]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Effettua iterazioni in cui ogni [[entità]] che potrebbe diventare potenzialmente [[leader]] diffonde il proprio [[identificatore]] a tutte le altre entro una certa distanza.
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md

@@ -1,5 +1,7 @@
 [[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]] ***introducendo una [[restrizione di topologia]] aggiuntiva.***
 
+## [[Comportamento]]
+
 > [!Summary]
 > Ogni [[entità]] invia il suo [[identificatore]] alla successiva, e gli inoltra gli identificatori ricevuti dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, ***fino a quando non ne conosce tanti quante le [[entità]] del [[sistema distribuito]]***.
 

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su grafo aciclico.md

@@ -1,8 +1,10 @@
 [[algoritmo]] di [[leader election]] su [[grafo aciclico|grafi aciclici]].
 
+## [[Comportamento]]
+
 > [!Summary]
 > Usa la [[tecnica di saturazione per grafi aciclici]] per trovare l'entità con [[identificatore]] minore, che viene poi scelta come [[leader]].
 
-## Duale
+## [[Duale]]
 
-Il duale di questo algoritmo è lo [[shout+ protocol]].
+- [[shout+ protocol]]

9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election.md

@@ -7,17 +7,17 @@ Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritm
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 
 - **[[restrizione di comunicazione|Comunicazione]]**
-	- [[iniziatori multipli]]
+	- [[half-duplex]]
-	- [[identificatori univoci]]
-		- **[[Angluin 1980]]**: questo problema è irrisolvibile senza identificatori univoci
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
-	- [[full-duplex|grafo indiretto]]
 	- [[grafo connesso]]
-	- [[half-duplex|grafo diretto]]
+	- [[identificatori univoci]]
+		- il teorema [[Angluin 1980]] li pone come requisito per la risolvibilità
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione unitario]]
+	- [[risveglio parziale]]
+	- [[terminazione locale]]
 
 ## [[algoritmo|Algoritmi]]
 

9 - Algoritmi distribuiti/★ algoritmi distribuiti.md

@@ -8,6 +8,6 @@ Appunti del corso di ***Algoritmi distribuiti***, tenuto da [[Manuela Montangero
 	1. [[★ concetti.canvas|★ concetti]]
 	2. [[★ broadcast.canvas|★ broadcast]]
 	3. [[★ spanning tree.canvas|★ spanning tree]]
-	4. [[★ computation in trees.canvas|★ computation in trees]]
+	4. [[★ computazione.canvas|★ computation in trees]]
 	5. [[★ leader election.canvas|★ leader election]]
 	6. [[★ routing.canvas|★ routing]]