In un sistema distribuito su larga scala privo di un'autorità centrale, stabilire l'ordine cronologico degli eventi è uno dei problemi più complessi dell'informatica teorica. Affidarsi agli orologi fisici locali dei computer tramite il protocollo Network Time Protocol (NTP) si rivela sistematicamente fallimentare: oscillazioni dei cristalli di quarzo, latenze di rete asimmetriche e correzioni dei secondi intercalari introducono derive temporali (clock skew) che possono compromettere l'integrità dei dati.

"Nei sistemi distribuiti, il tempo non è un valore scalare assoluto indicato da una lancetta, ma una relazione causale parziale tra eventi: un evento A può causare B, oppure A e B possono accadere in modo del tutto concorrente."

1. Il Limite degli Orologi Logici di Lamport

Nel fondamentale articolo del 1978 "Time, Clocks, and the Ordering of Events in a Distributed System", Leslie Lamport introdusse la relazione di "happened-before" ($\prec$):

Tuttavia, l'orologio scalare di Lamport soffre di un grave limite teorico: dato un timestamp logico $L(a) < L(b)$, non è possibile dedurre che $a \prec b$; gli eventi potrebbero essere concorrenti ($a \parallel b$) ma ricevere timestamp numerici diversi per pura casualità dell'incremento locale.

2. Gli Orologi Vettoriali (Mattern & Fidge, 1988)

Per superare questo limite e consentire l'isomorfismo tra ordine causale e timestamp, Friedemann Mattern e Colin Fidge hanno introdotto gli Orologi Vettoriali (Vector Clocks). In un cluster con $N$ nodi attivi, ogni nodo $i$ mantiene un vettore di $N$ interi:

V_i = [v_1, v_2, ..., v_N]

Le Tre Regole Fondamentali di Aggiornamento

  1. Inizializzazione: Al momento dell'avvio della rete, ogni nodo imposta tutte le coordinate del proprio vettore a zero: $V_i[k] = 0 \quad \forall k \in \{1, ..., N\}$.
  2. Evento Locale: Prima di eseguire una transazione, emettere un token o aggiornare la memoria a grafo, il nodo incrementa la propria coordinata:
    V_i[i] = V_i[i] + 1
  3. Messaggio e Fusione Causale: Quando il nodo $i$ invia un messaggio mesh al nodo $j$, allega una copia del proprio vettore $V_i$. Il nodo ricevente $j$ aggiorna il proprio orologio calcolando il massimo elemento per elemento (estremo superiore o sup):
    V_j[k] = max(V_j[k], V_msg[k]) ∀ k
    e incrementa successivamente il proprio indice locale: V_j[j] = V_j[j] + 1.

3. La Condizione di Precedenza Causale Rigorosa

Grazie alla struttura vettoriale, possiamo confrontare due eventi $a$ e $b$ con vettori $V(a)$ e $V(b)$ in modo matematicamente certo:

V(a) <= V(b)  <==>  (∀ k, V(a)[k] <= V(b)[k])
V(a) < V(b)   <==>  (V(a) <= V(b)  AND  ∃ k tale che V(a)[k] < V(b)[k])

Teorema Fondamentale:
a ≺ b  <===>  V(a) < V(b)
a || b <===>  NOT(V(a) < V(b)) AND NOT(V(b) < V(a))

Se non sussiste né $V(a) < V(b)$ né $V(b) < V(a)$, gli eventi sono concorrenti ($a \parallel b$). In questo caso il sistema sa con certezza che le due operazioni sono avvenute in rami paralleli della rete senza influenzarsi a vicenda.

4. Implementazione Reale nel Cluster 00MESH

Nel cluster HyperSpace, composto dal Mac M5 (Hub Control Plane), dalla workstation HP OMEN 16 (GPU RTX Code Engine) e dall'ASUS V16 (MoE Deep Inference), ogni transizione di stato della memoria e ogni prompt di dialogo con Anna viene coordinato attraverso il modulo VectorClock:

# Implementazione Python AST-Validated del Vector Clock in HyperSpace
from typing import Dict, List, Tuple

class SovereignVectorClock:
    def __init__(self, node_id: str, cluster_nodes: List[str]):
        self.node_id = node_id
        self.clock: Dict[str, int] = {n: 0 for n in cluster_nodes}

    def tick(self) -> Dict[str, int]:
        """Avanza il contatore logico del nodo corrente."""
        self.clock[self.node_id] += 1
        return dict(self.clock)

    def merge_message(self, received_clock: Dict[str, int]) -> Dict[str, int]:
        """Fonde causalmente l'orologio del payload mesh calcolando il sup."""
        for nid, val in received_clock.items():
            self.clock[nid] = max(self.clock.get(nid, 0), val)
        self.clock[self.node_id] += 1
        return dict(self.clock)

    def compare_causality(self, other: Dict[str, int]) -> str:
        """Restituisce: 'PRECEDES' (a ≺ b), 'SUCCEEDS' (b ≺ a), o 'CONCURRENT' (a || b)."""
        all_keys = set(self.clock.keys()).union(other.keys())
        is_less_or_equal = all(self.clock.get(k, 0) <= other.get(k, 0) for k in all_keys)
        is_strictly_less = any(self.clock.get(k, 0) < other.get(k, 0) for k in all_keys)
        
        is_greater_or_equal = all(self.clock.get(k, 0) >= other.get(k, 0) for k in all_keys)
        is_strictly_greater = any(self.clock.get(k, 0) > other.get(k, 0) for k in all_keys)

        if is_less_or_equal and is_strictly_less:
            return "PRECEDES"
        if is_greater_or_equal and is_strictly_greater:
            return "SUCCEEDS"
        return "CONCURRENT"

5. Risoluzione dei Conflitti senza Deadlock né Server Centrali

Quando due nodi operano in modo concorrente su note della memoria a grafo (ad esempio se il Mac Hub riassume un log mentre l'OMEN convalida una patch di codice), 00MESH adotta una struttura a Conflict-Free Replicated Data Types (CRDT):

Conclusioni

L'adozione degli orologi vettoriali rappresenta l'architrave su cui poggia l'intera sovranità computazionale di 00MESH. Essa garantisce che centinaia di nodi eterogenei possano dialogare, inferire modelli linguistici e scambiarsi token senza dover mai interrogare un server di sincronizzazione centralizzato.