mirror of
https://github.com/Steffo99/appunti-magistrali.git
synced 2024-11-24 03:04:18 +00:00
Update various things
This commit is contained in:
parent
fe6b559a7d
commit
fd32f541c9
GPG key ID:
2A24051445686895
50 changed files with 1301 additions and 666 deletions
3
.obsidian/community-plugins.json
vendored
3
.obsidian/community-plugins.json
vendored
|
|
@ -1,4 +1,5 @@
|
|||
[
|
||||
"obsidian-file-color",
|
||||
"steffo-file-index"
|
||||
"steffo-file-index",
|
||||
"file-index"
|
||||
]
|
||||
2
.obsidian/graph.json
vendored
2
.obsidian/graph.json
vendored
|
|
@ -17,6 +17,6 @@
|
|||
"repelStrength": 10,
|
||||
"linkStrength": 1,
|
||||
"linkDistance": 250,
|
||||
"scale": 0.008325802584174924,
|
||||
"scale": 0.14225414259055125,
|
||||
"close": false
|
||||
}
|
||||
|
|
@ -37,12 +37,12 @@ var __privateAdd = (obj, member, value) => {
|
|||
// main.ts
|
||||
var main_exports = {};
|
||||
__export(main_exports, {
|
||||
default: () => SteffoFileIndexPlugin
|
||||
default: () => FileIndexPlugin
|
||||
});
|
||||
module.exports = __toCommonJS(main_exports);
|
||||
var import_obsidian = require("obsidian");
|
||||
var _reloadIgnoreRegExpsIfIgnoreFileChangedBinding, _recreateFileIndexBinding;
|
||||
var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
|
||||
var _FileIndexPlugin = class extends import_obsidian.Plugin {
|
||||
constructor() {
|
||||
super(...arguments);
|
||||
this.ignoreRegExps = [];
|
||||
|
|
@ -50,24 +50,24 @@ var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
|
|||
__privateAdd(this, _recreateFileIndexBinding, this.recreateFileIndex.bind(this));
|
||||
}
|
||||
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) {
|
||||
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 = [];
|
||||
} 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 = [];
|
||||
} else if (ignoreFile instanceof import_obsidian.TFile) {
|
||||
const ignoreJSON = await this.app.vault.cachedRead(ignoreFile);
|
||||
const ignoreContents = JSON.parse(ignoreJSON);
|
||||
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 {
|
||||
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) {
|
||||
if (file.path === _SteffoFileIndexPlugin.FILE_IGNORE_PATH) {
|
||||
if (file.path === _FileIndexPlugin.FILE_IGNORE_PATH) {
|
||||
await this.reloadIgnoreRegExps();
|
||||
}
|
||||
}
|
||||
|
|
@ -87,32 +87,37 @@ var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
|
|||
continue;
|
||||
}
|
||||
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)) {
|
||||
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;
|
||||
}
|
||||
paths.sort();
|
||||
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 indexFile = this.app.vault.getAbstractFileByPath(_SteffoFileIndexPlugin.FILE_INDEX_PATH);
|
||||
const indexFile = this.app.vault.getAbstractFileByPath(_FileIndexPlugin.FILE_INDEX_PATH);
|
||||
if (indexFile === null) {
|
||||
console.debug("[SteffoFileIndexPlugin] File index does not exist, creating it right now at:", _SteffoFileIndexPlugin.FILE_INDEX_PATH);
|
||||
await this.app.vault.create(_SteffoFileIndexPlugin.FILE_INDEX_PATH, indexContents);
|
||||
console.debug("[FileIndexPlugin] File index does not exist, creating it right now at:", _FileIndexPlugin.FILE_INDEX_PATH);
|
||||
await this.app.vault.create(_FileIndexPlugin.FILE_INDEX_PATH, indexContents);
|
||||
} 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) {
|
||||
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);
|
||||
} 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() {
|
||||
this.addCommand({
|
||||
id: "steffo-file-index-recreate",
|
||||
id: "recreate",
|
||||
name: "Force file index recreation",
|
||||
callback: this.recreateFileIndex.bind(this)
|
||||
});
|
||||
|
|
@ -142,8 +147,8 @@ var _SteffoFileIndexPlugin = class extends import_obsidian.Plugin {
|
|||
onunload() {
|
||||
}
|
||||
};
|
||||
var SteffoFileIndexPlugin = _SteffoFileIndexPlugin;
|
||||
var FileIndexPlugin = _FileIndexPlugin;
|
||||
_reloadIgnoreRegExpsIfIgnoreFileChangedBinding = new WeakMap();
|
||||
_recreateFileIndexBinding = new WeakMap();
|
||||
SteffoFileIndexPlugin.FILE_IGNORE_PATH = "steffo-file-index-ignore.json";
|
||||
SteffoFileIndexPlugin.FILE_INDEX_PATH = "steffo-file-index.json";
|
||||
FileIndexPlugin.FILE_IGNORE_PATH = "file-index-ignore.json";
|
||||
FileIndexPlugin.FILE_INDEX_PATH = "file-index.json";
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
{
|
||||
"id": "steffo-file-index",
|
||||
"id": "file-index",
|
||||
"name": "File Index",
|
||||
"version": "2.0.0",
|
||||
"version": "3.0.3",
|
||||
"minAppVersion": "0.15.0",
|
||||
"description": "Create a metadata file about the files present in the Vault",
|
||||
"author": "Steffo",
|
||||
72
.obsidian/plugins/obsidian-file-color/data.json
vendored
72
.obsidian/plugins/obsidian-file-color/data.json
vendored
|
|
@ -266,19 +266,7 @@
|
|||
"color": "fc3lLaITDn62PYbzBhqxl"
|
||||
},
|
||||
{
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita",
|
||||
"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",
|
||||
"path": "9 - Algoritmi distribuiti/3 - Computazione distribuita/1 - Concetti/★ concetti di computazione distribuita.canvas",
|
||||
"color": "7j7Pqog0VHMVVAfazMNlb"
|
||||
},
|
||||
{
|
||||
|
|
@ -385,22 +373,6 @@
|
|||
"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/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"
|
||||
|
|
@ -418,7 +390,47 @@
|
|||
"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"
|
||||
}
|
||||
]
|
||||
|
|
|
|||
|
|
@ -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
37
0 - Template/◍ algoritmo di approssimazione.md
Normal 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]==
|
||||
|
|
@ -1,40 +1,42 @@
|
|||
[[algoritmo]] di ==PROBLEMA==.
|
||||
[[algoritmo]] di ==[Problema]==.
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]] aggiuntive
|
||||
|
||||
==...==
|
||||
- **==[Categoria]==**
|
||||
- ==[Restrizione]==
|
||||
|
||||
## [[Comportamento]]
|
||||
|
||||
> [!Summary]
|
||||
> ==...==
|
||||
> ==[Riassunto]==
|
||||
|
||||
### ==`STATO1`==
|
||||
### ==`[Stato1]`==
|
||||
|
||||
==...==
|
||||
==[Descrizione stato 1]==
|
||||
|
||||
### ==`STATO2`==
|
||||
### ==`[Stato2]`==
|
||||
|
||||
==...==
|
||||
==[Descrizione stato 2]==
|
||||
|
||||
## [[algoritmo corretto|Correttezza]]
|
||||
|
||||
> [!Success]
|
||||
> ==...==
|
||||
> ==[Perchè l'algoritmo è corretto?]==
|
||||
|
||||
> [!Failure]
|
||||
> ==...==
|
||||
> ==[Perchè l'algoritmo non è corretto?]==
|
||||
|
||||
## [[costo computazionale distribuito|Costo computazionale]]
|
||||
|
||||
| Costo | [[notazione O-grande]] |
|
||||
|-|-|
|
||||
| [[comunicazione]] | ==...== |
|
||||
| [[tempo]] | ==...== |
|
||||
| [[comunicazione]] | ==[O()]== |
|
||||
| [[tempo]] | ==[O()]== |
|
||||
|
||||
### [[Comunicazione]]
|
||||
|
||||
==...==
|
||||
==[Dimostrazione del costo di comunicazione]==
|
||||
|
||||
### [[Tempo]]
|
||||
|
||||
==...==
|
||||
==[Dimostrazione del costo di tempo]==
|
||||
|
|
|
|||
9
0 - Template/◍ problema algoritmico.md
Normal file
9
0 - Template/◍ problema algoritmico.md
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
Problema.
|
||||
|
||||
## Definizione
|
||||
|
||||
==[Definizione informale del problema]==
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- ==[Algoritmo]==
|
||||
|
|
@ -2,20 +2,19 @@ Problema per un [[sistema distribuito]].
|
|||
|
||||
## Definizione
|
||||
|
||||
==...==
|
||||
==[Definizione informale del problema]==
|
||||
|
||||
## [[restrizioni al modello dei sistemi distribuiti|Restrizioni]]
|
||||
|
||||
- **[[restrizione di comunicazione|Comunicazione]]**
|
||||
- ==...==
|
||||
- ==[Restrizione]==
|
||||
- **[[restrizione di affidabilità|Affidabilità]]**
|
||||
- ==...==
|
||||
- ==[Restrizione]==
|
||||
- **[[restrizione di topologia|Topologia]]**
|
||||
- ==...==
|
||||
- ==[Restrizione]==
|
||||
- **[[restrizione di tempo|Tempo]]**
|
||||
- ==...==
|
||||
- ==[Restrizione]==
|
||||
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- ==...==
|
||||
- ==...==
|
||||
- ==[Algoritmo]==
|
||||
|
|
|
|||
|
|
@ -1 +1,5 @@
|
|||
[[soluzione]] ad un [[problema di ottimizzazione]] in cui si cerca di trovare massimi e minimi di una [[funzione obiettivo]].
|
||||
|
||||
$$
|
||||
\Huge Result_{Optimal}
|
||||
$$
|
||||
|
|
@ -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]].
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
$$
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
[[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]].
|
||||
|
||||
|
|
@ -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.
|
||||
|
||||
$Hamilton$ è la soluzione approssimata, con [[fattore di approsimazione]] $2$.
|
||||
$Hamilton$ è la soluzione approssimata, con [[fattore di approssimazione]] $2$.
|
||||
|
||||
### 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.
|
||||
|
||||
$Hamilton$ è la soluzione approssimata, con [[fattore di approsimazione]] $2$.
|
||||
$Hamilton$ è la soluzione approssimata, con [[fattore di approssimazione]] $2$.
|
||||
|
|
|
|||
|
|
@ -1,15 +1,17 @@
|
|||
[[Costante]].
|
||||
[[Costante]] per un [[algoritmo di approssimazione]].
|
||||
|
||||
$$
|
||||
\Huge
|
||||
\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
|
||||
cost(approx)
|
||||
\frac
|
||||
{\mathrm{cost}(Result_{Approximated})}
|
||||
{\mathrm{cost}(Result_{Optimal})}
|
||||
\leq
|
||||
\alpha \cdot cost(opt)
|
||||
\alpha
|
||||
$$
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
> $$
|
||||
|
|
@ -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,5 +2,5 @@ Una [[9 - Algoritmi distribuiti/1 - Problemi/soluzione|soluzione ammissibile]] p
|
|||
|
||||
$$
|
||||
\Huge
|
||||
Approx
|
||||
Result_{Approximated}
|
||||
$$
|
||||
|
|
|
|||
|
|
@ -1,15 +1,11 @@
|
|||
[[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:
|
||||
2. Scelgo un arco a caso
|
||||
3. Aggiungo i due estremi al cover
|
||||
4. Cancello tutti gli archi incidenti ai due nodi
|
||||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
È polinomiale perchè il numero di iterazioni massime è il numero di archi nel grafo, quindi tempo in $O(n)$.
|
||||
|
||||
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
|
||||
### Di approssimazione
|
||||
|
||||
- [[algoritmo senza nome approssimato greedy di vertex cover]]
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -1,6 +1,34 @@
|
|||
{
|
||||
"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"}
|
||||
]
|
||||
}
|
||||
|
|
@ -2,3 +2,6 @@
|
|||
|
||||
> [!EXAMPLE]
|
||||
> Un clock potrebbe fare 1000 tick ogni secondo.
|
||||
|
||||
> [!Tip]
|
||||
> In termini algoritmici, lo si potrebbe definire come un'*iterazione* di [[clock]]!
|
||||
|
|
|
|||
|
|
@ -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,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]]
|
||||
|
||||
==...==
|
||||
|
|
@ -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]]***
|
||||
|
|
@ -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?==
|
||||
|
||||
|
|
@ -27,4 +27,3 @@ Si vuole effettuare [[broadcast problem|broadcast]] in un [[grafo completo]] con
|
|||
## [[algoritmo|Algoritmi]]
|
||||
|
||||
- [[two-steps broadcast]]
|
||||
- ==...==
|
||||
|
|
|
|||
|
|
@ -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]].
|
||||
|
|
@ -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]].
|
||||
|
|
@ -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]]
|
||||
|
|
@ -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]]
|
||||
|
|
@ -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]]
|
||||
|
|
@ -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]]
|
||||
|
|
@ -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]]
|
||||
|
||||
- ==...==
|
||||
- ==...==
|
||||
|
|
@ -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)
|
||||
$$
|
||||
|
|
@ -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]]
|
||||
|
||||
==...==
|
||||
|
|
@ -1,3 +1,8 @@
|
|||
---
|
||||
aliases:
|
||||
- crash
|
||||
---
|
||||
|
||||
[[restrizione di affidabilità]].
|
||||
|
||||
Permette a un [[guasto]] di disattivare completamente l'esecuzione di una [[entità]].
|
||||
|
|
|
|||
|
|
@ -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]]
|
||||
|
||||
- ==...==
|
||||
- ==...==
|
||||
|
|
@ -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]]
|
||||
|
|
@ -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]]
|
||||
|
||||
==...==
|
||||
|
|
@ -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]]
|
||||
|
||||
==...==
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
==TODO==
|
||||
|
||||
Non è possibile raggiungere il consenso con un sistema deterministico se [[entità]] possono fallire.
|
||||
|
|
@ -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]]
|
||||
|
||||
==...==
|
||||
|
|
@ -1,40 +1,56 @@
|
|||
{
|
||||
"nodes":[
|
||||
{"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":"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":-2280,"y":600,"width":960,"height":940},
|
||||
{"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":"e0cddf97209d0b6d","type":"file","file":"9 - Algoritmi distribuiti/3 - Computazione distribuita/7 - Guasti/consenso.md","x":-2280,"y":2800,"width":960,"height":940}
|
||||
{"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":"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":"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":"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":"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":"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":"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":"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":[
|
||||
{"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":"b4fcf87ad06526e9","fromNode":"e5f4ab175fa54822","fromSide":"left","toNode":"d905913d841158d9","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"}
|
||||
]
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
{}
|
||||
|
|
@ -3,11 +3,13 @@ Appunti del corso di ***Algoritmi distribuiti***, tenuto da [[Manuela Montangero
|
|||
## Appunti
|
||||
|
||||
1. [[★ problemi.canvas|★ problemi]]
|
||||
2. [[★ algoritmi di approssimazione.canvas|★ algoritmi di approssimazione]]
|
||||
3. **Computazione distribuita**
|
||||
1. [[★ concetti.canvas|★ concetti]]
|
||||
2. [[9 - Algoritmi distribuiti/2 - Algoritmi di approssimazione/★ algoritmi di approssimazione.canvas|★ algoritmi di approssimazione]]
|
||||
3. ★ computazione distribuita
|
||||
1. [[★ concetti di computazione distribuita.canvas|★ concetti]]
|
||||
2. [[★ broadcast.canvas|★ broadcast]]
|
||||
3. [[★ spanning tree.canvas|★ spanning tree]]
|
||||
4. [[★ computazione.canvas|★ computation in trees]]
|
||||
5. [[★ leader election.canvas|★ leader election]]
|
||||
6. [[★ routing.canvas|★ routing]]
|
||||
7. [[★ guasti.canvas|★ guasti]]
|
||||
4. [[★ strutture dati distribuite.canvas|★ strutture dati distribuite]]
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue