An Efficient Construction of Completely Independent Spanning Trees in Dense Gaussian Networks

Abstract: Fault tolerance in routing and broadcasting is a critical aspect in ensuring the reliability and robustness of communication networks, particularly in environments prone to failures. This work presents an efficient method for constructing Completely Independent Spanning Trees (CISTs) within dense Gaussian networks, providing improved fault tolerance, reliability, and communication efficiency in large-scale interconnection systems. To construct the CISTs in the Gaussian network, we partition the network into sets, and accordingly the nodes are connected properly to form the first CIST and then rotated to get the second CIST with less depth than the existing state-of-art. To evaluate the performance of the proposed construction, we calculated the average maximum number of steps required to deliver a message from the root node to all other nodes in the network. A comparison with existing approaches shows that our construction outperforms them, achieving an improvement of at least 33%

• The paper introduces efficient algorithms for constructing CISTs in dense Gaussian networks, enabling reduced tree depths and enhanced fault tolerance.
• The methodology incorporates network partitioning and a rotation-based approach, achieving O(1) per-node complexity for edge-disjoint spanning tree construction.
• Experimental evaluations demonstrate a 50%-80% reduction in tree depth and lower communication latency, making the approach ideal for datacenter and HPC applications.

Efficient Construction of Completely Independent Spanning Trees in Dense Gaussian Networks

Introduction

The paper "An Efficient Construction of Completely Independent Spanning Trees in Dense Gaussian Networks" (2606.23935) addresses the construction of Completely Independent Spanning Trees (CISTs) in dense Gaussian networks for enhancing fault-tolerant communication and broadcasting, particularly pertinent to scalable datacenter interconnect architectures. Gaussian networks, characterized by their symmetry, regularity, and lower diameter relative to torus networks, are compelling candidates for high-performance, low-latency interconnection topologies. CISTs provide edge-disjoint paths rooted at distinct nodes, facilitating robust message delivery in the presence of node or link failures.

Background and Definitions

Gaussian networks are modeled by residue classes of Gaussian integers $\mathbb{Z}[i]$, forming 4-regular graphs with nodes $x + yi$, and edges connecting nodes if their difference modulo generator $a$ belongs to $\{\pm 1, \pm i\}$. Dense Gaussian networks maximize node count for a fixed diameter, with $a = a + bi$ where $b = a + 1$ yields diameter $k = a$.

Independent Spanning Trees (ISTs) are rooted at the same node, with paths to any other node internally node-disjoint, while Edge-Disjoint Node-Independent Spanning Trees (EDNISTs) extend this to edge-disjointness. CISTs further generalize by allowing distinct roots and requiring edge-disjointness, each path between any node pairs $v, u$ in different trees being node-disjoint except at endpoints.

Methodology

The authors introduce sequential and parallel algorithms for CIST construction:

1. Network Partitioning: The dense Gaussian network is partitioned into ten distinct subsets, covering all nodes and ensuring pairwise disjointness.
2. First CIST Construction: A sequential algorithm propagates construction messages based on node subset membership and port directionality, resulting in a spanning tree rooted at node $R$.
3. Second CIST via Rotation: The second CIST is obtained by rotating the first CIST's edge directions counterclockwise, yielding a tree rooted at a distinct node and edge-disjoint from the first.
4. Parallel Algorithm: Leveraging global network knowledge broadcasted to all nodes, each node independently determines its parent and children based on the subset table, achieving $O(1)$ time and communication complexity per node, with overall initialization dominated by $x + yi$0 complexity (diameter).

Both algorithms guarantee at most two CISTs for networks with $x + yi$1, using $x + yi$2 edges per CIST.

Depth and Routing Analysis

Through rigorous combinatorial analysis, the paper proves that all constructed CISTs have a depth of $x + yi$3, a significant reduction compared to the best previous algorithm (e.g., [15]), which exhibited depths scaling approximately as $x + yi$4, where $x + yi$5. The routing algorithm derived leverages the subset partition and direction tables to determine minimal-length paths, exploiting Gaussian integer lattice symmetry and ensuring shortest-path delivery between any root and destination node.

Experimental Evaluation

The evaluation applied the NetworkX Python package, examining networks with sizes ranging from $x + yi$6 to $x + yi$7 under three scenarios: no faults, one faulty node, and two faulty nodes. The key metrics are the average maximum number of steps from root to all nodes under each CIST, computed for all root and destination pairs and all possible fault combinations.

Notable findings include:

• Depth Reduction: The proposed algorithm consistently yielded tree depths $x + yi$8–$x + yi$9 less than prior work, directly translating to lower communication latency.
• Fault Tolerance: In scenarios with one or two faulty nodes, the average maximum steps remained substantially lower than prior methods (e.g., one-fault improvement reaches $a$0 at largest tested network).
• Scalability: Parallel CIST construction provides constant time/communication complexity, scaling favorably for large, dense networks.
• Robust Routing: The methodology ensures reliable message delivery even under multiple node failures, underlining its applicability for datacenter, HPC, and on-chip multiprocessor fabrics.

Implications and Future Directions

The efficient construction of CISTs with shallow depth enhances both reliability and communication efficiency in dense Gaussian networks. Practically, this translates to minimized latency, improved load balancing, and stronger fault tolerance in scalable interconnects. Theoretical implications extend to the tractability of CIST construction in algebraically structured graph classes, revealing new possibilities for network design and fault-tolerant algorithms.

Further directions include:

• Generalization to Other Topologies: Extending the rotation and partitioning approach to other algebraic or geometric network classes (Eisenstein-Jacobi, BCube, augmented cubes).
• Dynamic and Adaptive Algorithms: Incorporating dynamic edge weights or adaptive tree reconfiguration in response to node/link status changes.
• Security Applications: Leveraging CISTs for secure multi-path routing protocols and resilient broadcasting under adversarial scenarios.
• Integration with Hardware: Exploring efficient hardware implementations of the parallel CIST construction algorithm for FPGA or ASIC-based network controllers.

Conclusion

The presented algorithms for constructing two edge-disjoint, completely independent spanning trees in dense Gaussian networks represent a clear improvement over existing methods, offering shallower tree depths and robust, low-complexity construction. These properties significantly benefit large-scale fault-tolerant communication in datacenter and HPC architectures. The approach is both theoretically sound and practically validated, laying groundwork for further enhancements in efficient network-topology-based fault-tolerant routing.