Complete 9 - Algoritmi distribuiti/6 - Routing

2024-11-25 03:34:17 +00:00 · 2023-11-11 19:41:34 +01:00 · 2023-11-11 19:41:34 +01:00 · 8779441b47
commit 8779441b47
parent 2eca871583
51 changed files with 1168 additions and 669 deletions
--- a/.obsidian/plugins/obsidian-file-color/data.json
+++ b/.obsidian/plugins/obsidian-file-color/data.json
@ -269,10 +269,6 @@
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "steffo-file-index.json",
      "color": "me4XBNQC4rwzQFLlvIAn0"
@ -373,10 +369,6 @@
      "path": "9 - Algoritmi distribuiti/★ algoritmi distribuiti.md",
      "color": "7j7Pqog0VHMVVAfazMNlb"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
      "color": "7j7Pqog0VHMVVAfazMNlb"
    },
    {
      "path": "0 - Piano di studi/★ piano di studi.md",
      "color": "7j7Pqog0VHMVVAfazMNlb"
@ -386,15 +378,43 @@
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md",
+      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti bizantini.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md",
+      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti su grafo completo.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
-      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md",
+      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge-broadcast-possibility.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/ft-broad-election.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election con fallimenti su grafo completo.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/teorema innominato.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/two steps.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
      "color": "7j7Pqog0VHMVVAfazMNlb"
    },
    {
      "path": "9 - Algoritmi distribuiti/4 - Strutture dati distribuite",
      "color": "fc3lLaITDn62PYbzBhqxl"
    },
    {
      "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/centralized routing.md",
      "color": "fc3lLaITDn62PYbzBhqxl"
    }
  ]
--- a/.obsidian/workspace.sync-conflict-20231104-233155-TC3LVPI.json
+++ b/.obsidian/workspace.sync-conflict-20231104-233155-TC3LVPI.json
@ -1,212 +0,0 @@
 {
  "main": {
    "id": "ea42b6c6a6ada42e",
    "type": "split",
    "children": [
      {
        "id": "353bd9b9e09f62d7",
        "type": "tabs",
        "children": [
          {
            "id": "6e2c961c3fbc766e",
            "type": "leaf",
            "state": {
              "type": "canvas",
              "state": {
                "file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
                "viewState": {
                  "x": 569.2194349966362,
                  "y": -1224.5487072802703,
                  "zoom": -2.8
                }
              }
            }
          }
        ],
        "stacked": true
      }
    ],
    "direction": "vertical"
  },
  "left": {
    "id": "3dc78bddd518c3f3",
    "type": "split",
    "children": [
      {
        "id": "d5fc1d7e0478ba75",
        "type": "tabs",
        "children": [
          {
            "id": "cc2c082e511eafc9",
            "type": "leaf",
            "state": {
              "type": "file-explorer",
              "state": {
                "sortOrder": "alphabetical"
              }
            }
          },
          {
            "id": "4240e87522252410",
            "type": "leaf",
            "state": {
              "type": "search",
              "state": {
                "query": "stato di un'enti",
                "matchingCase": false,
                "explainSearch": false,
                "collapseAll": false,
                "extraContext": false,
                "sortOrder": "alphabetical"
              }
            }
          },
          {
            "id": "7b02a464bd7f94f4",
            "type": "leaf",
            "state": {
              "type": "bookmarks",
              "state": {}
            }
          }
        ]
      }
    ],
    "direction": "horizontal",
    "width": 282.5
  },
  "right": {
    "id": "4ef3f291c2866b38",
    "type": "split",
    "children": [
      {
        "id": "a0f58612eee5101f",
        "type": "tabs",
        "children": [
          {
            "id": "da0ecf3eab9f1146",
            "type": "leaf",
            "state": {
              "type": "backlink",
              "state": {
                "file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
                "collapseAll": false,
                "extraContext": false,
                "sortOrder": "alphabetical",
                "showSearch": false,
                "searchQuery": "",
                "backlinkCollapsed": false,
                "unlinkedCollapsed": true
              }
            }
          },
          {
            "id": "517852a0c1eb77e0",
            "type": "leaf",
            "state": {
              "type": "outgoing-link",
              "state": {
                "file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
                "linksCollapsed": false,
                "unlinkedCollapsed": true
              }
            }
          },
          {
            "id": "7e28c6b81ba7a75b",
            "type": "leaf",
            "state": {
              "type": "tag",
              "state": {
                "sortOrder": "frequency",
                "useHierarchy": true
              }
            }
          },
          {
            "id": "d08b5edb3d762c99",
            "type": "leaf",
            "state": {
              "type": "outline",
              "state": {
                "file": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas"
              }
            }
          },
          {
            "id": "3da04ae84a020b40",
            "type": "leaf",
            "state": {
              "type": "all-properties",
              "state": {
                "sortOrder": "frequency"
              }
            }
          }
        ]
      }
    ],
    "direction": "horizontal",
    "width": 300,
    "collapsed": true
  },
  "left-ribbon": {
    "hiddenItems": {
      "canvas:Create new canvas": true,
      "switcher:Open quick switcher": false,
      "graph:Open graph view": false,
      "templates:Insert template": false
    }
  },
  "active": "6e2c961c3fbc766e",
  "lastOpenFiles": [
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo sincrono.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/criterio di costo asincrono.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di tempo.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione limitato.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sistema distribuito asincrono.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/tick.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione illimitato.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione globale.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/terminazione locale.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/teorema innominato.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/sincronicità.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge-broadcast-possibility.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/ft-broad-election.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election con fallimenti su grafo completo.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/two steps.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti su grafo completo.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/one step.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/flooding v3.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso broadcast.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/condiviso.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/component failure.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/temporary fault.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/permanent fault.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti/crash fault.md",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/X - Guasti",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/Untitled",
    "9 - Algoritmi distribuiti/0 - Materiale di studio/Slides/07 - Routing.pdf",
    "steffo-file-index.sync-conflict-20231102-110633-UV5KNJL.json",
    "9 - Programmazione mobile/0 - Materiale di studio/Slides/2 - Computer graphics/6 - GLTextures.pdf",
    "9 - Programmazione mobile/0 - Materiale di studio/Slides/1 - Android/05 - MultiThread.pdf",
    "9 - Programmazione mobile/0 - Materiale di studio/Slides/1 - Android/01 - IntroMobileOS.pdf",
    "9 - Programmazione mobile/0 - Materiale di studio/Slides/2 - Computer graphics/8 - GLCS.pdf",
    "9 - Programmazione mobile/0 - Materiale di studio/Slides/1 - Android/06 - AndroidX&More.pdf",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/★ routing.canvas",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/★ leader election.canvas",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computation in trees/★ computation in trees.canvas",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Routing/★ routing.canvas",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/3 - Spanning tree/★ spanning tree.canvas",
    "9 - Algoritmi distribuiti/3 - Computazione distribuita/2 - Broadcast/★ broadcast.canvas",
    "8 - Crittografia applicata/★ indice.canvas",
    "7 - Big data analytics/★ indice.canvas",
    "0 - Generale/★ esami.canvas",
    "8 - Sistemi complessi/3 - Automi cellulari/modello HPP · regola di transizione.png",
    "8 - Crittografia applicata/3 - Comunicazione/2 - Garanzie/2 - Indistinguibilità/Pasted image 20230331181648.png"
  ]
 }
--- a/Generale/hash
+++ b/Generale/hash
@ -0,0 +1,9 @@
 ---
 aliases:
  - dizionario
  - oggetto JavaScript
  - dict
  - mappa
 ---
 [[struttura dati]] che associa una [[chiave]] a un [[valore]], utilizzando l'[[hash]] della [[chiave]] come indice.
--- a/Generale/indicizzazione
+++ b/Generale/indicizzazione
@ -0,0 +1,9 @@
 Enumerazione che inizia dal valore `0`, e usa quel valore per il primo elemento conteggiato.
 > [!Example]
 > Gli array nella maggior parte dei linguaggi di programmazione.
 È possibile convertirlo in [[indicizzazione a 1]] sommando $1$ all'indice:
 $$
 Index_0 + 1
 $$
--- a/Generale/indicizzazione
+++ b/Generale/indicizzazione
@ -0,0 +1,9 @@
 Enumerazione che inizia dal valore `1`, e usa quel valore per il primo elemento conteggiato. 
 > [!Example]
 > Gli array in [[Lua]].
 È possibile convertirlo in [[indicizzazione a 0]] sottraendo $1$ all'indice:
 $$
 Index_1 - 1
 $$
--- a/distribuito.md
+++ b/distribuito.md
@ -1,36 +1,40 @@
 [[algoritmo]] di ==PROBLEMA==.
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 ==...==
 ## [[Comportamento]]
 > [!Summary]
 > ==...==
 ## [[Comportamento]]
 ### ==`STATO1`==
 ==...==
 ```rust
 ```
 ### ==`STATO2`==
 ==...==
 ```rust
 ```
 ## [[algoritmo corretto|Correttezza]]
-==...==
+> [!Success]
 > ==...==
 > [!Failure]
 > ==...==
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | ==...== |
 | [[tempo]] | ==...== |
 ### [[Comunicazione]]
 ==...==
 ### [[Spazio]]
 ==...==
 ### [[Tempo]]
 ==...==
--- a/Concetti/dimensione
+++ b/Concetti/dimensione
@ -0,0 +1,3 @@
 [[restrizione di comunicazione]].
 Specifica che i [[messaggio|messaggi]] possono occupare qualsiasi [[9 - Algoritmi distribuiti/1 - Problemi/spazio|spazio]] sia necessario.
--- a/Concetti/dimensione
+++ b/Concetti/dimensione
@ -0,0 +1,6 @@
 [[restrizione di comunicazione]].
 Specifica che i [[messaggio|messaggi]] devono occupare [[9 - Algoritmi distribuiti/1 - Problemi/spazio|spazio]] inferiore di una certa costante.
 > [!Note]
 > Spesso applicata assieme a [[ritardo di comunicazione unitario]] per non trivializzare i problemi.
--- a/Concetti/risveglio
+++ b/Concetti/risveglio
--- a/Concetti/risveglio
+++ b/Concetti/risveglio
@ -6,3 +6,6 @@ aliases:
 [[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*.
 > [!Tip]
 > Le entità iniziatrici potrebbero essere tutte!
--- a/Concetti/ritardo
+++ b/Concetti/ritardo
@ -1,3 +1,9 @@
 [[restrizione di tempo]].
 Specifica che tutti i [[messaggio|messaggi]] sono consegnati esattamente dopo un [[tick]], e che se ciò non avviene, l'invio del messaggio è fallito.
 > [!Tip]
 > È molto utile, perchè in assenza di [[guasto|guasti]], il fatto stesso di inviare o non inviare un messaggio diventa un bit di informazione!
 > [!Note]
 > Spesso applicata assieme a [[dimensione dei messaggi limitata]] per non trivializzare i problemi.
--- a/concetti.canvas
+++ b/concetti.canvas
@ -1,14 +1,7 @@
 {
 	"nodes":[
-		{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2300,"width":2440,"height":1920,"label":"Restrizioni del modello"},
+		{"id":"0e88c8c55309b762","type":"group","x":220,"y":-2580,"width":2440,"height":2200,"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},
 		{"id":"9ff0a423dbb281a0","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/rete di comunicazione.md","x":-320,"y":-160,"width":400,"height":400},
 		{"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":"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},
 		{"id":"44b1b735656f3c4b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/azione.md","x":1360,"y":1520,"width":400,"height":400},
@ -34,19 +27,19 @@
 		{"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":"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":"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":"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":"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":"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":"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":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-160,"width":400,"height":400},
 		{"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":"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":"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":"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":"5a382d3822a5736e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio ignorato.md","x":1280,"y":-1160,"width":400,"height":200,"color":"3"},
-		{"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":"00b0016663a07f0b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/risveglio multiplo.md","x":1760,"y":-1160,"width":400,"height":200,"color":"2"},
 		{"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":"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":"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":"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":"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"},
@ -54,10 +47,19 @@
 		{"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":"7862502b2075f0a7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/no failure detection.md","x":1280,"y":-2000,"width":400,"height":200,"color":"3"},
 		{"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},
 		{"id":"83b3be69f6f3d497","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/timeout.md","x":2000,"y":-160,"width":400,"height":400},
 		{"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":"961e2a0551edc3c5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di comunicazione.md","x":800,"y":-2560,"width":400,"height":480},
-		{"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"}
+		{"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"},
 		{"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":"a7babffbb19e1b32","x":1280,"y":-2560,"width":400,"height":200,"color":"3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/dimensione dei messaggi limitata.md"},
 		{"id":"b5607837b4452d83","x":2240,"y":-2560,"width":400,"height":200,"color":"1","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/dimensione dei messaggi illimitata.md"}
 	],
 	"edges":[
 		{"id":"1bb35cb60ca4ea15","fromNode":"afa296d887da4394","fromSide":"bottom","toNode":"904bb8e648bdcb90","toSide":"top"},
@ -120,6 +122,8 @@
 		{"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"}
+		{"id":"ac5fdc2d569502ff","fromNode":"fc4c48607c9ae580","fromSide":"bottom","toNode":"83b3be69f6f3d497","toSide":"top"},
 		{"id":"a8acecef3a9f4a45","fromNode":"961e2a0551edc3c5","fromSide":"right","toNode":"a7babffbb19e1b32","toSide":"left"},
 		{"id":"57ba1c5dfab48bec","fromNode":"a7babffbb19e1b32","fromSide":"right","toNode":"b5607837b4452d83","toSide":"left"}
 	]
 }
--- a/Broadcast/broadcast
+++ b/Broadcast/broadcast
@ -12,6 +12,7 @@ Una [[entità]] vuole comunicare un'informazione a tutto il resto del [[sistema
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[half-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
--- a/Broadcast/wake-up
+++ b/Broadcast/wake-up
@ -7,6 +7,7 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
@ -14,7 +15,7 @@ Problema per un [[sistema distribuito]], variante del [[broadcast problem]].
 	- [[grafo connesso]]
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
-	- ***[[risveglio parziale]]***
+	- ***[[risveglio multiplo]]***
 	- [[terminazione locale]]
 ## [[algoritmo|Algoritmi]]
--- a/construction.md
+++ b/construction.md
@ -7,6 +7,7 @@ Si vuole ***minimizzare il [[diametro di un grafo|diametro]]*** di uno [[spannin
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[full-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
--- a/construction.md
+++ b/construction.md
@ -15,7 +15,7 @@ Si vuole [[problema di ricerca|determinare]] uno [[spanning tree]] per il [[sist
 	- ***[[identificatori univoci]]***
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione unitario]]
-	- ***[[risveglio parziale]]***
+	- ***[[risveglio multiplo]]***
 	- [[terminazione locale]]
 ### [[Algoritmo|Algoritmi]]
--- a/construction.md
+++ b/construction.md
@ -7,6 +7,7 @@ Si vuole determinare uno [[spanning tree]] per il [[sistema distribuito]] in mod
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[full-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
--- a/Computazione/computazione
+++ b/Computazione/computazione
@ -7,6 +7,7 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[full-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
--- a/Computazione/computazione
+++ b/Computazione/computazione
@ -7,6 +7,7 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[full-duplex|grafo indiretto]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
@ -15,7 +16,7 @@ Si vuole calcolare qualcosa più efficientemente possibile, distribuendo gli [[9
 	- ***[[grafo aciclico]]***
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
-	- ***[[risveglio parziale]]***
+	- ***[[risveglio multiplo]]***
 	- [[terminazione locale]]
 ## [[algoritmo|Algoritmi]]
--- a/Computazione/tecnica
+++ b/Computazione/tecnica
@ -29,6 +29,13 @@ Le [[entità]] `PROCESSING` che ricevono il [[messaggio]] ***lo accettano come [
 Un'[[entità]] `DONE` conosce il [[risultato]] della computazione, e non fa nient'altro.
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Eventualmente, i messaggi convergeranno obbligatoriamente alla radice, e la sua notifica di terminazione raggiungerà eventualmente tutte le foglie.
 > 
 > ==Come si chiamano i problemi risolvibili con la saturazione?==
 ## [[costo computazionale distribuito|Costo computazionale]]
 ### [[Comunicazione]]
--- a/Computazione/tecnica
+++ b/Computazione/tecnica
@ -27,6 +27,13 @@ Le [[entità]] `PROCESSING` che ricevono il [[messaggio]] ***effettuano nuovamen
 Un'[[entità]] `DONE` conosce il [[risultato]] della computazione, e non fa nient'altro.
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Eventualmente, i messaggi convergeranno obbligatoriamente a due entità, e la loro notifica di terminazione raggiungerà eventualmente tutte le altre.
 > 
 > ==Come si chiamano i problemi risolvibili con la saturazione?==
 ## [[costo computazionale distribuito|Costo computazionale]]
 ### [[Comunicazione]]
--- a/election/fully
+++ b/election/fully
@ -0,0 +1,25 @@
 Problema per un [[sistema distribuito]] che introduce maggiori [[restrizioni al modello dei sistemi distribuiti|restrizioni]] alla [[leader election]] per ottenere [[costo computazionale]] minore.
 ## Definizione
 Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritmo]] futuro.
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- ***[[dimensione dei messaggi limitata]]***
 	- [[half-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
 - **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
 	- [[identificatori univoci]]
 - **[[restrizione di tempo|Tempo]]**
 	- ***[[ritardo di comunicazione unitario]]***
 	- [[risveglio multiplo]]
 	- [[terminazione locale]]
 ## [[algoritmo|Algoritmi]]
 - [[leader election su anello speeding]]
 - [[leader election su anello waiting]]
--- a/election/leader
+++ b/election/leader
@ -4,3 +4,15 @@
 > [!Summary]
 > La radice diventa automaticamente il [[leader]].
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > L'algoritmo è triviale e termina immediatamente.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | $0$ |
 | [[tempo]] | $0$ |
--- a/as-far-as-it-can.md
+++ b/as-far-as-it-can.md
@ -4,19 +4,23 @@
 > [!Summary]
 > 
-> Ogni [[entità]] riceve identificatori dalla precedente, tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla successiva qualsiasi cambiamento al proprio minimo.
+> Ogni [[entità]] riceve identificatori dalla [[entità precedente in un anello|precedente]], tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla [[entità successiva in un anello|successiva]] qualsiasi cambiamento al proprio minimo.
 > 
 > Quando un'[[entità]] avrà ricevuto il suo stesso identificatore dalla [[entità precedente in un anello|precedente]], essa diventerà leader, e manderà un [[broadcast problem|broadcast]] di terminazione a tutte le altre.
 ## [[algoritmo corretto|Correttezza]]
-Quando il futuro [[leader]] avrà ricevuto dalla precedente il suo stesso identificatore, l'algoritmo avrà terminato.
+> [!Success]
-
+> È certo che l'identificatore minimo di tutto il [[sistema distribuito]] attraverserà tutte le [[entità]] in esso, fino a tornare al futuro [[leader]].
 > [!Note]
 > 
-> La [[terminazione locale|terminazione è locale solo per il leader]], le altre entità hanno bisogno di un [[broadcast problem|broadcast]]. 
+> Avendo l'[[anello]] un numero finito di [[nodo di un grafo|nodi]] al suo interno, eventualmente sarà trovato un [[leader]], che a quel punto farà terminare l'esecuzione con il [[broadcast problem|broadcast]].
 ## [[costo computazionale distribuito|Costo computazionale]]
-==Includere la terminazione nel costo computazionale?==
+| Costo | [[notazione O-grande]] | [[notazione Ω-grande]] |
 |-|-|-|
 | [[comunicazione]] | $O(Entities^2)$ | $\Omega(Entities)$ |
 | [[tempo]] | ... | ... |
 ### [[Comunicazione]]
@ -24,7 +28,7 @@ Quando il futuro [[leader]] avrà ricevuto dalla precedente il suo stesso identi
 Il caso peggiore è quello in cui le [[entità]] sono [[iniziatori multipli|tutte iniziatrici]] e in ordine crescente di [[identificatore]].
-Assumendo un [[ritardo di comunicazione unitario]], avremo che:
+Nel caso peggiore, il [[ritardo di comunicazione unitario|ritardo di comunicazione sarà unitario]], quindi avremo che:
 1. il massimo sarà propagato per $1$ messaggio
 2. il secondo massimo sarà propagato per $2$ messaggi
 3. $\dots$
@ -32,16 +36,35 @@ Assumendo un [[ritardo di comunicazione unitario]], avremo che:
 Totalizzando:
 $$
-\sum_{Identifier=1}^{Entities} Identifier
+\color{LightCoral} \sum_{Identifier=1}^{Entities} Identifier
 $$
 Ovvero:
 $$
 \color{LightCoral}
 \frac
 {Entities \cdot (Entities + 1)}
 {2}
 $$
 In aggiunta, sarà necessaria anche un [[broadcast problem|broadcast]] di terminazione, che richiederà:
 $$
 \color{SkyBlue} Entities
 $$
 Per un totale di:
 $$
 {
 \color{LightCoral}
 \frac
 {Entities \cdot (Entities + 1)}
 {2}
 }
 +
 {
 \color{SkyBlue} Entities
 }
 $$
 [[notazione asintotica|Asintoticamente]]:
 $$
 \Large O \left( Entities^2 \right)
@ -49,22 +72,42 @@ $$
 #### Caso migliore
-Il caso peggiore è quello in cui ==le [[entità]] sono [[iniziatori multipli|tutte iniziatrici]]== e in ordine decrescente di [[identificatore]].
+Il caso migliore è quello in cui le [[entità]] sono [[risveglio multiplo|tutte iniziatrici]] e in ordine decrescente di [[identificatore]].
-==Assumendo un [[ritardo di comunicazione unitario]]==, avremo che:
+Avremo che:
 1. il minimo sarà propagato per $Entities$ messaggi
 2. tutti gli altri per $1$ messaggio
 Totalizzando:
 $$
 \color{LightCoral}
 Entities
 +
 \sum_{Identifier=2}^{Entities} 1
 $$
 Ovvero:
 $$
-Entities + (Entities - 1)
+\color{LightCoral} Entities + (Entities - 1)
 $$
 In aggiunta, sarà necessaria anche un [[broadcast problem|broadcast]] di terminazione, che richiederà:
 $$
 \color{SkyBlue} Entities
 $$
 Per un totale di:
 $$
 {
 \color{LightCoral} Entities + (Entities - 1)
 }
 +
 {
 \color{SkyBlue} Entities
 }
 $$
 Ovvero:
 $$
 3 \cdot Entities - 1
 $$
 [[notazione asintotica|Asintoticamente]]:
 $$
--- a/controlled-distance.md
+++ b/controlled-distance.md
@ -5,8 +5,6 @@
 > [!Summary]
 > Effettua iterazioni in cui ogni [[entità]] che potrebbe diventare potenzialmente [[leader]] diffonde il proprio [[identificatore]] a tutte le altre entro una certa distanza.
 ## [[Comportamento]]
 ### `CANDIDATE`
 All'inizio di ogni iterazione, invia e fa inoltrare il proprio [[identificatore]] ai vicini (in entrambe le direzioni) a distanza $2^{Iteration}$.
@ -23,26 +21,46 @@ Sapendo sicuramente di non essere il leader, si limita a inoltrare messaggi.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | $O(Entities \cdot \log (Entities))$ |
 | [[tempo]] | ... |
 ### [[Comunicazione]]
-Ad ogni iterazione, ogni candidato invia e riceve su ogni lato:
+Il caso peggiore per le iterazioni sono le iterazioni intermedie (che non sono la prima o l'ultima o il broadcast di terminazione). ==Perchè?==
 Ad ogni iterazione intermedia, ogni candidato invia e riceve su ogni lato:
 $$
-\color{Gold} 2 ^ {Iteration}
+\color{Gold} 2 ^ {Iteration_1}
 $$
 Sommando andata e ritorno:
 $$
-{\color{Gold} 2} \cdot 2 ^ {Iteration}
+{\color{Gold} 2} \cdot 2 ^ {Iteration_1}
 $$
 Sommando i due lati:
 $$
-{\color{Gold} 2} \cdot 2 \cdot 2^{Iteration}
+{\color{Gold} 2} \cdot 2 \cdot 2^{Iteration_1}
 $$
-Sommando tutti i `CANDIDATE`:
+I `CANDIDATE` si dimezzano ad ogni iterazione; considerando le iterazioni [[indicizzazione a 1|indicizzate a 1]], sommandoli si ottiene che:
 $$
 {\color{Gold} \mathrm{floor} \left(
-\frac{n}{2^{Iteration - 1} + 1}
+\frac{Entities}{2^{Iteration_1 - 1} + 1}
 \right)}
-\cdot 2 \cdot 2 \cdot 2 ^ {Iteration}
+\cdot 2 \cdot 2 \cdot 2 ^ {Iteration_1}
 $$
 Pertanto, in [[notazione asintotica]] abbiamo:
 $$
 O(Entities \cdot Iteration)
 $$
-==Qui la prof fa dei calcoli. Ho troppo sonno per capirli.==
+Il numero di iterazioni è pari al [[logaritmo in base 2]] del numero di [[entità]] del [[sistema distribuito]]:
 $$
 \color{Gold} \mathrm{ceil} \left(
 	\log (Entities)
 \right)
 $$
 Quindi, la [[notazione asintotica]] finale sarà:
 $$
 \large O(Entities \cdot {\color{Gold} \log (Entities)})
 $$
--- a/election/leader
+++ b/election/leader
@ -1,19 +1,23 @@
-[[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]] ***introducendo una [[restrizione di topologia]] aggiuntiva.***
+[[algoritmo]] di [[leader election]] che risolve il problema di terminazione della [[leader election su anello all-the-way]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 - **[[restrizione di topologia|Topologia]]**
 	- [[anello]] di ***dimensione nota***
 ## [[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]]***.
 ## [[Comportamento]] aggiuntivo
 Si può effettuare il conteggio in due modi:
 - con un [[contatore]] su ogni [[entità]], che conta il numero di [[messaggio|messaggi]] transitati
- ==con un contatore su un messaggio==
+- con un [[contatore]] su ogni [[messaggio]], che conta il numero di [[entità]] transitate
 ## [[algoritmo corretto|Correttezza]]
-L'algoritmo termina quando tutte le [[entità]] hanno visto tanti [[messaggio|messaggi]] quante le [[entità]] del [[sistema distribuito]].
+> [!Success]
 > L'algoritmo termina quando tutte le [[entità]] hanno visto tanti [[messaggio|messaggi]] quante le [[entità]] del [[sistema distribuito]].
 ## [[costo computazionale distribuito|Costo computazionale]]
--- a/election/leader
+++ b/election/leader
@ -0,0 +1,54 @@
 [[algoritmo]] di [[fully synchronous leader election]] derivato dalla [[leader election su anello as-far-as-it-can]]
 ## [[Comportamento]]
 > [!Summary]
 > 
 > Ogni [[entità]] riceve identificatori dalla [[entità precedente in un anello|precedente]], tenendo traccia dell'identificatore minimo ricevuto, e inoltra alla [[entità successiva in un anello|successiva]] qualsiasi cambiamento ad esso, ***applicando però un ritardo dipendente dal valore dell'[[identificatore]]***.
 > 
 > Quando un'[[entità]] avrà ricevuto il suo stesso identificatore dalla [[entità precedente in un anello|precedente]], essa diventerà leader, e manderà un [[broadcast problem|broadcast]] di terminazione a tutte le altre.
 ==Spiegare come scegliere il tempo?==
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > È certo che l'identificatore minimo di tutto il [[sistema distribuito]] attraverserà tutte le [[entità]] in esso, fino a tornare al futuro [[leader]].
 > 
 > Avendo l'[[anello]] un numero finito di [[nodo di un grafo|nodi]] al suo interno, eventualmente sarà trovato un [[leader]], che a quel punto farà terminare l'esecuzione con il [[broadcast problem|broadcast]].
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | Dipende. |
 | [[tempo]] | Dipende. |
 ### [[Tempo]]
 L'[[identificatore]] minore compie un giro completo dell'[[anello]] dopo:
 $$
 \color{LightCoral} \mathrm{delay}(\min (Identifier)) \cdot Entities
 $$
 In più, il [[broadcast problem|broadcast]] di terminazione richiede:
 $$
 \color{SkyBlue} Entities
 $$
 Per un totale di:
 $$
 {
 \color{LightCoral} \mathrm{delay}(\min (Identifier)) \cdot Entities
 }
 +
 {
 \color{SkyBlue} Entities
 }
 $$
 La [[notazione asintotica]] risultante dipende dalla scelta effetuata di $\mathrm{delay}(Identifier)$.
 ### [[Comunicazione]]
 Anche il costo di comunicazione dipende dalla scelta effettuata di $\mathrm{delay}(Identifier)$, pertanto il calcolo è completamente omesso da questa pagina.
--- a/contemporaneo.md
+++ b/contemporaneo.md
@ -0,0 +1,66 @@
 [[algoritmo]] di [[fully synchronous leader election]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 - **[[restrizione di topologia|Topologia]]**
 	- [[anello]] di dimensione nota
 - **[[9 - Algoritmi distribuiti/1 - Problemi/tempo|Tempo]]**
 	- ***[[risveglio multiplo]]***
 ## [[Comportamento]]
 > [!Summary]
 > Ogni [[entità]] aspetta un tempo dipendente dal valore dell'identificatore, inviando il suo [[identificatore]] alla successiva al termine dell'attesa.
 > 
 > Quando una [[entità]] in attesa riceve l'identificatore di un'altra, la accetta come [[leader]] e termina.
 ==***Cambia come scegliere il tempo!***== $2 \cdot Entities \cdot Identifier$
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Prima o poi, un'[[entità]] terminerà la sua attesa, e farà circolare il suo [[messaggio]] di terminazione da tutte le altre.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | $O(Entities)$ |
 | [[tempo]] | Dipende. |
 ### [[Comunicazione]]
 Vengono inviati solamente:
 $$
 Entities
 $$
 Quindi, il costo computazionale è di:
 $$
 \Large O(Entities)
 $$
 ### [[Tempo]]
 L'[[identificatore]] minore deve terminare l'attesa per poter notificare della terminazione:
 $$
 \color{LightCoral} \mathrm{delay}(\min (Identifier))
 $$
 Poi, deve trascorrere sufficiente tempo per il [[broadcast problem|broadcast]] di terminazione:
 $$
 \color{SkyBlue} Entities
 $$
 Per un totale di:
 $$
 {
 \color{LightCoral} \mathrm{delay}(\min (Identifier))
 }
 +
 {
 \color{SkyBlue} Entities
 }
 $$
 La [[notazione asintotica]] risultante dipende dalla scelta effetuata di $\mathrm{delay}(Identifier)$.
--- a/election/leader
+++ b/election/leader
@ -0,0 +1,66 @@
 [[algoritmo]] di [[fully synchronous leader election]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 - **[[restrizione di topologia|Topologia]]**
 	- [[anello]] di dimensione nota
 - **[[9 - Algoritmi distribuiti/1 - Problemi/tempo|Tempo]]**
 	- [[risveglio ignorato]]
 ## [[Comportamento]]
 > [!Summary]
 > Ogni [[entità]] aspetta un tempo dipendente dal valore dell'identificatore, inviando il suo [[identificatore]] alla successiva al termine dell'attesa.
 > 
 > Quando una [[entità]] in attesa riceve l'identificatore di un'altra, la accetta come [[leader]] e termina.
 ==Spiegare come scegliere il tempo?==
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Prima o poi, un'[[entità]] terminerà la sua attesa, e farà circolare il suo [[messaggio]] di terminazione da tutte le altre.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | $O(Entities)$ |
 | [[tempo]] | Dipende. |
 ### [[Comunicazione]]
 Vengono inviati solamente:
 $$
 Entities
 $$
 Quindi, il costo computazionale è di:
 $$
 \Large O(Entities)
 $$
 ### [[Tempo]]
 L'[[identificatore]] minore deve terminare l'attesa per poter notificare della terminazione:
 $$
 \color{LightCoral} \mathrm{delay}(\min (Identifier))
 $$
 Poi, deve trascorrere sufficiente tempo per il [[broadcast problem|broadcast]] di terminazione:
 $$
 \color{SkyBlue} Entities
 $$
 Per un totale di:
 $$
 {
 \color{LightCoral} \mathrm{delay}(\min (Identifier))
 }
 +
 {
 \color{SkyBlue} Entities
 }
 $$
 La [[notazione asintotica]] risultante dipende dalla scelta effetuata di $\mathrm{delay}(Identifier)$.
--- a/election/leader
+++ b/election/leader
@ -5,6 +5,18 @@
 > [!Summary]
 > Usa la [[tecnica di saturazione per grafi aciclici]] per trovare l'entità con [[identificatore]] minore, che viene poi scelta come [[leader]].
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > L'unica parte non-[[algoritmo triviale|triviale]] di questo [[algoritmo]] è la [[tecnica di saturazione per grafi aciclici]], ed essendo corretta, rende anche questo [[algoritmo]] corretto.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione]] | $O(Entities)$ |
 | [[tempo]] | ... |
 ## [[Duale]]
 - [[shout+ protocol]]
--- a/election/leader
+++ b/election/leader
@ -7,6 +7,7 @@ Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritm
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
 - **[[restrizione di comunicazione|Comunicazione]]**
 	- [[dimensione dei messaggi illimitata]]
 	- [[half-duplex]]
 - **[[restrizione di affidabilità|Affidabilità]]**
 	- [[affidabilità totale]]
@ -15,8 +16,8 @@ Si vuole scegliere un'[[entità]] che diventerà il [[leader]] per un [[algoritm
 	- [[identificatori univoci]]
 		- il teorema [[Angluin 1980]] li pone come requisito per la risolvibilità
 - **[[restrizione di tempo|Tempo]]**
-	- [[ritardo di comunicazione unitario]]
+	- [[ritardo di comunicazione illimitato]]
-	- [[risveglio parziale]]
+	- [[risveglio multiplo]]
 	- [[terminazione locale]]
 ## [[algoritmo|Algoritmi]]
--- a/election.canvas
+++ b/election.canvas
@ -1,19 +1,24 @@
 {
 	"nodes":[
-		{"id":"18ea906d1635d485","type":"group","x":660,"y":900,"width":920,"height":3080,"color":"5","label":"Anello"},
+		{"id":"18ea906d1635d485","type":"group","x":660,"y":900,"width":920,"height":3080,"label":"Anello"},
-		{"id":"59e651b187da9388","type":"group","x":660,"y":4100,"width":920,"height":1000,"color":"5","label":"Grafo di diametro noto"},
+		{"id":"59e651b187da9388","type":"group","x":660,"y":4100,"width":920,"height":1000,"label":"Grafo di diametro noto"},
-		{"id":"740207a9a63c9513","type":"group","x":660,"y":340,"width":920,"height":440,"color":"5","label":"Grafo aciclico"},
+		{"id":"8c32c2275213ea05","type":"group","x":660,"y":5220,"width":440,"height":2040,"label":"Anello"},
-		{"id":"e7d0f7c50e744dfe","type":"group","x":660,"y":-260,"width":920,"height":440,"color":"5","label":"Albero"},
+		{"id":"740207a9a63c9513","type":"group","x":660,"y":340,"width":920,"height":440,"label":"Grafo aciclico"},
-		{"id":"26a2bda47738d7d8","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election.md","x":-440,"y":-240,"width":960,"height":5320},
+		{"id":"e7d0f7c50e744dfe","type":"group","x":660,"y":-260,"width":920,"height":440,"label":"Albero"},
 		{"id":"b672c8042ef8c199","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader.md","x":-160,"y":-800,"width":400,"height":400},
 		{"id":"c1f4d995f9345928","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su albero.md","x":680,"y":-240,"width":400,"height":400},
 		{"id":"5c61b7c7c5e2883d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello all-the-way.md","x":680,"y":920,"width":400,"height":960},
 		{"id":"855e7d4c6a36c000","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su grafo aciclico.md","x":680,"y":360,"width":400,"height":400},
-		{"id":"1c59488cd9ea817b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md","x":1160,"y":920,"width":400,"height":960},
+		{"id":"c1f4d995f9345928","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su albero.md","x":680,"y":-240,"width":400,"height":400},
 		{"id":"26a2bda47738d7d8","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election.md","x":-440,"y":-240,"width":960,"height":5320},
 		{"id":"9f58039648a89105","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/fully synchronous leader election.md","x":-440,"y":5240,"width":960,"height":960},
 		{"id":"57cedce16261c4ec","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/FloodMax.md","x":680,"y":4120,"width":400,"height":960},
 		{"id":"e419946480096acc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello speeding.md","x":680,"y":5240,"width":400,"height":960},
 		{"id":"a94c943350a80ff7","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/ritardo di comunicazione unitario.md","x":-1000,"y":5520,"width":400,"height":400},
 		{"id":"060624bd1d86f910","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md","x":680,"y":3000,"width":400,"height":960},
 		{"id":"bf49d10d32c845a4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello as-far-as-it-can.md","x":680,"y":1960,"width":400,"height":960},
 		{"id":"90c13d04acf28d97","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/Angluin 1980.md","x":-1000,"y":2220,"width":400,"height":400},
-		{"id":"060624bd1d86f910","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello controlled-distance.md","x":680,"y":3000,"width":400,"height":960},
+		{"id":"5c61b7c7c5e2883d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello all-the-way.md","x":680,"y":920,"width":400,"height":960},
-		{"id":"57cedce16261c4ec","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/FloodMax.md","x":680,"y":4120,"width":400,"height":960}
+		{"id":"1c59488cd9ea817b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello di dimensione conosciuta all-the-way.md","x":1160,"y":920,"width":400,"height":960},
 		{"id":"6bb989c83e5ff0aa","x":680,"y":6280,"width":400,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/5 - Leader election/leader election su anello waiting.md"}
 	],
 	"edges":[
 		{"id":"76ba628c35000191","fromNode":"b672c8042ef8c199","fromSide":"bottom","toNode":"26a2bda47738d7d8","toSide":"top"},
@ -23,6 +28,9 @@
 		{"id":"63b2664f9a3c7489","fromNode":"5c61b7c7c5e2883d","fromSide":"right","toNode":"1c59488cd9ea817b","toSide":"left"},
 		{"id":"3d8a52267df701d9","fromNode":"5c61b7c7c5e2883d","fromSide":"bottom","toNode":"bf49d10d32c845a4","toSide":"top"},
 		{"id":"34c21c398375393a","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"18ea906d1635d485","toSide":"left"},
-		{"id":"29ea3a738fc0be45","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"59e651b187da9388","toSide":"left"}
+		{"id":"29ea3a738fc0be45","fromNode":"26a2bda47738d7d8","fromSide":"right","toNode":"59e651b187da9388","toSide":"left"},
 		{"id":"ef87ea0f01bb48f4","fromNode":"26a2bda47738d7d8","fromSide":"bottom","toNode":"9f58039648a89105","toSide":"top"},
 		{"id":"2d815c735e9b4772","fromNode":"a94c943350a80ff7","fromSide":"right","toNode":"9f58039648a89105","toSide":"left"},
 		{"id":"78abf2a6f676f331","fromNode":"9f58039648a89105","fromSide":"right","toNode":"8c32c2275213ea05","toSide":"left"}
 	]
 }
--- a/Routing/centralized
+++ b/Routing/centralized
@ -0,0 +1,83 @@
 [[algoritmo]] di [[routing]] che sfrutta l'[[algoritmo di Dijkstra]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 - **[[restrizione di topologia|Topologia]]**
 	- [[canale di comunicazione|canali]] con [[funzione costo|costo]] ***non-negativo***
 ## [[Comportamento]]
 > [!Summary]
 > Fintanto che non sono rimasti [[router]] fuori dallo [[spanning tree]], ad ogni iterazione:
 > 1. il [[leader]] usa la [[tecnica di saturazione per alberi]] all'interno dello [[spanning tree]] costruito fino a quel momento per determinare il [[canale di comunicazione|canale]] di [[costo]] minimo;
 > 2. il [[leader]] aggiunge allo [[spanning tree]] quel [[canale di comunicazione|canale]] e il relativo [[router]], notificandolo della cosa attraverso la route conosciuta;
 > 3. il [[router]] aggiunto notifica i [[vicini di un'entità|vicini]] della sua aggiunta all'albero, aspettando che tutti i vicini confermino l'operazione;
 > 4. il [[router]] notifica il [[leader]] della aggiunta completata.
 > [!Tip]
 > Per ciascun [[router]], il genitore nell'albero diventa il [[default gateway]]!
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Deriva dalla [[algoritmo corretto|correttezza]] dell'[[algoritmo di Dijkstra]].
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione di routing]] | $O(Entities^2) |
 | [[tempo]] | ... |
 ### [[Comunicazione di routing]]
 #### Inizio
 Ciascuna [[entità]] scambia informazioni con i propri vicini:
 $$
 \color{LightCoral} 2 \cdot Channels
 $$
 #### Iterazione singola
 1. La [[tecnica di saturazione per alberi]] costa:
   $$4 \cdot Entities - 4$$
 2. L'*andata* della notifica di aggiunta costa:
   $$Entities$$
 3. La notifica ai [[vicini di un'entità|vicini]] costa:
   $$\mathrm{neighbours}(Entity)$$
 4. Il *ritorno* della notifica di aggiunta costa:
   $$Entities$$
 Sommando per tutte le iterazioni, abbiamo:
 $$
 \sum_{Entity}^{Entities}
 (4 \cdot Entities - 4)
 +
 (Entities)
 +
 (\mathrm{neighbours}(Entity))
 +
 (Entities)
 $$
 Considerando che i [[vicini di un'entità|vicini]] di una [[entità]] non possono essere più dei [[router]] totali:
 $$
 \sum_{Entity}^{Entities}
 (4 \cdot Entities - 4)
 +
 (Entities)
 +
 (Entities)
 +
 (Entities)
 $$
 #### Totale
 In totale, dunque, avremo una [[notazione asintotica]] di:
 $$
 O(Entities^2)
 $$
 ==C'è una dimostrazione diversa sulle slides, che non ho troppo capito perchè è tutta in notazione matematica.==
--- a/Routing/comunicazione
+++ b/Routing/comunicazione
@ -0,0 +1,2 @@
 > [!Warning]
 > Per qualche motivo a me sconosciuto, nel calcolare il [[costo computazionale]] di [[comunicazione]] in [[routing]] viene usata una misura diversa, ibrida tra [[comunicazione]] e [[9 - Algoritmi distribuiti/1 - Problemi/spazio|spazio]], che considera **un [[messaggio]] ogni coppia chiave-valore della [[routing table]] scambiata***.
--- a/Routing/funzione
+++ b/Routing/funzione
@ -2,13 +2,15 @@
 aliases:
  - routing function
 ---
-[[Funzione]] [[individuale]] che, in un problema di [[routing]], associa ogni [[entità]] con il [[canale di comunicazione]] da utilizzare per raggiungerla.
+[[Funzione]] [[individuale|specifica ogni singola entità]] che, associa ogni [[entità]] con il [[canale di comunicazione]] da utilizzare per raggiungerla.
 $$
-\def \varSource {{\color{LimeGreen} Source}}
+\def \varEntity {{\color{LimeGreen} Entity}}
 \def \varDestination {{\color{IndianRed} Destination}}
 \def \varChannel {{\color{SkyBlue} Channel}}
 \Large
-\textrm{Channel}_{\varSource}(\varDestination)
+\textrm{Route}_{\varEntity}(\varDestination) \to \varChannel
 $$
-Comunemente implementata come [[routing table]].
+> [!Example]
 > Comunemente implementata con una [[routing table]]!
--- a/Routing/gossiping
+++ b/Routing/gossiping
@ -0,0 +1,66 @@
 [[algoritmo]] di [[routing]].
 ## [[Comportamento]]
 > [!Summary]
 > I [[router]] recuperano informazioni sul loro [[vicinato]].
 >
 > Si costruisce uno [[spanning tree]] non ottimizzato e lo si usa per permettere ai [[router]] di scambiarsi le informazioni raccolte.
 > 
 > Ricevute le informazioni, ogni entità computa uno [[spanning tree]] ottimizzato, e ci deriva la [[routing table]].
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Eventualmente, il [[broadcast problem su grafo aciclico|broadcast]] termina, dando a tutti i [[router]] le informazioni necessarie per calcolare la loro [[routing table]].
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione del routing]] | $O(Entities \cdot Channels)$ |
 | [[tempo]] | ... |
 ### [[comunicazione del routing]]
 Recuperare informazioni sul [[vicini di un'entità|vicinato]] richiede un'andata-e-ritorno attraverso ogni [[canale di comunicazione|canale]]:
 $$
 \color{LightCoral} 2 \cdot Channels
 $$
 Creare lo [[spanning tree]] iniziale con [[shout+ protocol]] richiede:
 $$
 \color{SpringGreen} 2 \cdot Channels
 $$
 Infine, inviare il [[broadcast problem su grafo aciclico|broadcast]] richiede:
 $$
 \sum_{Entity}^{Entities} (Entities - 1) \cdot \mathrm{neighbours}(Entity)
 $$
 Ovvero:
 $$
 \color{SkyBlue} (Entities - 1) \cdot (2 \cdot Channels)
 $$
 Per un totale di:
 $$
 {\color{LightCoral} 2 \cdot Channels}
 +
 {\color{SpringGreen} 2 \cdot Channels}
 +
 {\color{SkyBlue} (Entities - 1) \cdot (2 \cdot Channels)}
 $$
 Ovvero:
 $$
 (Entities + 3) \cdot (2 \cdot Channels)
 $$
 In [[notazione asintotica]]:
 $$
 \Large O(Entities \cdot Channels)
 $$
 ### [[routing memory]]
 > [!Note]
 > Ogni [[entità]] si deve salvare le informazioni per *tutta* la [[rete di comunicazione]]!
--- a/Routing/iterating
+++ b/Routing/iterating
@ -0,0 +1,57 @@
 [[algoritmo]] di [[routing]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 - **[[restrizione di topologia|Topologia]]**
 	- [[diametro di un grafo|diametro]] noto
 ## [[Comportamento]]
 > [!Summary]
 > Ogni [[router]] crea una [[routing table]] con solo i suoi vicini.
 > 
 > Ad ogni iterazione, la invia a tutti i suoi [[vicini di un'entità|vicini]], e riceve contemporaneamente le loro, con cui aggiorna la propria.
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Dopo tante iterazioni quante il [[diametro di un grafo|diametro]] della [[rete di comunicazione]], tutti i [[router]] avranno aggregato le routing table di tutti gli altri, terminando cosí l'algoritmo.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione del routing]] | $O(Entities \cdot Channels)$ |
 | [[tempo]] | ... |
 ### [[Comunicazione]]
 Ogni [[router]] scambia informazioni con i suoi [[vicini di un'entità|vicini]]:
 $$
 \color{LightCoral} 2 \cdot Entities
 $$
 Ad ogni iterazione, ogni [[router]] invia la sua [[routing table]] ai suoi [[vicini di un'entità|vicini]]:
 $$
 \sum_{Entity}^{Entities} \sum_{RoutingEntry}^{RoutingEntries} \mathrm{neighbours}(Entity)
 $$
 Cioè:
 $$
 Entities \cdot 2 \cdot Channels
 $$
 Riscritto meglio:
 $$
 \color{SpringGreen} 2 \cdot Entities \cdot Channels
 $$
 In totale:
 $$
 {\color{LightCoral} 2 \cdot Entities}
 +
 {\color{SpringGreen} 2 \cdot Entities \cdot Channels}
 $$
 In [[notazione asintotica]]:
 $$
 \Large O(Entities \cdot Channels)
 $$
--- a/Routing/min-hop
+++ b/Routing/min-hop
@ -1,92 +0,0 @@
 [[algoritmo]] [[iterativo]] di [[routing]] che sfrutta la visita [[breadth-first]].
 ## Funzionamento
 ### Distanze a relazione
 Consideriamo due [[entità]] vicine nel [[sistema distribuito]]:
 $$
 \def \varSource {{\color{LimeGreen} Source}}
 \def \varA {{\color{DarkGoldenrod} Entity_A}}
 \def \varB {{\color{Goldenrod} Entity_B}}
 \Large
 \varA\ \textrm{neighbours}\ \varB
 $$
 Misuriamo la [[distanza]] di $\varA$ dalla sorgente $\varSource$:
 $$
 \Large
 \textrm{Distance}_{\varSource}(\varA)
 $$
 Confrontiamola con la [[distanza]] di $\varB$, notando che ci si può trovare in tre casi:
 $$
 \Large
 \textrm{Distance}_{\varSource}(\varA) = \begin{cases}
 \textrm{Distance}_{\varSource}(\varB)-1\\
 \textrm{Distance}_{\varSource}(\varB)\\
 \textrm{Distance}_{\varSource}(\varB)+1
 \end{cases}
 $$
 ### Albero parziale
 Definiamo un *albero parziale*, che ad ogni iterazione conterrà i nodi a distanza $Iterazione - 1$, e poi esploriamo i nodi vicini fino a raggiungere i nodi a distanza $Iterazione$.
 ## [[stato di un'entità|Stati]]
 - `SOURCE`: il [[leader]]
 - `UNKNOWN`: una [[entità]] non parte dell'albero parziale
 - `EXPLORED`: una [[entità]] parte dell'albero parziale
 ## [[Comportamento]]
 ### `SOURCE`
 ==...==
 ### `UNKNOWN`
 ==...==
 ### `EXPLORED`
 ==...==
 ## [[costo computazionale distribuito|Costo computazionale]]
 Ogni iterazione dell'algoritmo è divisa in tre fasi:
 - broadcast
 - explore
 - convergecast
 Definiamo il numero di nodi all'inizio di ogni iterazione come $\def \varNi {{\color{salmon} Nodes_{Iteration}}} \varNi$.
 Definiamo l'iterazione attuale come $\def \varIter {{\color{Blue} Iteration_{Current}}} \varIter$.
 ### [[Comunicazione]]
 ==...==
 ### [[Spazio]]
 ==...==
 ### [[Tempo]]
 Per ogni iterazione, abbiamo che:
 | Fase | Costo |
 |--|--|
 | broadcast | $\varIter - 1$ |
 | explore | $2$ |
 | convergecast | $\varIter - 1$ |
 In totale, avremo allora che il costo di tempo per una certa iterazione sarà:
 $$
 (\varIter - 1) + 2 + (\varIter - 1) = 2 \cdot \varIter
 $$
 Allora, il costo per l'intero algoritmo sarà:
 ==quale?==
 $$
 $$
--- a/Routing/min-hops
+++ b/Routing/min-hops
@ -0,0 +1,79 @@
 [[algoritmo]] di [[routing]] che sfrutta la [[breadth-first search]].
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
 - **[[restrizione di topologia|Topologia]]**
 	- [[canale di comunicazione|canali]] a [[costo]] ***unitario***
 ## [[Comportamento]]
 > [!Summary]
 > Ad ogni iterazione:
 > 1. il [[leader]] invia un [[broadcast]];
 > 2. le [[foglia di un albero|foglie]] che lo ricevono chiedono ai loro [[vicini di un'entità|vicini]] se sono già nell'albero;
 > 3. i [[vicini di un'entità|vicini]] che rispondono di no oppure con un altra domanda diventano le nuove [[foglia di un albero|foglie]], notificando il loro nuovo genitore della cosa;
 > 4. ogni [[router]] attende che tutti i suoi figli abbiano completato l'operazione, poi notifica il genitore, fino ad arrivare alla radice.
 ## [[algoritmo corretto|Correttezza]]
 > [!Success]
 > Essendo tutti i [[router]] a distanza finita dal [[leader]], eventualmente saranno aggiunti tutti allo [[spanning tree]], terminando cosí l'algoritmo.
 ## [[costo computazionale distribuito|Costo computazionale]]
 | Costo | [[notazione O-grande]] | 
 |-|-|
 | [[comunicazione di routing]] | $O(Entities^2 + Channels)$ |
 | [[tempo]] | ... |
 ### [[Comunicazione di routing]]
 #### Singola iterazione
 1. Il [[broadcast problem|broadcast]] iniziale costa, nel caso peggiore:
   $$Entities$$
 2. L'esplorazione costa, nel caso peggiore:
   $$\mathrm{neighbours}(Entity)$$
 3. Le risposte all'esplorazione costano, nel caso peggiore:
   $$\mathrm{neighbours}(Entity)$$
 4. Il [[messaggio]] di termine iterazione costa, nel caso peggiore:
   $$Entities$$
 Per un totale di:
 $$
 (Entities)
 +
 (\mathrm{neighbours}(Entity))
 +
 (\mathrm{neighbours}(Entity))
 +
 (Entities)
 $$
 Ovvero:
 $$
 2 \cdot Entities + 2 \cdot \mathrm{neighbours}(Entity)
 $$
 #### Totale
 Il numero totale di iterazione dipende dal [[diametro di un grafo|diametro]] della [[rete di comunicazione]], cioè:
 $$
 \sum_{Iteration}^{\mathrm{diameter}} (2 \cdot Entities + 2 \cdot \mathrm{neighbours}(Entity))
 $$
 Visto che ogni [[canale di comunicazione|canale]] avrà esattamente una *andata-e-ritorno* di esplorazione, possiamo portarlo fuori dalla sommatoria, sostituendolo con $2 \cdot Channels$:
 $$
 4 \cdot Channels + \sum_{Iteration}^{\mathrm{diameter}} (2 \cdot Entities)
 $$
 Nel caso peggiore, il [[diametro di un grafo]] è pari al numero totale di [[router]], quindi:
 $$
 4 \cdot Channels + 2 Entities^2
 $$
 In [[notazione asintotica]]:
 $$
 \Large O(Entities^2 + Channels)
 $$
--- a/Routing/pacchetto.md
+++ b/Routing/pacchetto.md
@ -0,0 +1 @@
 In un problema di [[routing]], [[messaggio]] contenente l'[[identificatore]] del [[router]] a cui è destinato.
--- a/Routing/principio
+++ b/Routing/principio
@ -0,0 +1,3 @@
 [[Corollario]] derivante dalla costruzione di uno [[spanning tree]].
 Se un [[nodo di un grafo|nodo]] si trova tra altri due all'interno dello [[spanning tree]], allora tutti gli [[arco di un grafo|archi]] che connettono i due si trovano nello [[spanning tree]] del nodo.
--- a/Routing/routing
+++ b/Routing/routing
@ -1,4 +1,4 @@
-In un contesto di [[routing]], [[associazione]] tra [[entità]] da raggiungere e [[canale di comunicazione]] da utilizzare più [[costo]] totale per raggiungerla.
+In un contesto di [[routing]], [[hash table|mappa]] da [[router]] destinatario a [[canale di comunicazione]] da utilizzare più [[costo]] totale per raggiungerla.
 $$
 \def \varSource {{\color{LimeGreen} Source}}
@ -13,3 +13,22 @@ $$
 $$
 Implementazione semplice di [[funzione di routing]].
 > [!Note]
 > ==Il [[principio di ottimalità]] è il motivo per cui è sufficiente salvare solo il [[canale di comunicazione]]!==
 ## [[Costo computazionale]]
 ### [[Search time]]
 Un lookup nel [[hash table|dizionario]]:
 $$
 \Large O(\log(Entities))
 $$
 ### [[Routing memory]]
 Lo spazio usato dal [[hash table|dizionario]]:
 $$
 \Large O(Entities \cdot \log(\max(Identifier)))
 $$
--- a/Routing/routing.md
+++ b/Routing/routing.md
@ -1,28 +1,32 @@
 [[problema di ottimizzazione]] per un [[sistema distribuito]].
 ## Terminologia aggiuntiva
 Le [[entità]] che partecipano al routing sono anche dette [[router]].
 ## Definizione
-Date due qualsiasi [[entità]], si vuole determinare un [[cammino]] nella [[rete di comunicazione]] che permetta alle due di comunicare persistentemente.
+Si vuole determinare una [[funzione di routing]] per tutti i [[router]] del sistema.
 ### Terminologia
 Le [[entità]] che partecipano alla risoluzione del problema sono dette anche [[router]].
 Ogni entità ha una [[funzione di routing]], archiviata nella [[routing memory]], che richiede un dato [[tempo di ricerca]] per essere eseguita.e mi 
 ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- [[full-duplex]]
+- **[[restrizione di comunicazione|Comunicazione]]**
- [[canale di comunicazione|canali di comunicazione]] con un [[costo]]
+	- [[dimensione dei messaggi illimitata]]
- ==connettività?==
+	- [[full-duplex]]
- [[affidabilità totale]]
+- **[[restrizione di affidabilità|Affidabilità]]**
- [[orientamento locale]]
+	- [[affidabilità totale]]
- [[identificatori univoci]]
+- **[[restrizione di topologia|Topologia]]**
 	- [[grafo connesso]]
 	- [[identificatori univoci]]
 	- [[canale di comunicazione|canali]] con un [[funzione costo|costo]]
 - **[[restrizione di tempo|Tempo]]**
 	- [[ritardo di comunicazione illimitato]]
 	- [[risveglio singolo]]
 	- [[terminazione locale]]
 ## [[algoritmo|Algoritmi]]
- [[broadcast routing]]
+- [[gossiping routing]]
- [[routing table gossiping]]
+- [[iterating routing]]
- [[routing table iterating]]
+- [[centralized routing]]
- [[shortest path spanning tree]]
+- [[min-hops routing]]
 - [[min-hop routing]]
--- a/Routing/search
+++ b/Routing/search
@ -0,0 +1,3 @@
 [[risorsa]].
 [[Tempo]] necessario a eseguire la [[funzione di routing]].
--- a/Routing/tempo
+++ b/Routing/tempo
@ -1,3 +0,0 @@
 [[Risorsa]].
 [[Tempo]] necessario a valutare la [[funzione di routing]].
--- a/routing.canvas
+++ b/routing.canvas
@ -1,4 +1,34 @@
 {
-	"nodes":[],
+	"nodes":[
-	"edges":[]
+		{"id":"1b02df69b1abf291","type":"group","x":2060,"y":-1100,"width":1560,"height":1560,"label":"Concetti"},
 		{"id":"bb569fef44f295e1","x":2060,"y":580,"width":440,"height":1000,"type":"group","label":"Generale"},
 		{"id":"68acbd213e07eb80","x":2060,"y":1700,"width":440,"height":1000,"type":"group","label":"Diametro noto"},
 		{"id":"dfe1179e8607aab5","x":2060,"y":2820,"width":440,"height":1000,"type":"group","label":"Costo non-negativo"},
 		{"id":"a2f4ec1d9ef4fca5","x":2060,"y":3940,"width":440,"height":1000,"type":"group","label":"Costo unitario"},
 		{"id":"d89867fdda35cdde","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/routing.md","x":960,"y":-800,"width":960,"height":5720},
 		{"id":"8bf228c354e56f9e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/funzione di routing.md","x":2080,"y":-520,"width":400,"height":400},
 		{"id":"977d445b9efd3c63","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/routing memory.md","x":2640,"y":-800,"width":400,"height":400},
 		{"id":"c9ae37a9e586a72d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/search time.md","x":2640,"y":-240,"width":400,"height":400},
 		{"id":"cb0fa8b1f3b67bdd","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/pacchetto.md","x":2080,"y":40,"width":400,"height":400},
 		{"id":"a5fe4cabc58e4ded","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/router.md","x":2080,"y":-1080,"width":400,"height":400},
 		{"id":"781c1e8e5acea10a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/routing table.md","x":3200,"y":-800,"width":400,"height":960},
 		{"id":"bb4745ef27a83d75","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/gossiping routing.md","x":2080,"y":600,"width":400,"height":960},
 		{"id":"aad122a35d265477","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/iterating routing.md","x":2080,"y":1720,"width":400,"height":960},
 		{"id":"a64242492150bbbd","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/centralized routing.md","x":2080,"y":2840,"width":400,"height":960},
 		{"id":"5602d9da9f18a97d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/min-hops routing.md","x":2080,"y":3960,"width":400,"height":960},
 		{"id":"ea475183f7c55a25","x":1240,"y":-1360,"width":400,"height":400,"color":"3","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/6 - Routing/comunicazione del routing.md"}
 	],
 	"edges":[
 		{"id":"58a76a4228ed6e62","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"8bf228c354e56f9e","toSide":"left"},
 		{"id":"a9ded24e83178bcd","fromNode":"8bf228c354e56f9e","fromSide":"right","toNode":"977d445b9efd3c63","toSide":"left"},
 		{"id":"cdab59da9351844e","fromNode":"8bf228c354e56f9e","fromSide":"right","toNode":"c9ae37a9e586a72d","toSide":"left"},
 		{"id":"ba114b8d66b34d81","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"a5fe4cabc58e4ded","toSide":"left"},
 		{"id":"820e0566dd3893d7","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"cb0fa8b1f3b67bdd","toSide":"left"},
 		{"id":"951773f2dfb01c66","fromNode":"8bf228c354e56f9e","fromSide":"right","toNode":"781c1e8e5acea10a","toSide":"left"},
 		{"id":"618c83092da33be8","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"bb4745ef27a83d75","toSide":"left"},
 		{"id":"de8236f4437be009","fromNode":"d89867fdda35cdde","fromSide":"top","toNode":"ea475183f7c55a25","toSide":"bottom"},
 		{"id":"5f2d6351f5f2f313","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"68acbd213e07eb80","toSide":"left"},
 		{"id":"21d6efdf44e535fc","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"dfe1179e8607aab5","toSide":"left"},
 		{"id":"a86bf78728816781","fromNode":"d89867fdda35cdde","fromSide":"right","toNode":"a2f4ec1d9ef4fca5","toSide":"left"}
 	]
 }
--- a/Guasti/consenso
+++ b/Guasti/consenso
@ -0,0 +1,12 @@
 ==Ovviamente TODO, questo è un glossario per le notazioni.==
 - $n$ 
 	- numero delle entità
 - $f$ 
 	- massimo delle entità che possono fallire, sempre minore di $\frac{f}{9}$ per qualche motivo
 - $n - f$ 
 	- il numero di vicini di un nodo che non possono avere un guasto 
 - $n - 2f$ 
 	- il numero di vicini in comune tra due nodi che non possono avere un guasto
 - $n - 4f$ 
 	- il numero di vicini in comune tra due nodi che hanno sicuramente mandato lo stesso messaggio ==credo==
--- a/distribuite/distributed
+++ b/distribuite/distributed
@ -0,0 +1,3 @@
 [[struttura dati distribuita]] basata su una [[hash table]].
 L'[[hash]] della [[chiave]] viene usato per determinare quale [[entità]] ha controllo su di essa.
--- a/distribuite/struttura
+++ b/distribuite/struttura
@ -0,0 +1 @@
 [[struttura dati distribuita]] di dimensione variabile.
--- a/distribuite/struttura
+++ b/distribuite/struttura
@ -0,0 +1 @@
 [[struttura dati]] gestita da [[entità]].
--- a/steffo-file-index.json
+++ b/steffo-file-index.json
		`@ -0,0 +1,3 @@`
							`[[restrizione di comunicazione]].`

							`Specifica che i [[messaggio\|messaggi]] possono occupare qualsiasi [[9 - Algoritmi distribuiti/1 - Problemi/spazio\|spazio]] sia necessario.`
		`@ -0,0 +1,2 @@`
							`> [!Warning]`
							`> Per qualche motivo a me sconosciuto, nel calcolare il [[costo computazionale]] di [[comunicazione]] in [[routing]] viene usata una misura diversa, ibrida tra [[comunicazione]] e [[9 - Algoritmi distribuiti/1 - Problemi/spazio\|spazio]], che considera un [[messaggio]] ogni coppia chiave-valore della [[routing table]] scambiata*.`
		`@ -0,0 +1 @@`
							`In un problema di [[routing]], [[messaggio]] contenente l'[[identificatore]] del [[router]] a cui è destinato.`
		`@ -0,0 +1,3 @@`
							`[[Corollario]] derivante dalla costruzione di uno [[spanning tree]].`

							`Se un [[nodo di un grafo\|nodo]] si trova tra altri due all'interno dello [[spanning tree]], allora tutti gli [[arco di un grafo\|archi]] che connettono i due si trovano nello [[spanning tree]] del nodo.`
		`@ -0,0 +1,3 @@`
							`[[risorsa]].`

							`[[Tempo]] necessario a eseguire la [[funzione di routing]].`
		`@ -1,3 +0,0 @@`
			`[[Risorsa]].`

			`[[Tempo]] necessario a valutare la [[funzione di routing]].`
		`@ -0,0 +1,3 @@`
							`[[struttura dati distribuita]] basata su una [[hash table]].`

							`L'[[hash]] della [[chiave]] viene usato per determinare quale [[entità]] ha controllo su di essa.`
		`@ -0,0 +1 @@`
							`[[struttura dati distribuita]] di dimensione variabile.`