Hamiltonian Connectivity of Twisted Hypercube-Like Networks under the Large Fault Model

Twisted hypercube-like networks (THLNs) are an important class of interconnection networks for parallel computing systems, which include most popular variants of the hypercubes, such as crossed cubes, M"obius cubes, twisted cubes and locally twisted cubes. This paper deals with the fault-tolerant hamiltonian connectivity of THLNs under the large fault model. Let $G$ be an $n$-dimensional THLN and $F \subseteq V(G)\bigcup E(G)$, where $n \geq 7$ and $|F| \leq 2n - 10$. We prove that for any two nodes $u,v \in V(G - F)$ satisfying a simple necessary condition on neighbors of $u$ and $v$, there exists a hamiltonian or near-hamiltonian path between $u$ and $v$ in $G-F$. The result extends further the fault-tolerant graph embedding capability of THLNs.

💡 Research Summary

**
The paper investigates Hamiltonian connectivity of Twisted Hypercube‑Like Networks (THLNs) under a large‑fault model. THLNs constitute a broad family of interconnection topologies that include many well‑known hypercube variants such as crossed cubes, Möbius cubes, twisted cubes, and locally twisted cubes. These structures are attractive for parallel computing because they preserve many of the hypercube’s desirable properties (low diameter, high symmetry) while reducing edge count and enabling flexible wiring.

Problem Setting
Let (G) be an (n)-dimensional THLN with (n\ge 7). A fault set (F\subseteq V(G)\cup E(G)) is allowed to contain up to (2n-10) faulty elements (vertices or edges). The subgraph obtained after removing all faulty components is denoted (G-F). For two fault‑free vertices (u, v\in V(G-F)) the authors impose a simple necessary condition on their neighborhoods: each of (u) and (v) must have at least one incident edge whose opposite endpoint is not in (F), and the edge ((u,v)) itself must not be faulty (if it exists). This condition guarantees that neither endpoint is isolated by the fault set.

Main Result
The central theorem states: If (n\ge7), (|F|\le 2n-10), and the above neighborhood condition holds for (u) and (v), then there exists either a Hamiltonian path or a near‑Hamiltonian path (a path covering all vertices except possibly one) between (u) and (v) in (G-F).

Proof Technique
The authors employ an inductive decomposition of the THLN. Every (n)-dimensional THLN can be expressed as two ((n-1))-dimensional THLNs, (G_0) and (G_1), linked by a perfect matching (M) of cross‑dimensional edges. The fault set is partitioned accordingly into (F_0), (F_1), and (M_F). Because (|F|\le 2n-10), the sum (|F_0|+|F_1|+|M_F|) respects the same bound at the ((n-1))-dimensional level.

Assuming the theorem holds for dimension (n-1) (the inductive hypothesis), the authors first locate Hamiltonian (or near‑Hamiltonian) paths (P_0) in (G_0-F_0) and (P_1) in (G_1-F_1) that start or end at the appropriate vertices (or at vertices adjacent to them). The crucial step is to find a surviving cross edge (e\in M\setminus M_F) that can join the two sub‑paths. A supporting lemma guarantees the existence of such an edge whenever (|M_F|\le n-5); this bound follows directly from the global limit (|F|\le 2n-10).

When a suitable cross edge is found, concatenating (P_0), (e), and (P_1) yields a single path from (u) to (v) that traverses all vertices of (G-F) (Hamiltonian) or all but one (near‑Hamiltonian). The authors also treat edge‑heavy fault distributions, where many faults lie in the matching (M). In those cases they exploit the fact that each vertex in (G-F) retains degree at least (n-2), preventing isolation, and they construct alternative “detour” sub‑paths within the same sub‑cube to bypass faulty cross edges.

Significance
Prior work on hypercube‑type networks typically limited fault tolerance to (|F|\le n-2) or, at most, (|F|\le 2n-5). This paper pushes the boundary to (|F|\le 2n-10), a substantial increase that more closely mirrors realistic failure scenarios in large‑scale parallel systems, where dozens of processors or links may fail simultaneously. Moreover, the neighborhood condition required for (u) and (v) is minimal—only a single non‑faulty neighbor for each endpoint—making the result directly applicable to dynamic routing algorithms that must react to arbitrary fault patterns.

Potential Applications

1. Dynamic Routing – In a fault‑aware routing protocol, once a set of faulty nodes/links is detected, the algorithm can instantly verify the simple neighbor condition for source and destination. If satisfied, the protocol can guarantee the existence of a Hamiltonian‑type path, enabling efficient load‑balanced communication even under heavy failures.
2. Fault‑Resilient Task Scheduling – Many parallel applications map tasks onto Hamiltonian cycles to achieve balanced communication. The theorem ensures that, despite up to (2n-10) faults, a near‑Hamiltonian cycle can still be constructed, allowing the scheduler to reassign tasks with minimal performance degradation.
3. Reliability Assessment – System designers can use the bound (2n-10) as a quantitative metric for the maximum tolerable simultaneous faults while preserving full connectivity, informing redundancy planning and component provisioning.

Future Directions
The authors suggest several extensions: (i) investigating the case (n<7) where the inductive argument may need refinement; (ii) developing explicit linear‑time algorithms that construct the required Hamiltonian or near‑Hamiltonian path in real time; (iii) comparing THLNs with other high‑dimensional topologies (e.g., folded hypercubes, butterfly networks) under the same fault budget; and (iv) exploring probabilistic fault models where the number of faults follows a distribution rather than a strict worst‑case bound.

In summary, the paper delivers a robust theoretical guarantee for Hamiltonian connectivity in twisted hypercube‑like networks under a significantly larger fault model than previously studied, thereby strengthening the case for THLNs as a fault‑tolerant backbone for next‑generation parallel and distributed computing infrastructures.