unimore/appunti-steffo
unimore/appunti-steffo
1
Fork 0
mirror of https://github.com/Steffo99/appunti-magistrali.git synced 2024-11-22 02:44:17 +00:00
Code Activity

Update various things

Browse source
This commit is contained in:
Steffo 2023-11-17 15:23:05 +01:00
parent fe6b559a7d
commit fd32f541c9
Signed by: steffo
GPG key ID: 2A24051445686895
50 changed files with 1301 additions and 666 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.obsidian/community-plugins.json vendored
View file

@ -1,4 +1,5 @@
[ [
"obsidian-file-color", "obsidian-file-color",
"steffo-file-index" "steffo-file-index",
"file-index"
] ]

2
.obsidian/graph.json vendored
View file

@ -17,6 +17,6 @@
"repelStrength": 10, "repelStrength": 10,
"linkStrength": 1, "linkStrength": 1,
"linkDistance": 250, "linkDistance": 250,
"scale": 0.008325802584174924, "scale": 0.14225414259055125,
"close": false "close": false
} }

47
.obsidian/plugins/steffo-file-index/main.js → .obsidian/plugins/file-index/main.js vendored
View file

@ -37,12 +37,12 @@ var __privateAdd = (obj, member, value) => {
// main.ts // main.ts
var main_exports = {}; var main_exports = {};
__export(main_exports, { __export(main_exports, {
default: () => SteffoFileIndexPlugin default: () => FileIndexPlugin
}); });
module.exports = __toCommonJS(main_exports); module.exports = __toCommonJS(main_exports);
var import_obsidian = require("obsidian"); var import_obsidian = require("obsidian");
var _reloadIgnoreRegExpsIfIgnoreFileChangedBinding, _recreateFileIndexBinding; var _reloadIgnoreRegExpsIfIgnoreFileChangedBinding, _recreateFileIndexBinding;
var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin { var _FileIndexPlugin = class extends import_obsidian.Plugin {
constructor() { constructor() {
super(...arguments); super(...arguments);
this.ignoreRegExps = []; this.ignoreRegExps = [];
@ -50,24 +50,24 @@ var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
__privateAdd(this, _recreateFileIndexBinding, this.recreateFileIndex.bind(this)); __privateAdd(this, _recreateFileIndexBinding, this.recreateFileIndex.bind(this));
} }
async reloadIgnoreRegExps() { async reloadIgnoreRegExps() {
const ignoreFile = this.app.vault.getAbstractFileByPath(_SteffoFileIndexPlugin.FILE_IGNORE_PATH); const ignoreFile = this.app.vault.getAbstractFileByPath(_FileIndexPlugin.FILE_IGNORE_PATH);
if (ignoreFile === null) { if (ignoreFile === null) {
console.debug("[SteffoFileIndexPlugin] Ignore file does not exist, not ignoring anything:", _SteffoFileIndexPlugin.FILE_IGNORE_PATH); console.debug("[FileIndexPlugin] Ignore file does not exist, not ignoring anything:", _FileIndexPlugin.FILE_IGNORE_PATH);
this.ignoreRegExps = []; this.ignoreRegExps = [];
} else if (ignoreFile instanceof import_obsidian.TFolder) { } else if (ignoreFile instanceof import_obsidian.TFolder) {
console.debug("[SteffoFileIndexPlugin] Ignore file is actually a folder, not ignoring anything:", _SteffoFileIndexPlugin.FILE_IGNORE_PATH); console.debug("[FileIndexPlugin] Ignore file is actually a folder, not ignoring anything:", _FileIndexPlugin.FILE_IGNORE_PATH);
this.ignoreRegExps = []; this.ignoreRegExps = [];
} else if (ignoreFile instanceof import_obsidian.TFile) { } else if (ignoreFile instanceof import_obsidian.TFile) {
const ignoreJSON = await this.app.vault.cachedRead(ignoreFile); const ignoreJSON = await this.app.vault.cachedRead(ignoreFile);
const ignoreContents = JSON.parse(ignoreJSON); const ignoreContents = JSON.parse(ignoreJSON);
this.ignoreRegExps = ignoreContents.map((re) => new RegExp(re)); this.ignoreRegExps = ignoreContents.map((re) => new RegExp(re));
console.debug("[SteffoFileIndexPlugin] Determined ignore list to be:", this.ignoreRegExps); console.debug("[FileIndexPlugin] Determined ignore list to be:", this.ignoreRegExps);
} else { } else {
console.error("[SteffoFileIndexPlugin] Ignore file is of an unknown type, not doing anything:", _SteffoFileIndexPlugin.FILE_IGNORE_PATH); console.error("[FileIndexPlugin] Ignore file is of an unknown type, not doing anything:", _FileIndexPlugin.FILE_IGNORE_PATH);
} }
} }
async reloadIgnoreRegExpsIfIgnoreFileChanged(file) { async reloadIgnoreRegExpsIfIgnoreFileChanged(file) {
if (file.path === _SteffoFileIndexPlugin.FILE_IGNORE_PATH) { if (file.path === _FileIndexPlugin.FILE_IGNORE_PATH) {
await this.reloadIgnoreRegExps(); await this.reloadIgnoreRegExps();
} }
} }
@ -87,32 +87,37 @@ var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
continue; continue;
} }
paths.push(file.path); paths.push(file.path);
const basename = file.basename.toLocaleLowerCase(); let basename;
if (file.extension === "md") {
basename = file.basename.toLocaleLowerCase();
} else {
basename = file.basename.toLocaleLowerCase() + "." + file.extension.toLocaleLowerCase();
}
if (basenames.hasOwnProperty(basename)) { if (basenames.hasOwnProperty(basename)) {
console.warn("[SteffoFileIndexPlugin] Multiple files with the same basename detected:", basenames[basename], file.path); console.warn("[FileIndexPlugin] Multiple files with the same basename detected:", basenames[basename], file.path);
} }
basenames[basename] = file.path; basenames[basename] = file.path;
} }
paths.sort(); paths.sort();
const index = { basenames, paths }; const index = { basenames, paths };
console.debug("[SteffoFileIndexPlugin] Determined index to be:", index); console.debug("[FileIndexPlugin] Determined index to be:", index);
const indexContents = JSON.stringify(index, null, " "); const indexContents = JSON.stringify(index, null, " ");
const indexFile = this.app.vault.getAbstractFileByPath(_SteffoFileIndexPlugin.FILE_INDEX_PATH); const indexFile = this.app.vault.getAbstractFileByPath(_FileIndexPlugin.FILE_INDEX_PATH);
if (indexFile === null) { if (indexFile === null) {
console.debug("[SteffoFileIndexPlugin] File index does not exist, creating it right now at:", _SteffoFileIndexPlugin.FILE_INDEX_PATH); console.debug("[FileIndexPlugin] File index does not exist, creating it right now at:", _FileIndexPlugin.FILE_INDEX_PATH);
await this.app.vault.create(_SteffoFileIndexPlugin.FILE_INDEX_PATH, indexContents); await this.app.vault.create(_FileIndexPlugin.FILE_INDEX_PATH, indexContents);
} else if (indexFile instanceof import_obsidian.TFolder) { } else if (indexFile instanceof import_obsidian.TFolder) {
console.debug("[SteffoFileIndexPlugin] Cannot create file index, as there's a folder at:", _SteffoFileIndexPlugin.FILE_INDEX_PATH); console.debug("[FileIndexPlugin] Cannot create file index, as there's a folder at:", _FileIndexPlugin.FILE_INDEX_PATH);
} else if (indexFile instanceof import_obsidian.TFile) { } else if (indexFile instanceof import_obsidian.TFile) {
console.debug("[SteffoFileIndexPlugin] File index already exists, overwriting contents of:", _SteffoFileIndexPlugin.FILE_INDEX_PATH); console.debug("[FileIndexPlugin] File index already exists, overwriting contents of:", _FileIndexPlugin.FILE_INDEX_PATH);
await this.app.vault.modify(indexFile, indexContents); await this.app.vault.modify(indexFile, indexContents);
} else { } else {
console.error("[SteffoFileIndexPlugin] File index is of an unknown type, not doing anything:", _SteffoFileIndexPlugin.FILE_INDEX_PATH); console.error("[FileIndexPlugin] File index is of an unknown type, not doing anything:", _FileIndexPlugin.FILE_INDEX_PATH);
} }
} }
async onload() { async onload() {
this.addCommand({ this.addCommand({
id: "steffo-file-index-recreate", id: "recreate",
name: "Force file index recreation", name: "Force file index recreation",
callback: this.recreateFileIndex.bind(this) callback: this.recreateFileIndex.bind(this)
}); });
@ -142,8 +147,8 @@ var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
onunload() { onunload() {
} }
}; };
var SteffoFileIndexPlugin = _SteffoFileIndexPlugin; var FileIndexPlugin = _FileIndexPlugin;
_reloadIgnoreRegExpsIfIgnoreFileChangedBinding = new WeakMap(); _reloadIgnoreRegExpsIfIgnoreFileChangedBinding = new WeakMap();
_recreateFileIndexBinding = new WeakMap(); _recreateFileIndexBinding = new WeakMap();
SteffoFileIndexPlugin.FILE_IGNORE_PATH = "steffo-file-index-ignore.json"; FileIndexPlugin.FILE_IGNORE_PATH = "file-index-ignore.json";
SteffoFileIndexPlugin.FILE_INDEX_PATH = "steffo-file-index.json"; FileIndexPlugin.FILE_INDEX_PATH = "file-index.json";

4
.obsidian/plugins/steffo-file-index/manifest.json → .obsidian/plugins/file-index/manifest.json vendored
View file

@ -1,7 +1,7 @@
{ {
"id": "steffo-file-index", "id": "file-index",
"name": "File Index", "name": "File Index",
"version": "2.0.0", "version": "3.0.3",
"minAppVersion": "0.15.0", "minAppVersion": "0.15.0",
"description": "Create a metadata file about the files present in the Vault", "description": "Create a metadata file about the files present in the Vault",
"author": "Steffo", "author": "Steffo",

72
.obsidian/plugins/obsidian-file-color/data.json vendored
View file

@ -266,19 +266,7 @@
"color": "fc3lLaITDn62PYbzBhqxl" "color": "fc3lLaITDn62PYbzBhqxl"
}, },
{ {
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita", "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti di computazione distribuita.canvas",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "steffo-file-index.json",
"color": "me4XBNQC4rwzQFLlvIAn0"
},
{
"path": "steffo-file-index-ignore.json",
"color": "me4XBNQC4rwzQFLlvIAn0"
},
{
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas",
"color": "7j7Pqog0VHMVVAfazMNlb" "color": "7j7Pqog0VHMVVAfazMNlb"
}, },
{ {
@ -385,22 +373,6 @@
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti su grafo completo.md", "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso con fallimenti su grafo completo.md",
"color": "fc3lLaITDn62PYbzBhqxl" "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", "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/4 - Computazione/★ computazione.canvas",
"color": "7j7Pqog0VHMVVAfazMNlb" "color": "7j7Pqog0VHMVVAfazMNlb"
@ -418,7 +390,47 @@
"color": "7j7Pqog0VHMVVAfazMNlb" "color": "7j7Pqog0VHMVVAfazMNlb"
}, },
{ {
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso.md", "path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome di consenso sincrono deterministico.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/protocollo di Ben-Or Las Vegas.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/protocollo di Ben-Or Monte Carlo.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso sincrono deterministico bizantino.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/TellZero Byz.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome Las Vegas di consenso asincrono non-deterministico bizantino.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "0 - Template/◍ algoritmo di approssimazione.md",
"color": "me4XBNQC4rwzQFLlvIAn0"
},
{
"path": "9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/approssimazione del problema del commesso viaggiatore.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/proprietà triangolare per il costo degli archi.md",
"color": "fc3lLaITDn62PYbzBhqxl"
},
{
"path": "0 - Template/◍ problema algoritmico.md",
"color": "me4XBNQC4rwzQFLlvIAn0"
},
{
"path": "9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/algoritmo senza nome approssimato greedy di vertex cover.md",
"color": "fc3lLaITDn62PYbzBhqxl" "color": "fc3lLaITDn62PYbzBhqxl"
} }
] ]

8
.obsidian/plugins/steffo-file-index/styles.css vendored
View file

@ -1,8 +0,0 @@
/*
This CSS file will be included with your plugin, and
available in the app when your plugin is enabled.
If your plugin does not need CSS, delete this file.
*/

37
0 - Template/◍ algoritmo di approssimazione.md Normal file
View file

@ -0,0 +1,37 @@
[[algoritmo di approssimazione]] di ==[Problema]==.
## Funzionamento
> [!Summary]
> ==[In breve, come funziona l'algoritmo?]==
==[In cosa consiste l'algoritmo?]==
## [[algoritmo corretto|Correttezza]]
> [!Success]
> ==[Perchè l'algoritmo è corretto?]==
> [!Failure]
> ==[Perchè l'algoritmo non è corretto?]==
## [[fattore di approssimazione|Fattore di approssimazione]]
==[Qual è il fattore di approssimazione?]==
==[Come è stato determinato?]==
## [[Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[spazio]] | ==[O()]== |
| [[tempo]] | ==[O()]== |
### [[9 - Algoritmi distribuiti/1 - Problemi/spazio|Spazio]]
==[Dimostrazione del costo di spazio]==
### [[9 - Algoritmi distribuiti/1 - Problemi/tempo|Tempo]]
==[Dimostrazione del costo di tempo]==

28
0 - Template/◍ algoritmo distribuito.md
View file

@ -1,40 +1,42 @@
[[algoritmo]] di ==PROBLEMA==. [[algoritmo]] di ==[Problema]==.
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
==...== - **==[Categoria]==**
- ==[Restrizione]==
## [[Comportamento]] ## [[Comportamento]]
> [!Summary] > [!Summary]
> ==...== > ==[Riassunto]==
### ==`STATO1`== ### ==`[Stato1]`==
==...== ==[Descrizione stato 1]==
### ==`STATO2`== ### ==`[Stato2]`==
==...== ==[Descrizione stato 2]==
## [[algoritmo corretto|Correttezza]] ## [[algoritmo corretto|Correttezza]]
> [!Success] > [!Success]
> ==...== > ==[Perchè l'algoritmo è corretto?]==
> [!Failure] > [!Failure]
> ==...== > ==[Perchè l'algoritmo non è corretto?]==
## [[costo computazionale distribuito|Costo computazionale]] ## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] | | Costo | [[notazione O-grande]] |
|-|-| |-|-|
| [[comunicazione]] | ==...== | | [[comunicazione]] | ==[O()]== |
| [[tempo]] | ==...== | | [[tempo]] | ==[O()]== |
### [[Comunicazione]] ### [[Comunicazione]]
==...== ==[Dimostrazione del costo di comunicazione]==
### [[Tempo]] ### [[Tempo]]
==...== ==[Dimostrazione del costo di tempo]==

9
0 - Template/◍ problema algoritmico.md Normal file
View file

@ -0,0 +1,9 @@
Problema.
## Definizione
==[Definizione informale del problema]==
## [[algoritmo|Algoritmi]]
- ==[Algoritmo]==

13
0 - Template/◍ problema distribuito.md
View file

@ -2,20 +2,19 @@ Problema per un [[sistema distribuito]].
## Definizione ## Definizione
==...== ==[Definizione informale del problema]==
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] ## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]** - **[[restrizione di comunicazione|Comunicazione]]**
- ==...== - ==[Restrizione]==
- **[[restrizione di affidabilità|Affidabilità]]** - **[[restrizione di affidabilità|Affidabilità]]**
- ==...== - ==[Restrizione]==
- **[[restrizione di topologia|Topologia]]** - **[[restrizione di topologia|Topologia]]**
- ==...== - ==[Restrizione]==
- **[[restrizione di tempo|Tempo]]** - **[[restrizione di tempo|Tempo]]**
- ==...== - ==[Restrizione]==
## [[algoritmo|Algoritmi]] ## [[algoritmo|Algoritmi]]
- ==...== - ==[Algoritmo]==
- ==...==

4
9 - Algoritmi distribuiti/1 - Problemi/soluzione ottima.md
View file

@ -1 +1,5 @@
[[soluzione]] ad un [[problema di ottimizzazione]] in cui si cerca di trovare massimi e minimi di una [[funzione obiettivo]]. [[soluzione]] ad un [[problema di ottimizzazione]] in cui si cerca di trovare massimi e minimi di una [[funzione obiettivo]].
$$
\Huge Result_{Optimal}
$$

4
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/algoritmo di approssimazione.md
View file

@ -1 +1,3 @@
[[algoritmo]] [[polinomiale]] per un [[classe di problemi NP-difficili|problema NP-hard]] che vi trova una [[soluzione approssimata]] entro un certo [[fattore di approssimazione]]. [[algoritmo]] [[polinomiale]] per un [[classe di problemi NP-difficili|problema NP-hard]].
Trova una [[soluzione approssimata]] entro un certo [[fattore di approssimazione]].

46
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/algoritmo senza nome approssimato greedy di vertex cover.md Normal file
View file

@ -0,0 +1,46 @@
[[algoritmo di approssimazione]] di [[vertex cover]].
## Funzionamento
> [!Summary]
> Finchè ci sono [[arco di un grafo|archi]] nel [[grafo]]:
> 1. seleziona un [[arco di un grafo|arco]] qualsiasi
> 2. aggiungi i due [[nodo di un grafo|nodi]] che lo collegano al [[vertex cover]]
> 3. rimuovi dal [[grafo]] tutti gli [[arco di un grafo|archi]] adiacenti ai [[nodo di un grafo|nodi]] aggiunti
## [[algoritmo corretto|Correttezza]]
> [!Success]
> Dato che l'algoritmo termina solo quando tutti gli [[arco di un grafo|archi]] sono stati aggiunti, il risultato è sicuramente un [[vertex cover]].
>
> Si ha sicuramente terminazione, perchè ogni iterazione aggiunge almeno un [[arco di un grafo|arco]] al [[vertex cover]].
## [[fattore di approssimazione|Fattore di approssimazione]]
Il [[vertex cover]] [[soluzione ottima|ottimale]] ==something something metà dei nodi==
Il [[fattore di approssimazione]] è:
$$
\Huge 2
$$
## [[Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[spazio]] | ... |
| [[tempo]] | $O(Edges)$ |
### [[9 - Algoritmi distribuiti/1 - Problemi/tempo|Tempo]]
Nel caso peggiore, il numero di iterazioni effettuate è pari alla metà del numero degli [[arco di un grafo|archi]], cioè:
$$
\frac
{Edges}
{2}
$$
In [[notazione asintotica]]:
$$
\Large O(Edges)
$$

6
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/approssimazione del problema del commesso viaggiatore.md
View file

@ -1,6 +1,6 @@
[[algoritmo di approssimazione]] per il [[problema del commesso viaggiatore]]. [[algoritmo di approssimazione]] per il [[problema del commesso viaggiatore]].
Per questo problema, il [[fattore di approsimazione]] $\alpha$ può essere costante solo se [[P=NP]]. Per questo problema, il [[fattore di approssimazione]] $\alpha$ può essere costante solo se [[P=NP]].
> L'algoritmo di approssimazione a fattore costante è riducibile alla [[ricerca di ciclo hamiltoniano]]. > L'algoritmo di approssimazione a fattore costante è riducibile alla [[ricerca di ciclo hamiltoniano]].
@ -26,7 +26,7 @@ Si trova il [[ciclo hamiltoniano]] per $Tree$, usando *shortcut*:
- Si selezionano i nodi di $Euler$ mantenendoli nello stesso ordine, ma scartando quelli che vi appaiono due volte, e poi connettendo l'ultimo al primo. - Si selezionano i nodi di $Euler$ mantenendoli nello stesso ordine, ma scartando quelli che vi appaiono due volte, e poi connettendo l'ultimo al primo.
$Hamilton$ è la soluzione approssimata, con [[fattore di approsimazione]] $2$. $Hamilton$ è la soluzione approssimata, con [[fattore di approssimazione]] $2$.
### Dimostrazione ### Dimostrazione
@ -72,4 +72,4 @@ Si trova il [[ciclo hamiltoniano]] per $Tree$, usando *shortcut*:
- Si selezionano i nodi di $Euler$ mantenendoli nello stesso ordine, ma scartando quelli che vi appaiono due volte, e poi connettendo l'ultimo al primo. - Si selezionano i nodi di $Euler$ mantenendoli nello stesso ordine, ma scartando quelli che vi appaiono due volte, e poi connettendo l'ultimo al primo.
$Hamilton$ è la soluzione approssimata, con [[fattore di approsimazione]] $2$. $Hamilton$ è la soluzione approssimata, con [[fattore di approssimazione]] $2$.

10
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/fattore di approssimazione.md
View file

@ -1,15 +1,17 @@
[[Costante]]. [[Costante]] per un [[algoritmo di approssimazione]].
$$ $$
\Huge \Huge
\alpha \alpha
$$ $$
In un [[algoritmo di approssimazione]], indica di quanto può essere peggiore la [[soluzione approssimata]] restituita rispetto alla [[soluzione ottima]]. Indica di quanto può essere peggiore la [[soluzione approssimata]] restituita rispetto alla [[soluzione ottima]].
$$ $$
\Large \Large
cost(approx) \frac
{\mathrm{cost}(Result_{Approximated})}
{\mathrm{cost}(Result_{Optimal})}
\leq \leq
\alpha \cdot cost(opt) \alpha
$$ $$

11
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/schema di approssimazione interamente polinomiale.md Normal file
View file

@ -0,0 +1,11 @@
[[schema di approssimazione]] il cui [[costo computazionale]] è [[polinomiale]] sia considerando l'[[istanza]], sia considerando il [[fattore di approssimazione]].
> [!Example]
> Uno [[schema di approssimazione|schema]] il cui [[costo computazionale]] è:
> $$
> \Large
> O
> \left(
> \frac{n}{\epsilon}
> \right)
> $$

5
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/schema di approssimazione.md Normal file
View file

@ -0,0 +1,5 @@
[[algoritmo di approssimazione]] che prende in input non solo un'[[istanza]] ma anche il [[fattore di approssimazione]] desiderato.
## [[Costo computazionale]]
Per determinare il [[costo computazionale]] di uno schema di approssimazione, si considerano tutti i [[fattore di approssimazione|fattori di approssimanzione]] che esso può accettare.

2
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/soluzione approssimata.md
View file

@ -2,5 +2,5 @@ Una [[9 - Algoritmi distribuiti/1 - Problemi/soluzione|soluzione ammissibile]] p
$$ $$
\Huge \Huge
Approx Result_{Approximated}
$$ $$

14
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/vertex cover problem.md
View file

@ -1,15 +1,11 @@
[[problema di minimizzazione]] [[classe di problemi NP-difficili|NP-hard]]. [[problema di minimizzazione]] [[classe di problemi NP-difficili|NP-hard]].
Dato un [[grafo]] non diretto e non pesato, vogliamo trovare il [[vertex cover]] di [[cardinalità]] [[problema di minimizzazione|minima]]. ## Definizione
## #TODO Con un [[algoritmo greedy]] Dato un [[grafo]], si vuole determinare il [[vertex cover]] composto dal numero minimo di [[nodo di un grafo|nodi]].
1. Finchè rimangono degli archi: ## [[algoritmo|Algoritmi]]
2. Scelgo un arco a caso
3. Aggiungo i due estremi al cover
4. Cancello tutti gli archi incidenti ai due nodi
È polinomiale perchè il numero di iterazioni massime è il numero di archi nel grafo, quindi tempo in $O(n)$. ### Di approssimazione
Fattore di approssimazione $2$. C'è una dimostrazione facile, ma ho troppo sonno, ha a che fare con il fatto che gli archi dell'algoritmo greedy sono disgiunti
- [[algoritmo senza nome approssimato greedy di vertex cover]]

2
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/vertex cover.md
View file

@ -1 +1 @@
[[Insieme]] di [[nodo di un grafo|nodi di un grafo]] il cui insieme di archi copre tutto il grafo. [[Insieme]] di [[nodo di un grafo|nodi di un grafo]] tale che l'[[unione]] di tutti i loro [[arco di un grafo|archi]] adiacenti coincide con gli [[arco di un grafo|archi]] presenti nel [[grafo]] stesso.

32
9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/★ algoritmi di approssimazione.canvas
View file

@ -1,6 +1,34 @@
{ {
"nodes":[ "nodes":[
{"id":"4d3c216659c17596","x":-480,"y":-160,"width":400,"height":400,"color":"#ffffff","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/algoritmo di approssimazione.md"} {"id":"2ec6b855516359a3","type":"file","file":"9 - Algoritmi distribuiti/1 - Problemi/classe di problemi NP-difficili.md","x":-480,"y":-720,"width":400,"height":400},
{"id":"4d3c216659c17596","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/algoritmo di approssimazione.md","x":-480,"y":400,"width":400,"height":400},
{"id":"3a9e9d4caa20fff8","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/soluzione approssimata.md","x":-1040,"y":400,"width":400,"height":400},
{"id":"e7e31b7a24989fdd","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/fattore di approssimazione.md","x":-1040,"y":960,"width":400,"height":400},
{"id":"e10c70a79599cd67","type":"file","file":"9 - Algoritmi distribuiti/1 - Problemi/soluzione ottima.md","x":-1040,"y":-160,"width":400,"height":400},
{"id":"28e50cced4c59e84","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/schema di approssimazione.md","x":-480,"y":1520,"width":400,"height":400},
{"id":"92105d11d24eed0c","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/schema di approssimazione interamente polinomiale.md","x":-480,"y":2080,"width":400,"height":400},
{"id":"ace76303d024c700","type":"file","file":"9 - Algoritmi distribuiti/1 - Problemi/istanza.md","x":80,"y":960,"width":400,"height":400},
{"id":"46482c7ee4ebfa26","type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/vertex cover.md","x":80,"y":-720,"width":400,"height":400},
{"id":"44c2fa4093fc9c04","x":640,"y":-720,"width":960,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/vertex cover problem.md"},
{"id":"7b3091391cc8a19b","x":1760,"y":-720,"width":400,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/algoritmo senza nome approssimato greedy di vertex cover.md"},
{"id":"2fab0947414cdffe","x":2320,"y":-720,"width":400,"height":400,"type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/proprietà triangolare per il costo degli archi.md"},
{"id":"08d98d147d3e6b08","x":2880,"y":-720,"width":960,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/1 - Problemi/problema del commesso viaggiatore.md"},
{"id":"4fdea1de022751c5","x":4000,"y":-720,"width":400,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/approssimazione del problema del commesso viaggiatore.md"}
], ],
"edges":[] "edges":[
{"id":"dd32bf1c67ce9804","fromNode":"2ec6b855516359a3","fromSide":"bottom","toNode":"4d3c216659c17596","toSide":"top"},
{"id":"88ffe70b34d17035","fromNode":"4d3c216659c17596","fromSide":"left","toNode":"3a9e9d4caa20fff8","toSide":"right"},
{"id":"7738916e116e2bd4","fromNode":"4d3c216659c17596","fromSide":"bottom","toNode":"28e50cced4c59e84","toSide":"top"},
{"id":"75607cc5a94b547c","fromNode":"28e50cced4c59e84","fromSide":"bottom","toNode":"92105d11d24eed0c","toSide":"top"},
{"id":"0314808b4eaaa2eb","fromNode":"e10c70a79599cd67","fromSide":"bottom","toNode":"3a9e9d4caa20fff8","toSide":"top"},
{"id":"ab5860af8ef2d7e1","fromNode":"3a9e9d4caa20fff8","fromSide":"bottom","toNode":"e7e31b7a24989fdd","toSide":"top"},
{"id":"7b6ac34c15336a5c","fromNode":"ace76303d024c700","fromSide":"left","toNode":"28e50cced4c59e84","toSide":"top"},
{"id":"960603f27b98be25","fromNode":"e7e31b7a24989fdd","fromSide":"right","toNode":"28e50cced4c59e84","toSide":"top"},
{"id":"b55d2cd3533c09b2","fromNode":"46482c7ee4ebfa26","fromSide":"right","toNode":"44c2fa4093fc9c04","toSide":"left"},
{"id":"63b3b0fb2b86b36c","fromNode":"44c2fa4093fc9c04","fromSide":"right","toNode":"7b3091391cc8a19b","toSide":"left"},
{"id":"362ab5f832d84f4c","fromNode":"4d3c216659c17596","fromSide":"right","toNode":"7b3091391cc8a19b","toSide":"bottom"},
{"id":"cfa6bc1368db658a","fromNode":"08d98d147d3e6b08","fromSide":"right","toNode":"4fdea1de022751c5","toSide":"left"},
{"id":"6ab3bf8ecaa5f8e3","fromNode":"4d3c216659c17596","fromSide":"right","toNode":"08d98d147d3e6b08","toSide":"bottom"},
{"id":"502b52ee867f9d64","fromNode":"2fab0947414cdffe","fromSide":"right","toNode":"08d98d147d3e6b08","toSide":"left"}
]
} }

3
9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/tick.md
View file

@ -2,3 +2,6 @@
> [!EXAMPLE] > [!EXAMPLE]
> Un clock potrebbe fare 1000 tick ogni secondo. > Un clock potrebbe fare 1000 tick ogni secondo.
> [!Tip]
> In termini algoritmici, lo si potrebbe definire come un'*iterazione* di [[clock]]!

0
9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti.canvas → 9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti di computazione distribuita.canvas
View file

40
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/TellZero Byz.md Normal file
View file

@ -0,0 +1,40 @@
[[algoritmo]] di [[consenso sincrono deterministico bizantino]].
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
==...==
## [[Comportamento]]
> [!Summary]
> ==...==
### ==`STATO1`==
==...==
### ==`STATO2`==
==...==
## [[algoritmo corretto|Correttezza]]
> [!Success]
> ==...==
> [!Failure]
> ==...==
## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[comunicazione]] | ==...== |
| [[tempo]] | ==...== |
### [[Comunicazione]]
==...==
### [[Tempo]]
==...==

0
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/Untitled.md Normal file
View file

41
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome Las Vegas di consenso asincrono non-deterministico bizantino.md Normal file
View file

@ -0,0 +1,41 @@
[[algoritmo]] [[algoritmo Las Vegas|Las Vegas]] di [[consenso asincrono non-deterministico bizantino]].
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
- **[[restrizione di tempo|Tempo]]**
- ***[[terminazione ignorata]]***
## [[Comportamento]]
> [!Summary]
> ==...==
### ==`STATO1`==
==...==
### ==`STATO2`==
==...==
## [[algoritmo corretto|Correttezza]]
> [!Success]
> ==...==
> [!Failure]
> ==...==
## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[comunicazione]] | ==...== |
| [[tempo]] | ==...== |
### [[Comunicazione]]
==...==
### [[Tempo]]
==...==

8
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome Monte Carlo di consenso asincrono non-deterministico bizantino.md Normal file
View file

@ -0,0 +1,8 @@
[[algoritmo]] [[algoritmo Monte Carlo|Monte Carlo]] di [[consenso asincrono non-deterministico bizantino]].
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
- **[[restrizione di affidabilità|Affidabilità]]**
- ***massimo di $\frac{Entities}{500}$ guasti***
- **[[restrizione di tempo|Tempo]]**
- ***[[terminazione locale]]***

60
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome di consenso sincrono deterministico.md Normal file
View file

@ -0,0 +1,60 @@
[[algoritmo]] di [[consenso sincrono deterministico]].
## [[Comportamento]]
> [!Summary]
> Ogni [[entità]] tiene traccia delle scelte e dei [[guasti di esecuzione di crash|crash]] che conosce.
>
> Ad ogni [[tick]], manda questi dati a tutte le altre, e aggiorna i propri con i dati che riceve.
## [[algoritmo corretto|Correttezza]]
> [!Success]
> Dopo tante iterazioni quante i [[guasto|guasti]] possibili più una, l'algoritmo termina.
## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[comunicazione]] | $O(Entities^2 \cdot Fallible)$ |
| [[tempo]] | $O(Fallible)$ |
### [[Comunicazione]]
Ad ogni [[tick]], ogni [[entità]] invia a tutte le altre un report:
$$
{\color{LightCoral} \sum_{Tick}^{Iterations}}
{\color{SpringGreen} \sum_{Entity}^{Entities}}
{\color{SkyBlue} (Entities - 1)}
$$
Cioè:
$$
{\color{LightCoral} (Fallible - 1)}
\cdot
{\color{SpringGreen} (Entities)}
\cdot
{\color{SkyBlue} (Entities - 1)}
$$
In [[notazione asintotica]]:
$$
\Large O({\color{SpringGreen} Entities} ^{\color{SkyBlue} 2} \cdot {\color{LightCoral} Fallible})
$$
### [[Tempo]]
Richiede il seguente numero di iterazioni da un [[tick]] ciascuna:
$$
Fallible + 1
$$
In [[notazione asintotica]]:
$$
\Large O(Fallible)
$$
## ==Extra==
==C'è una dimostrazione aggiuntiva strana di cui non capisco lo scopo.==
==C'è un algoritmo di semplificazione per problemi decisionali che mi sembra triviale?==

1
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/broadcast affidabile su grafo completo.md
View file

@ -27,4 +27,3 @@ Si vuole effettuare [[broadcast problem|broadcast]] in un [[grafo completo]] con
## [[algoritmo|Algoritmi]] ## [[algoritmo|Algoritmi]]
- [[two-steps broadcast]] - [[two-steps broadcast]]
- ==...==

46
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono deterministico bizantino.md Normal file
View file

@ -0,0 +1,46 @@
Problema per un [[sistema distribuito]], che allenta il [[consenso asincrono deterministico]].
## Definizione
Ad ogni [[entità]] viene fornito un [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], che usa per scegliere un valore da una [[enumerazione]].
Successivamente, deve accordarsi con almeno un certo numero di altre per selezionare un [[risultato|output]].
Tutte le [[entità]] non [[guasto|guaste]] devono:
- **principio di non-trivialità**
- dato uno stesso [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], scegliere lo stesso valore
- **principio di accordo**
- dare lo stesso [[risultato|output]]
- **principio di terminazione**
- dare eventualmente un [[risultato|output]]
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- [[dimensione dei messaggi illimitata]]
- [[full-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[guasti di esecuzione]]
- [[guasti di esecuzione di crash]]
- ***[[guasti di esecuzione di omissione]]***
- ***[[guasti di esecuzione bizantini]]***
- [[niente guasti di trasmissione]]
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[grafo completo]]
- **[[restrizione di tempo|Tempo]]**
- [[ritardo di comunicazione illimitato]]
- [[risveglio multiplo]]
- [[terminazione locale]]
## [[algoritmo|Algoritmi]]
> [!Failure]
> Il problema non è risolvibile deterministicamente e asincronicamente:
> - **[[ritardo di comunicazione illimitato]]**
> - non si può distinguere un attesa da un [[guasti di esecuzione di crash|crash]]
> - **[[algoritmo deterministico]]**
> - non si può avere la certezza che l'[[algoritmo]] sia [[algoritmo corretto|corretto]].

46
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono deterministico.md Normal file
View file

@ -0,0 +1,46 @@
Problema per un [[sistema distribuito]].
## Definizione
Ad ogni [[entità]] viene fornito un [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], che usa per scegliere un valore da una [[enumerazione]].
Successivamente, deve accordarsi con almeno un certo numero di altre per selezionare un [[risultato|output]].
Tutte le [[entità]] non [[guasto|guaste]] devono:
- **principio di non-trivialità**
- dato uno stesso [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], scegliere lo stesso valore
- **principio di accordo**
- dare lo stesso [[risultato|output]]
- **principio di terminazione**
- dare eventualmente un [[risultato|output]]
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- [[dimensione dei messaggi illimitata]]
- [[full-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[guasti di esecuzione]]
- [[guasti di esecuzione di crash]]
- [[niente guasti di esecuzione di omissione]]
- [[niente guasti di esecuzione bizantini]]
- [[niente guasti di trasmissione]]
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[grafo completo]]
- **[[restrizione di tempo|Tempo]]**
- [[ritardo di comunicazione illimitato]]
- [[risveglio multiplo]]
- [[terminazione locale]]
## Risolvibilità
> [!Failure]
> Il problema non è risolvibile deterministicamente e asincronicamente:
> - **[[ritardo di comunicazione illimitato]]**
> - non si può distinguere un attesa da un [[guasti di esecuzione di crash|crash]]
> - **[[algoritmo deterministico]]**
> - non si può avere la certezza che l'[[algoritmo]] sia [[algoritmo corretto|corretto]].

42
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono non-deterministico bizantino.md Normal file
View file

@ -0,0 +1,42 @@
Problema per un [[sistema distribuito]] che restringe il [[consenso asincrono deterministico bizantino]].
## Definizione
Ad ogni [[entità]] viene fornito un [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], che usa per scegliere un valore da una [[enumerazione]].
Successivamente, deve accordarsi con almeno un certo numero di altre per selezionare un [[risultato|output]].
Tutte le [[entità]] non [[guasto|guaste]] devono:
- **principio di non-trivialità**
- dato uno stesso [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], scegliere lo stesso valore
- **principio di accordo**
- dare lo stesso [[risultato|output]]
- **principio di terminazione**
- dare eventualmente un [[risultato|output]]
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- [[dimensione dei messaggi illimitata]]
- [[full-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[guasti di esecuzione]]
- [[guasti di esecuzione di crash]]
- [[guasti di esecuzione di omissione]]
- [[guasti di esecuzione bizantini]]
- [[niente guasti di trasmissione]]
- ***massimo di $\frac{Entities}{9}$ guasti***
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[grafo completo]]
- **[[restrizione di tempo|Tempo]]**
- [[ritardo di comunicazione illimitato]]
- [[risveglio multiplo]]
- [[terminazione locale]]
## [[algoritmo|Algoritmi]]
- [[algoritmo senza nome Las Vegas di consenso asincrono non-deterministico bizantino]]

46
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono non-deterministico.md Normal file
View file

@ -0,0 +1,46 @@
Problema per un [[sistema distribuito]] che restringe il [[consenso asincrono deterministico]].
## Definizione
Ad ogni [[entità]] viene fornito un [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], che usa per scegliere un valore da una [[enumerazione]].
Successivamente, deve accordarsi con almeno un certo numero di altre per selezionare un [[risultato|output]].
Tutte le [[entità]] non [[guasto|guaste]] devono:
- **principio di non-trivialità**
- dato uno stesso [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], scegliere lo stesso valore
- **principio di accordo**
- dare lo stesso [[risultato|output]]
- **principio di terminazione**
- dare eventualmente un [[risultato|output]]
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- [[dimensione dei messaggi illimitata]]
- [[full-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[guasti di esecuzione]]
- [[guasti di esecuzione di crash]]
- [[niente guasti di esecuzione di omissione]]
- [[niente guasti di esecuzione bizantini]]
- [[niente guasti di trasmissione]]
- ***massimo di $\frac{Entities}{2}$ guasti***
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[grafo completo]]
- **[[restrizione di tempo|Tempo]]**
- [[ritardo di comunicazione illimitato]]
- [[risveglio multiplo]]
- [[terminazione locale]]
- **[[Algoritmo]]**
- ***[[algoritmo non-deterministico]]***
## [[algoritmo|Algoritmi]]
- **protocollo di Ben-Or**
- [[protocollo di Ben-Or Las Vegas|versione Las Vegas]]
- [[protocollo di Ben-Or Monte Carlo|versione Monte Carlo]]

43
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso sincrono deterministico bizantino.md Normal file
View file

@ -0,0 +1,43 @@
Problema per un [[sistema distribuito]] che restringe il [[consenso asincrono deterministico bizantino]].
## Definizione
Ad ogni [[entità]] viene fornito un [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], che usa per scegliere un valore da una [[enumerazione]].
Successivamente, deve accordarsi con almeno un certo numero di altre per selezionare un [[risultato|output]].
Tutte le [[entità]] non [[guasto|guaste]] devono:
- **principio di non-trivialità**
- dato uno stesso [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], scegliere lo stesso valore
- **principio di accordo**
- dare lo stesso [[risultato|output]]
- **principio di terminazione**
- dare eventualmente un [[risultato|output]]
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- [[dimensione dei messaggi illimitata]]
- [[full-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[guasti di esecuzione]]
- [[guasti di esecuzione di crash]]
- [[guasti di esecuzione di omissione]]
- [[guasti di esecuzione bizantini]]
- [[niente guasti di trasmissione]]
- ***massimo di $\frac{Entities}{3}$ guasti***
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[grafo completo]]
- **[[restrizione di tempo|Tempo]]**
- ***[[ritardo di comunicazione limitato]]***
- [[risveglio multiplo]]
- ***[[risveglio contemporaneo]]***
- [[terminazione locale]]
## [[algoritmo|Algoritmi]]
- [[TellZero Byz]]

42
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso sincrono deterministico.md Normal file
View file

@ -0,0 +1,42 @@
Problema per un [[sistema distribuito]] che restringe il [[consenso asincrono deterministico]].
## Definizione
Ad ogni [[entità]] viene fornito un [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], che usa per scegliere un valore da una [[enumerazione]].
Successivamente, deve accordarsi con almeno un certo numero di altre per selezionare un [[risultato|output]].
Tutte le [[entità]] non [[guasto|guaste]] devono:
- **principio di non-trivialità**
- dato uno stesso [[9 - Algoritmi distribuiti/1 - Problemi/parametro|input]], scegliere lo stesso valore
- **principio di accordo**
- dare lo stesso [[risultato|output]]
- **principio di terminazione**
- dare eventualmente un [[risultato|output]]
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- [[dimensione dei messaggi illimitata]]
- [[full-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[guasti di esecuzione]]
- [[guasti di esecuzione di crash]]
- [[niente guasti di esecuzione di omissione]]
- [[niente guasti di esecuzione bizantini]]
- [[niente guasti di trasmissione]]
- ***massimo di $\frac{Entities}{2}$ guasti***
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[grafo completo]]
- **[[restrizione di tempo|Tempo]]**
- ***[[ritardo di comunicazione limitato]]***
- [[risveglio multiplo]]
- [[terminazione locale]]
## [[algoritmo|Algoritmi]]
- [[algoritmo senza nome di consenso sincrono deterministico]]

31
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso.md
View file

@ -1,31 +0,0 @@
Problema per un [[sistema distribuito]].
## Definizione
Ogni [[entità]] sceglie un valore da una [[enumerazione]], poi deve accordarsi con almeno un certo numero di altre per la selezione dello stesso valore.
==Come deve accordarsi?==
> [!Note]
> Il valore deve essere scelto in modo non-triviale, ovvero ==...==
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- ==...==
- **[[restrizione di affidabilità|Affidabilità]]**
- [[affidabilità nulla]]
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[niente guasti di esecuzione]]
- [[guasti di trasmissione]]
- [[edge-broadcast-possibility]]
- **[[restrizione di topologia|Topologia]]**
- ==...==
- **[[restrizione di tempo|Tempo]]**
- ==...==
## [[algoritmo|Algoritmi]]
- ==...==
- ==...==

42
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/fault-tolerant broadcast election.md Normal file
View file

@ -0,0 +1,42 @@
---
aliases:
- ft-broad-election
- fault-tolerant broad election
- ft-broadcast-election
---
[[algoritmo]] di [[leader election edge-fault-tolerant su grafo completo]].
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
- **[[restrizione di affidabilità|Affidabilità]]**
- numero di [[guasti]] noto
## [[Comportamento]]
> [!Summary]
> Ogni [[entità]] fa un [[broadcast affidabile su grafo completo|broadcast affidabile]] del suo identificatore, e avendo tutte le informazioni, determina se è il [[leader]] oppure no.
## [[algoritmo corretto|Correttezza]]
> [!Success]
> Tutte le [[entità]] ricevono tutte le informazioni per determinare il risultato appena il [[broadcast affidabile su grafo completo|broadcast affidabile]] termina.
## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[comunicazione]] | $O(Entities^2 \cdot Fallible)$ |
| [[tempo]] | ... |
### [[Comunicazione]]
Vengono effettuati tanti [[two-steps broadcast]] quante le [[entità]] del [[sistema distribuito]]:
$$
{\color{Gold} Entities} \cdot (Fallible + 1) \cdot (Entities - 2)
$$
In [[notazione asintotica]]:
$$
\Large O(Entities^{\color{Gold} 2} \cdot Fallible)
$$

39
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/ft-broad-election.md
View file

@ -1,39 +0,0 @@
[[algoritmo]] di [[leader election con fallimenti su grafo completo]].
## Funzionamento
Usa [[two steps]] come [[broadcast problem|broadcast]].
==TODO==
## [[Comportamento]]
### ==`STATO1`==
==...==
```rust
```
### ==`STATO2`==
==...==
```rust
```
## [[algoritmo corretto|Correttezza]]
==...==
## [[costo computazionale distribuito|Costo computazionale]]
### [[Comunicazione]]
==...==
### [[Spazio]]
==...==
### [[Tempo]]
==...==

5
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione di crash.md
View file

@ -1,3 +1,8 @@
---
aliases:
- crash
---
[[restrizione di affidabilità]]. [[restrizione di affidabilità]].
Permette a un [[guasto]] di disattivare completamente l'esecuzione di una [[entità]]. Permette a un [[guasto]] di disattivare completamente l'esecuzione di una [[entità]].

21
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election con fallimenti su grafo completo.md
View file

@ -1,21 +0,0 @@
Problema per un [[sistema distribuito]], che estende la [[leader election]] a un sistema senza restrizioni di affidabilità.
## Definizione
==...==
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
- **[[restrizione di comunicazione|Comunicazione]]**
- ==...==
- **[[restrizione di affidabilità|Affidabilità]]**
- ==...==
- **[[restrizione di topologia|Topologia]]**
- ==...==
- **[[restrizione di tempo|Tempo]]**
- ==...==
## [[algoritmo|Algoritmi]]
- ==...==
- ==...==

29
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election edge-fault-tolerant su grafo completo.md Normal file
View file

@ -0,0 +1,29 @@
Problema per un [[sistema distribuito]], che estende la [[leader election]] a un sistema con [[affidabilità nulla]].
## 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 illimitata]]
- [[half-duplex]]
- **[[restrizione di affidabilità|Affidabilità]]**
- ***[[affidabilità nulla]]***
- [[guasti ubiqui]]
- [[guasti permanenti]]
- [[niente guasti di esecuzione]]
- [[guasti di trasmissione]]
- [[edge-broadcast-possibility]]
- **[[restrizione di topologia|Topologia]]**
- [[grafo connesso]]
- [[identificatori univoci]]
- **[[restrizione di tempo|Tempo]]**
- [[ritardo di comunicazione illimitato]]
- [[risveglio multiplo]]
- [[terminazione locale]]
## [[algoritmo|Algoritmi]]
- [[fault-tolerant broadcast election]]

36
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/protocollo di Ben-Or Las Vegas.md Normal file
View file

@ -0,0 +1,36 @@
[[algoritmo]] [[algoritmo Las Vegas|Las Vegas]] di [[consenso asincrono non-deterministico]].
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
- **[[restrizione di tempo|Tempo]]**
- ***[[terminazione ignorata]]***
## [[Comportamento]]
> [!Summary] Summary ma non troppo
> Tutte le [[entità]] partono che si trovano al *round 1*, poi avanzano di round man mano che sono completate iterazioni.
>
> I [[messaggio|messaggi]] ricevuti appartenenti a un *round* precedente al proprio sono scartati; quelli appartenenti a un *round* successivo al proprio sono archiviati per uso futuro.
>
> Ad ogni *round*:
> - ==La descrizione sulle slides non ha senso.==
## [[algoritmo corretto|Correttezza]]
> [!Success]
> ==...==
## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[comunicazione]] | ==...== |
| [[tempo]] | ==...== |
### [[Comunicazione]]
==...==
### [[Tempo]]
==...==

38
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/protocollo di Ben-Or Monte Carlo.md Normal file
View file

@ -0,0 +1,38 @@
[[algoritmo]] [[algoritmo Monte Carlo|Monte Carlo]] di [[consenso asincrono non-deterministico]].
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
- **[[restrizione di affidabilità|Affidabilità]]**
- ***massimo di $\frac{Entities}{3}$ [[guasto|guasti]]***
- **[[restrizione di tempo|Tempo]]**
- ***[[terminazione locale]]***
## [[Comportamento]]
> [!Summary] Summary ma non troppo
> Tutte le [[entità]] partono che si trovano al *round 1*, poi avanzano di round man mano che sono completate iterazioni.
>
> I [[messaggio|messaggi]] ricevuti appartenenti a un *round* precedente al proprio sono scartati; quelli appartenenti a un *round* successivo al proprio sono archiviati per uso futuro.
>
> Ad ogni *round*:
> - ==La descrizione sulle slides non ha senso.==
## [[algoritmo corretto|Correttezza]]
> [!Success]
> ==...==
## [[costo computazionale distribuito|Costo computazionale]]
| Costo | [[notazione O-grande]] |
|-|-|
| [[comunicazione]] | ==...== |
| [[tempo]] | ==...== |
### [[Comunicazione]]
==...==
### [[Tempo]]
==...==

3
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/teorema innominato.md
View file

@ -1,3 +0,0 @@
==TODO==
Non è possibile raggiungere il consenso con un sistema deterministico se [[entità]] possono fallire.

61
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/two steps.md
View file

@ -1,61 +0,0 @@
[[algoritmo]] di [[consenso con fallimenti su grafo completo]], che estende [[one step]].
## Funzionamento
Il [[leader]] invia il suo [[messaggio]] iniziale ad alcuni nodi, e questi, se lo ricevono direttamente da esso, lo inoltrano a loro volta a tutti i loro vicini, che però non lo inoltreranno.
## [[Comportamento]]
### `LEADER`
All'[[impulso spontaneo|inizio dell'algoritmo]], invia il suo [[messaggio]]:
```rust
spontaneously! {
send!(0..MAX_FAULTS, Message {leader: true});
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`:
```rust
on_receive! {
_ => {
send!(!sender, Message {leader: false});
state!(DONE);
},
}
```
### `DONE`
Non fa niente:
```rust
on_receive! {
_ => {},
}
```
## [[algoritmo corretto|Correttezza]]
==...==
## [[costo computazionale distribuito|Costo computazionale]]
### [[Comunicazione]]
==...==
### [[Spazio]]
==...==
### [[Tempo]]
==...==

72
9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/★ guasti.canvas
View file

@ -1,40 +1,56 @@
{ {
"nodes":[ "nodes":[
{"id":"c28e8ae13374d8c6","type":"group","x":-340,"y":-2600,"width":1980,"height":3040,"label":"Restrizioni del modello"}, {"id":"c28e8ae13374d8c6","type":"group","x":-340,"y":-2600,"width":1980,"height":3040,"label":"Restrizioni del modello"},
{"id":"68bbfe85e32578c6","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md","x":-320,"y":-1280,"width":400,"height":400}, {"id":"19a784cb5255053f","type":"group","x":-100,"y":5020,"width":920,"height":1000,"label":"Protocollo di Ben-Or"},
{"id":"04cfc6550c4fa330","x":-100,"y":7260,"width":920,"height":1000,"type":"group","label":"Senza nome"},
{"id":"8fae0c5d77388881","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/affidabilità nulla.md","x":260,"y":-2580,"width":400,"height":200,"color":"3"},
{"id":"21735a09afc03155","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/affidabilità parziale.md","x":740,"y":-2580,"width":400,"height":200,"color":"2"},
{"id":"0ed7f1afe62952ea","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/affidabilità totale.md","x":1220,"y":-2580,"width":400,"height":200,"color":"1"},
{"id":"a20ebaebc4a29fcc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione di omissione.md","x":500,"y":-340,"width":400,"height":200,"color":"2"}, {"id":"a20ebaebc4a29fcc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione di omissione.md","x":500,"y":-340,"width":400,"height":200,"color":"2"},
{"id":"3c5898147ff06f4d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione di omissione.md","x":980,"y":-340,"width":400,"height":200,"color":"1"},
{"id":"83c826c203b69e98","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione di aggiunta.md","x":500,"y":-60,"width":400,"height":200,"color":"2"}, {"id":"83c826c203b69e98","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione di aggiunta.md","x":500,"y":-60,"width":400,"height":200,"color":"2"},
{"id":"70470ce379adb776","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione di aggiunta.md","x":980,"y":-60,"width":400,"height":200,"color":"1"}, {"id":"70470ce379adb776","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione di aggiunta.md","x":980,"y":-60,"width":400,"height":200,"color":"1"},
{"id":"b7a610286a64c5c4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione di corruzione.md","x":500,"y":220,"width":400,"height":200,"color":"2"}, {"id":"b7a610286a64c5c4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione di corruzione.md","x":500,"y":220,"width":400,"height":200,"color":"2"},
{"id":"40de7c7aaf875477","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione di corruzione.md","x":980,"y":220,"width":400,"height":200,"color":"1"}, {"id":"40de7c7aaf875477","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione di corruzione.md","x":980,"y":220,"width":400,"height":200,"color":"1"},
{"id":"73e2acdd24b40c9e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione.md","x":1220,"y":-620,"width":400,"height":200,"color":"1"}, {"id":"73e2acdd24b40c9e","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione.md","x":1220,"y":-620,"width":400,"height":200,"color":"1"},
{"id":"2eaae6a0d03704bc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione.md","x":260,"y":-620,"width":400,"height":200,"color":"3"}, {"id":"2eaae6a0d03704bc","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di trasmissione.md","x":260,"y":-620,"width":400,"height":200,"color":"3"},
{"id":"91446dd84a00dfab","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione di omissione.md","x":500,"y":-1180,"width":400,"height":200,"color":"2"},
{"id":"9d3039d25bda4200","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione bizantini.md","x":500,"y":-900,"width":400,"height":200,"color":"2"},
{"id":"bd414e8cefb0e5e5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/rilevamento guasti di trasmissione.md","x":740,"y":-620,"width":400,"height":200,"color":"2"}, {"id":"bd414e8cefb0e5e5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/rilevamento guasti di trasmissione.md","x":740,"y":-620,"width":400,"height":200,"color":"2"},
{"id":"7ef7209ec794590d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione di omissione.md","x":980,"y":-1180,"width":400,"height":200,"color":"1"}, {"id":"3c5898147ff06f4d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di trasmissione di omissione.md","x":980,"y":-340,"width":400,"height":200,"color":"1"},
{"id":"e149c4b8acaf172f","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/node-broadcast-possibility.md","x":-880,"y":-720,"width":400,"height":400},
{"id":"d5f4bf8331098754","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/node connectivity.md","x":-1440,"y":-720,"width":400,"height":400},
{"id":"9d3039d25bda4200","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione bizantini.md","x":500,"y":-900,"width":400,"height":200,"color":"2"},
{"id":"eacb18a5b8236572","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione bizantini.md","x":980,"y":-900,"width":400,"height":200,"color":"1"}, {"id":"eacb18a5b8236572","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione bizantini.md","x":980,"y":-900,"width":400,"height":200,"color":"1"},
{"id":"dc5fea299e2ee5c8","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti permanenti.md","x":260,"y":-2020,"width":400,"height":200,"color":"3"}, {"id":"68bbfe85e32578c6","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/restrizione di affidabilità.md","x":-320,"y":-1280,"width":400,"height":400},
{"id":"3c1df47c2798ff9c","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti transitori.md","x":740,"y":-2020,"width":400,"height":200,"color":"2"}, {"id":"91446dd84a00dfab","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione di omissione.md","x":500,"y":-1180,"width":400,"height":200,"color":"2"},
{"id":"7ef7209ec794590d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione di omissione.md","x":980,"y":-1180,"width":400,"height":200,"color":"1"},
{"id":"b3533f3a32d49f33","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione di crash.md","x":500,"y":-1460,"width":400,"height":200,"color":"2"},
{"id":"cb81bc8c88a05679","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione di crash.md","x":980,"y":-1460,"width":400,"height":200,"color":"1"},
{"id":"be5d1a688c5c9495","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge-broadcast-possibility.md","x":-880,"y":-1840,"width":400,"height":400},
{"id":"ae16216e7181f6b5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge connectivity.md","x":-1440,"y":-1840,"width":400,"height":400},
{"id":"aa9f60284b1a9cdb","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione.md","x":260,"y":-1740,"width":400,"height":200,"color":"3"}, {"id":"aa9f60284b1a9cdb","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione.md","x":260,"y":-1740,"width":400,"height":200,"color":"3"},
{"id":"cf88c1b52997051b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/rilevamento guasti di esecuzione.md","x":740,"y":-1740,"width":400,"height":200,"color":"2"}, {"id":"cf88c1b52997051b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/rilevamento guasti di esecuzione.md","x":740,"y":-1740,"width":400,"height":200,"color":"2"},
{"id":"2cd2a29eba773dc4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione.md","x":1220,"y":-1740,"width":400,"height":200,"color":"1"}, {"id":"2cd2a29eba773dc4","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione.md","x":1220,"y":-1740,"width":400,"height":200,"color":"1"},
{"id":"b3533f3a32d49f33","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti di esecuzione di crash.md","x":500,"y":-1460,"width":400,"height":200,"color":"2"}, {"id":"dc5fea299e2ee5c8","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti permanenti.md","x":260,"y":-2020,"width":400,"height":200,"color":"3"},
{"id":"cb81bc8c88a05679","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/niente guasti di esecuzione di crash.md","x":980,"y":-1460,"width":400,"height":200,"color":"1"}, {"id":"3c1df47c2798ff9c","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti transitori.md","x":740,"y":-2020,"width":400,"height":200,"color":"2"},
{"id":"8fae0c5d77388881","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/affidabilità nulla.md","x":260,"y":-2580,"width":400,"height":200,"color":"3"},
{"id":"21735a09afc03155","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/affidabilità parziale.md","x":740,"y":-2580,"width":400,"height":200,"color":"2"},
{"id":"0ed7f1afe62952ea","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/affidabilità totale.md","x":1220,"y":-2580,"width":400,"height":200,"color":"1"},
{"id":"1f1da6a430ef43fa","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti ubiqui.md","x":260,"y":-2300,"width":400,"height":200,"color":"3"}, {"id":"1f1da6a430ef43fa","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti ubiqui.md","x":260,"y":-2300,"width":400,"height":200,"color":"3"},
{"id":"f859011c43180277","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti localizzati.md","x":740,"y":-2300,"width":400,"height":200,"color":"2"}, {"id":"f859011c43180277","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasti localizzati.md","x":740,"y":-2300,"width":400,"height":200,"color":"2"},
{"id":"be5d1a688c5c9495","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge-broadcast-possibility.md","x":-880,"y":-1840,"width":400,"height":400}, {"id":"f3ee38b27f2bcf54","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/broadcast affidabile su grafo completo.md","x":-2320,"y":560,"width":960,"height":960},
{"id":"ae16216e7181f6b5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/edge connectivity.md","x":-1440,"y":-1840,"width":400,"height":400}, {"id":"973954f79c6496ef","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/two-steps broadcast.md","x":-1200,"y":560,"width":400,"height":960},
{"id":"e149c4b8acaf172f","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/node-broadcast-possibility.md","x":-880,"y":-720,"width":400,"height":400}, {"id":"60015d8ce8e4c855","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/fault-tolerant broadcast election.md","x":-1200,"y":1680,"width":400,"height":960},
{"id":"d5f4bf8331098754","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/node connectivity.md","x":-1440,"y":-720,"width":400,"height":400}, {"id":"fd6d0efabf5bdf68","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/leader election edge-fault-tolerant su grafo completo.md","x":-2320,"y":1680,"width":960,"height":960},
{"id":"e5f4ab175fa54822","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasto.md","x":-2280,"y":-1260,"width":960,"height":400}, {"id":"d905913d841158d9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/problema dei due generali.md","x":-2320,"y":2800,"width":960,"height":960},
{"id":"d905913d841158d9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/problema dei due generali.md","x":-2280,"y":600,"width":960,"height":940}, {"id":"dd2dfa59a4abafa9","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono deterministico.md","x":-2320,"y":3920,"width":960,"height":2080},
{"id":"f3ee38b27f2bcf54","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/broadcast affidabile su grafo completo.md","x":-2280,"y":1700,"width":960,"height":940}, {"id":"5b0a7d258ded1d97","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso sincrono deterministico.md","x":-1200,"y":3920,"width":960,"height":960},
{"id":"e0cddf97209d0b6d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso.md","x":-2280,"y":2800,"width":960,"height":940} {"id":"37b118b05d930636","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome di consenso sincrono deterministico.md","x":-80,"y":3920,"width":400,"height":960},
{"id":"c4c0cf8378d3dcde","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono non-deterministico.md","x":-1200,"y":5040,"width":960,"height":960},
{"id":"4de631c74d48eec5","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/protocollo di Ben-Or Las Vegas.md","x":-80,"y":5040,"width":400,"height":960},
{"id":"e7ecc6d1fc70eaab","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/protocollo di Ben-Or Monte Carlo.md","x":400,"y":5040,"width":400,"height":960},
{"id":"90b6bb6521b73b00","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono deterministico bizantino.md","x":-2320,"y":6160,"width":960,"height":2080},
{"id":"17136aeeb106bd3a","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso sincrono deterministico bizantino.md","x":-1200,"y":6160,"width":960,"height":960},
{"id":"200822b7952f8abf","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/TellZero Byz.md","x":-80,"y":6160,"width":400,"height":960},
{"id":"2f09bbf4ec002b2b","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso asincrono non-deterministico bizantino.md","x":-1200,"y":7280,"width":960,"height":960},
{"id":"3e8b1e701c0de116","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome Las Vegas di consenso asincrono non-deterministico bizantino.md","x":-80,"y":7280,"width":400,"height":960},
{"id":"f89db1c030032971","x":400,"y":7280,"width":400,"height":960,"type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/algoritmo senza nome Monte Carlo di consenso asincrono non-deterministico bizantino.md"},
{"id":"e5f4ab175fa54822","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/guasto.md","x":-2320,"y":-1280,"width":960,"height":400}
], ],
"edges":[ "edges":[
{"id":"54f8b47c95315ec2","fromNode":"e5f4ab175fa54822","fromSide":"right","toNode":"68bbfe85e32578c6","toSide":"left"}, {"id":"54f8b47c95315ec2","fromNode":"e5f4ab175fa54822","fromSide":"right","toNode":"68bbfe85e32578c6","toSide":"left"},
@ -69,6 +85,20 @@
{"id":"ec9b43343fe8c4a2","fromNode":"68bbfe85e32578c6","fromSide":"right","toNode":"2eaae6a0d03704bc","toSide":"left"}, {"id":"ec9b43343fe8c4a2","fromNode":"68bbfe85e32578c6","fromSide":"right","toNode":"2eaae6a0d03704bc","toSide":"left"},
{"id":"b4fcf87ad06526e9","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"d905913d841158d9","toSide":"left"}, {"id":"b4fcf87ad06526e9","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"d905913d841158d9","toSide":"left"},
{"id":"e1213d5214f96830","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"f3ee38b27f2bcf54","toSide":"left"}, {"id":"e1213d5214f96830","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"f3ee38b27f2bcf54","toSide":"left"},
{"id":"fd6f267133dfd382","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"e0cddf97209d0b6d","toSide":"left"} {"id":"c8951ad8a42d74d9","fromNode":"f3ee38b27f2bcf54","fromSide":"right","toNode":"973954f79c6496ef","toSide":"left"},
{"id":"fbed0bc781186110","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"fd6d0efabf5bdf68","toSide":"left"},
{"id":"cb695b14aa0c83fc","fromNode":"fd6d0efabf5bdf68","fromSide":"right","toNode":"60015d8ce8e4c855","toSide":"left"},
{"id":"d8d95f863134c05e","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"dd2dfa59a4abafa9","toSide":"left"},
{"id":"296f59b4a76359d0","fromNode":"dd2dfa59a4abafa9","fromSide":"right","toNode":"5b0a7d258ded1d97","toSide":"left"},
{"id":"216945a7a36afd0b","fromNode":"5b0a7d258ded1d97","fromSide":"right","toNode":"37b118b05d930636","toSide":"left"},
{"id":"7013e702d4c0b101","fromNode":"dd2dfa59a4abafa9","fromSide":"right","toNode":"c4c0cf8378d3dcde","toSide":"left"},
{"id":"e593a804bef6349b","fromNode":"4de631c74d48eec5","fromSide":"right","toNode":"e7ecc6d1fc70eaab","toSide":"left"},
{"id":"7aaba43b9cf12c88","fromNode":"dd2dfa59a4abafa9","fromSide":"bottom","toNode":"90b6bb6521b73b00","toSide":"top"},
{"id":"f528c4f6a6ffd211","fromNode":"c4c0cf8378d3dcde","fromSide":"right","toNode":"19a784cb5255053f","toSide":"left"},
{"id":"a0b3b20d4df68d7e","fromNode":"90b6bb6521b73b00","fromSide":"right","toNode":"17136aeeb106bd3a","toSide":"left"},
{"id":"9d82b84ee9546ecf","fromNode":"17136aeeb106bd3a","fromSide":"right","toNode":"200822b7952f8abf","toSide":"left"},
{"id":"0f3eb88229aee48b","fromNode":"90b6bb6521b73b00","fromSide":"right","toNode":"2f09bbf4ec002b2b","toSide":"left"},
{"id":"a0b1fb66aee77a7c","fromNode":"3e8b1e701c0de116","fromSide":"right","toNode":"f89db1c030032971","toSide":"left"},
{"id":"1112f18aa78360b8","fromNode":"2f09bbf4ec002b2b","fromSide":"right","toNode":"04cfc6550c4fa330","toSide":"left"}
] ]
} }

1
9 - Algoritmi distribuiti/4 - Strutture dati distribuite/★ strutture dati distribuite.canvas Normal file
View file

@ -0,0 +1 @@
{}

8
9 - Algoritmi distribuiti/★ algoritmi distribuiti.md
View file

@ -3,11 +3,13 @@ Appunti del corso di ***Algoritmi distribuiti***, tenuto da [[Manuela Montangero
## Appunti ## Appunti
1. [[★ problemi.canvas|★ problemi]] 1. [[★ problemi.canvas|★ problemi]]
2. [[★ algoritmi di approssimazione.canvas|★ algoritmi di approssimazione]] 2. [[9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/★ algoritmi di approssimazione.canvas|★ algoritmi di approssimazione]]
3. **Computazione distribuita** 3. ★ computazione distribuita
1. [[★ concetti.canvas|★ concetti]] 1. [[★ concetti di computazione distribuita.canvas|★ concetti]]
2. [[★ broadcast.canvas|★ broadcast]] 2. [[★ broadcast.canvas|★ broadcast]]
3. [[★ spanning tree.canvas|★ spanning tree]] 3. [[★ spanning tree.canvas|★ spanning tree]]
4. [[★ computazione.canvas|★ computation in trees]] 4. [[★ computazione.canvas|★ computation in trees]]
5. [[★ leader election.canvas|★ leader election]] 5. [[★ leader election.canvas|★ leader election]]
6. [[★ routing.canvas|★ routing]] 6. [[★ routing.canvas|★ routing]]
7. [[★ guasti.canvas|★ guasti]]
4. [[★ strutture dati distribuite.canvas|★ strutture dati distribuite]]

0
steffo-file-index-ignore.json → file-index-ignore.json
View file

804
steffo-file-index.json → file-index.json
View file

File diff suppressed because it is too large Load diff