Intuition

Computing a minimum spanning tree centrally is easy (Prim, Kruskal). Doing it without a central coordinator — each node only knows its incident edges and their weights — is harder. GHS is distributed Kruskal: many small fragments grow in parallel, repeatedly absorbing or merging via their minimum outgoing edge (MWOE). Three combining rules manage the growth: smaller fragments rush into larger ones immediately (A); equal-level fragments merge only if they both chose the same edge (B); otherwise wait (C).

Explanation

MST definition + uniqueness. For a weighted graph $G=(V,E)$ with $N$ nodes, a spanning tree has $N-1$ edges connecting all nodes. The MST has minimum total edge weight. If all edge weights are distinct, the MST is unique.

Two fundamental MST properties. Cycle property: for any cycle $C$ in $G$, the heaviest edge in $C$ does NOT appear in the MST. (Rules edges OUT.) Cut property: for any proper non-empty subset $X$ of vertices, the lightest edge with exactly one endpoint in $X$ belongs to the MST. (Rules edges IN.) GHS is built on the cut property.

Proof of cut property (sketch). Suppose the lightest edge $e$ crossing the cut were NOT in MST $T^{\ast }$. Adding $e$ to $T^{\ast }$ creates a unique cycle; some other edge $f$ in $T^{\ast }$ also crosses the cut. $T=T^{\ast }+\{e\}-\{f\}$ is still a spanning tree; $w(e)<w(f)$ ⇒ $w(T)<w(T^{\ast })$. Contradicts minimality. ∎

Fragment — definition. A *fragment* is a subtree of some MST. Key lemma: if $F$ is a fragment and $e$ is the minimum-weight outgoing edge (MWOE) of $F$ (lightest edge with exactly one endpoint in $F$), then $F\cup \{e\}$ is also a fragment. This is the heart of GHS.

Classical MST algorithms — analogy. Prim's: grow a single fragment by repeatedly adding its MWOE. Kruskal's: start with $N$ single-node fragments; merge fragments by adding the MWOE of some fragment. GHS is the distributed analogue of Kruskal's — many fragments grow in parallel.

Assumptions of GHS. Each edge has a unique weight (or use tiebreaker like the pair of node IDs). Reliable, bidirectional communication channels. All nodes initially asleep; on receiving any message, a node first runs the local initialisation procedure.

High-level outline of GHS. (1) Start with each node as a level-0, one-node fragment. (2) Nodes in a fragment cooperate to find the fragment's MWOE. (3) Combine the fragment with the one on the other side of the MWOE. (4) Terminate when only one fragment remains.

Fragment naming and levels. Each fragment has a name (FN) and a level, both initially 0. The fragment's core edge is the most recently used combining edge; its weight is the new fragment name.

Three combining rules (A, B, C) — high-yield. Fragment $F=(FN,L)$ with MWOE $e_F$ leading to neighbour fragment $F^{\prime }=(F{N}^{\prime },L^{\prime })$. Rule A (Absorption): if $L<L^{\prime }$ — $F$ absorbs into $F^{\prime }$. New fragment takes $F^{\prime }$'s name and level. $F$'s nodes informed via initiate. Rule B (Merger): if $L=L^{\prime }$ AND $F^{\prime }$'s MWOE is also $e_F$ (mutual choice) — merge into a new fragment of level $L+1$ and name $w(e_F)$. Rule C (Wait): otherwise — wait until Rule A or B applies.

Combining rules intuition. Smaller fragments rush into larger ones immediately (don't slow the bigger one down). Equal fragments merge only if mutual MWOE (avoid premature merging). Larger fragments wait if other side is smaller and not pointing at the same edge (other side will grow and re-evaluate).

Node and edge state variables. ${\text{status}}_p[q]\in \{\text{basic, branch, reject}\}$ — basic = undecided; branch = in MST; reject = known non-MST. ${\text{state}}_p\in \{\text{sleep, find, found}\}$ — find = currently searching for MWOE; found = done. ${\text{father}}_p$ — pointer towards the core edge. Plus ${\text{name}}_p,{\text{level}}_p,{\text{bestwt}}_p,{\text{bestch}}_p,{\text{testch}}_p$.

Five message types in GHS. connect ⟨L⟩ — request to combine fragments. initiate ⟨L, F, state⟩ — broadcast inside a fragment to inform of new level/name and to start a new MWOE search. test ⟨L, F⟩ — sent across a candidate edge to check whether the other end is in a different fragment. accept / reject — replies to a test. report ⟨w⟩ — child reports its sub-fragment's MWOE up to its parent. changeroot — sent from the core edge down to the node incident on the MWOE, to instruct it to send connect.

Test/Accept/Reject mechanism. A node $p$ inspects its basic edges in increasing weight order. For each edge $pq$, $p$ sends test ⟨$L_p,F_p$⟩ to $q$. **$q$ replies: reject** if $F_p=F_q$ (same fragment, internal edge); accept if $F_q\ne F_p$ AND $L_q\ge L_p$; defer if $L_q<L_p$ (because $q$ might in fact be in $p$'s fragment but the initiate hasn't arrived yet).

Test/Reject optimisation. If $p$ sent a test to $q$ and $q$ sent a test to $p$, only ONE reject is needed — the other end can locally mark the edge rejected. Without this, two rejects would be exchanged.

Reporting the MWOE. Each fragment node reports the minimum (report ⟨$w$⟩) of its own MWOE candidate and its children's reports UP toward the core. The two endpoints of the core edge each receive a report from their subtree; the side whose minimum is smaller initiates a changeroot, which travels along bestch pointers to the node incident on the MWOE; that node then sends connect ⟨$L$⟩ along the MWOE.

Termination. When both endpoints of the core edge have reported $\infty$ (no outgoing edges found anywhere), the algorithm halts — only one fragment remains, which is the MST.

Max level a node can reach. Level grows only when fragments combine. Level $k$ requires $\ge 2^k$ nodes (two level-$(k-1)$ fragments merging by Rule B). Therefore for $N$ nodes, **max level $\le {\log }_{2}N$**.

Complexity of GHS. Messages: $O(N\log N+E)$, where $E$ = number of edges. The $N\log N$ term comes from initiates sent down at each of up to $\log N$ level increases. Time: $O(N\log N)$. Optimal among comparison-based distributed MST algorithms.

Definitions

• Spanning tree — An acyclic subgraph that connects all $N$ vertices using exactly $N-1$ edges.
• MST — Spanning tree with minimum total edge weight. Unique if edge weights are distinct.
• Cut property — For any non-empty proper subset $X$ of vertices, the lightest edge crossing the cut is in the MST. Foundation of GHS.
• Cycle property — For any cycle in $G$, the heaviest edge is NOT in the MST.
• Fragment — A subtree of some MST. Has a (name, level) pair. Initial single-node fragments are level 0 with name = node id.
• Core edge — The most recently used combining edge of a fragment (Rule B merger). Its weight becomes the fragment's new name.
• MWOE (Minimum-Weight Outgoing Edge) — Lightest edge of a fragment with exactly one endpoint outside the fragment. Adding it preserves the fragment property.
• Rule A (absorption) — $L<L^{\prime }$ → $F$ absorbs into $F^{\prime }$, taking $F^{\prime }$'s name and level. Smaller fragment rushes into bigger.
• Rule B (merger) — $L=L^{\prime }$ AND mutual MWOE → merge into new fragment, level $L+1$, name = $w(\text{MWOE})$.
• Rule C (wait) — Else — wait until conditions for A or B are met.
• GHS message types — connect, initiate, test, accept, reject, report, changeroot.
• Test reply rules — Same fragment → reject. Different fragment AND $L_q\ge L_p$ → accept. Different fragment AND $L_q<L_p$ → defer.

Formulas

• $$\text{Cut property:}\forall X⊊V,\underset{e}{\min }\{e\text{crosses cut}\}\in \text{MST}$$
• $$\text{Rule A:}L<L^{\prime }\Rightarrow F\text{absorbs into}{F}^{\prime }$$
• $$\text{Rule B:}L=L^{\prime }\wedge \text{mutual MWOE}\Rightarrow \text{merge at level}L+1,\text{name}=w(e_F)$$
• $$\text{Rule C:}\text{else WAIT}$$
• $$\text{Max level:}\le {\log }_{2}N$$
• $$\text{Complexity:}O(N\log N+E)\text{msgs},O(N\log N)\text{time}$$

Derivations

Max level ≤ log N (proof). Level grows only when two equal-level fragments merge (Rule B). A level-$k$ fragment is the merger of two level-$(k-1)$ fragments. By induction, a level-$k$ fragment contains $\ge 2^k$ nodes. With $N$ total nodes, $2^k\le N$ ⇒ $k\le {\log }_{2}N$. ∎

Cut property (formal). Let $T^{\ast }$ be an MST. Suppose there's a cut $(X,V\setminus X)$ and edge $e$ with one endpoint in each side, $e\notin T^{\ast }$, $w(e)<w(f)$ for every edge $f\in T^{\ast }$ crossing the cut. Adding $e$ to $T^{\ast }$ creates a unique cycle $C$. $C$ must use some edge $f$ from $T^{\ast }$ crossing the cut (else $C$ stays in $X$). Replace $f$ with $e$: $T=T^{\ast }+\{e\}-\{f\}$ has $w(T)<w(T^{\ast })$ and is still a spanning tree. Contradicts minimality. Hence $e\in T^{\ast }$.

Why Rule C (wait). Suppose $L>L^{\prime }$. If we absorbed $F^{\prime }$ immediately, we'd be doing it before $F^{\prime }$ confirms its MWOE choice — $F^{\prime }$ might be about to merge into a yet-bigger fragment $F^{\prime \prime }$. Better to wait until either: $F^{\prime }$ grows to $L^{\prime }=L$ and they share MWOE (Rule B), or $F^{\prime }$ chooses our MWOE while we have higher level (Rule A applies in reverse).

Examples

• Small GHS example, 4 nodes. A, B, C, D with edges A-B (1), B-C (2), C-D (3), A-D (5), A-C (4), B-D (6). Phase 0: 4 fragments, all level 0. Each finds MWOE: A→B(1), B→A(1), C→B(2), D→C(3). A and B mutual choice + equal level → Rule B: merge to {A,B} level 1, name = $w(AB)=1$. C's MWOE is BC(2), wants to join {A,B} (now level 1). C is level 0 < 1 → Rule A: C absorbs into {A,B}; now {A,B,C} level 1. D's MWOE CD(3) → same logic, Rule A: D absorbs. Now {A,B,C,D} level 1. MST = {AB, BC, CD}.
• Test/Accept/Reject scenario. $p$ in fragment $F_p$ level 2 sends test ⟨2, $F_p$⟩ on its lightest basic edge to $q$. (a) $q$ in same $F_p$, level 2 → reject. (b) $q$ in $F_q\ne F_p$, level 2 → accept (different fragment, equal level, edge is cross-fragment outgoing candidate). (c) $q$ in $F_q$, level 1 < 2 → defer (q might be about to be in $F_p$ — hasn't received the initiate yet). Once $q$'s level catches up, it answers definitively.
• Level increment bound (4 nodes max level). With 4 nodes, max possible level is ${\log }_{2}4=2$. Indeed: 4 single-node fragments → 2 pair fragments (level 1) → 1 four-node fragment (level 2). Cannot grow further.

Diagrams

• GHS fragment merger by Rule B: two level-$L$ fragments with mutual MWOE → merge to level $L+1$, name = $w(\text{MWOE})$ (the 'core edge').
• Combining rules table: rows = Rule A / B / C; cols = condition, action, level/name update.
• Test/Accept/Reject decision tree at $q$: same fragment → reject; diff fragment, $L_q\ge L_p$ → accept; diff, $L_q<L_p$ → defer.
• Message flow on a 4-node example: connect → initiate → test/accept/reject → report → changeroot → connect (next level).
• Level tree: each level-$k$ fragment shown as a subtree of the merger tree; height ≤ log N.

Edge cases

• Equal-weight edges break uniqueness. Use $(\text{weight},\text{smaller-id},\text{larger-id})$ lex order.
• Sleeping nodes must initialise on first received message — otherwise they don't participate.
• Async vs sync semantics — GHS is asynchronous but assumes reliable channels. With unreliable channels, retransmission protocols layer underneath.
• Test/defer chain — a defer can cascade through multiple levels before resolution; eventually resolved when levels catch up.
• Network partition during GHS — undefined behaviour without additional fault tolerance; GHS assumes reliable channels.

Common mistakes

• Saying 'GHS finds MST by Prim's algorithm'. No — GHS is closer to Kruskal's (parallel fragments merging by MWOE).
• Confusing Rule A and Rule B. A: smaller absorbs into larger (level diff). B: equal level + mutual MWOE → merge to level+1.
• Saying 'max level = N - 1'. No — max level = ${\log }_{2}N$. Each level requires doubling fragment size.
• Forgetting tie-breaking for equal weights. GHS assumes unique edge weights; without a tiebreaker, behaviour is undefined.
• Saying 'test → accept always means edge in MST'. No — accept means 'different fragment, eligible candidate'; the final MWOE selection happens via report aggregation.

Shortcuts

• Cut property: lightest edge crossing cut ∈ MST.
• Rule A: smaller absorbs into larger.
• Rule B: equal level + mutual MWOE → merge level+1.
• Rule C: else WAIT.
• Max level: log N.
• **Complexity: $O(N\log N+E)$ msgs.**
• 5 message types: connect, initiate, test, accept/reject, report, changeroot.
• **Test reply: reject (same F), accept (diff F + $L_q\ge L_p$), defer (diff + $L_q<L_p$).**

Proofs / Algorithms

Cut property formal proof. Let $T^{\ast }$ be any MST, $X⊊V$ non-empty, $e^{\ast }=(u,v)$ with $u\in X,v\in V\setminus X$ the lightest edge crossing the cut, and $e^{\ast }\notin T^{\ast }$. Adding $e^{\ast }$ to $T^{\ast }$ creates a unique cycle $C$. $C$ has $\ge 1$ other edge crossing the cut (else $C$ stays inside $X$ contradicting acyclicity of $T^{\ast }$); pick such an edge $f$. Form $T^{\prime }=T^{\ast }+\{e^{\ast }\}-\{f\}$. $T^{\prime }$ is a spanning tree (connected + $|V|-1$ edges + acyclic). $w(T^{\prime })=w(T^{\ast })+w(e^{\ast })-w(f)<w(T^{\ast })$ since $w(e^{\ast })<w(f)$. Contradicts minimality of $T^{\ast }$. Hence $e^{\ast }\in T^{\ast }$.

**Max level $\le {\log }_{2}N$.** By induction on level. Level 0: 1 node. Suppose level-$(k-1)$ fragments have $\ge 2^{k-1}$ nodes. A level-$k$ fragment results from Rule B merging of two level-$(k-1)$ fragments → $\ge 2^{k-1}+2^{k-1}=2^k$ nodes. With $N$ total, $2^k\le N$ ⇒ $k\le {\log }_{2}N$.

Correctness of GHS — each combining step extends a fragment. By the MWOE lemma, if $F$ is a fragment and $e$ is its MWOE, $F\cup \{e\}$ is also a fragment. By Rules A and B, each combining step adds the MWOE. Hence GHS always builds fragments that are subtrees of the MST.