HOP: Traversals, Retrieval & Learning

• HOP is a family of graph notions defined by bounded edge traversals, applicable in exact-distance domination, hop constraints, and iterative message passing.
• It underpins methods in network design and tree embeddings, providing insights into computational complexity including NP-completeness and ETH-based lower bounds.
• HOP frameworks drive multi-hop retrieval and continual learning architectures in reinforcement learning and NLP, enhancing efficiency and mitigating catastrophic forgetting.

HOP denotes a family of notions organized around the graph-theoretic idea of traversing one or more edges, but the term is used in several technically distinct senses across recent literature. In combinatorial optimization, a hop is an exact-distance or bounded-length constraint on graph paths; in retrieval and graph learning, it indexes successive reasoning or propagation steps; in continual learning, it names specific architectures such as Hierarchical Orchestra of Policies and a high-order-pooling framework for NLP (Das et al., 28 Feb 2026, Haeupler et al., 2020, Cannon et al., 2024, Michieli et al., 2024). The shared vocabulary therefore masks heterogeneous mathematical roles: hard feasibility constraints, retrieval units, receptive-field indices, and modular composition rules.

1. Terminological scope and formal notion of a hop

In its most literal graph-theoretic sense, a hop is one edge traversal. Recent work formalizes this either through shortest-path distance or through explicit hop bounds. For a graph $G=(V,E)$, one recurring definition is

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$

with exact-distance neighborhoods

$N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$

A second standard formulation uses edge lengths $\ell_e$ and a global hop-limit $H$, declaring a path $P$ hop-constrained when $\sum_{e\in P}\ell_e\le H$ (Das et al., 28 Feb 2026, Chekuri et al., 2024).

Usage of HOP or hop	Technical role	Representative source
Exact-distance domination	Vertices must be dominated from distance exactly $r$	(Das et al., 28 Feb 2026)
Hop-constrained network design	Paths must respect a hop-limit $H$	(Haeupler et al., 2020)
Multi-hop retrieval or relation extraction	Reasoning proceeds hop by hop	(Li et al., 2020, Chen et al., 2019)
Higher-order propagation in graphs	Neighborhood information is aggregated over multiple hops	(Vijayan et al., 2018, Zhang et al., 2020)
Modular continual learning	HOP names specific frameworks in RL and NLP	(Cannon et al., 2024, Michieli et al., 2024)

A plausible implication is that “hop” functions as a common abstraction of bounded-depth interaction. The cited papers, however, do not treat these as interchangeable notions: exact-distance domination requires equality $d_G(u,v)=r$, hop-constrained design permits bounded length, and learning systems often interpret hops as iterative message-passing or policy-reuse steps rather than hard graph constraints.

2. Exact-distance domination and Roman variants

The most formalized use of HOP in recent graph theory appears in exact-distance domination. For $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$0, a set $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$1 is an $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$2-hop dominating set if every vertex in $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$3 is exactly at distance $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$4 from some vertex of $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$5:

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$6

By contrast, an $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$7-step dominating set requires every vertex of $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$8, including vertices in $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$9, to lie at distance exactly $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$0 from at least one vertex of $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$1. The Roman variant replaces sets by a function $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$2, requiring that every vertex $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$3 with $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$4 have a vertex $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$5 at distance exactly $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$6 with $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$7, and measures solution size by the weight $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$8 (Das et al., 28 Feb 2026).

These problems are all NP-complete for every fixed $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$9. The parameterized picture is sharper. For each $\ell_e$0, $\ell_e$1-Hop Roman Domination}) parameterized by the weight bound $\ell_e$2 is W[2]-complete. Membership is proved by an FPT-reduction to classical Roman Domination using a distance-encoder graph $\ell_e$3 whose vertices correspond one-to-one with those of $\ell_e$4, and where $\ell_e$5 is an edge iff $\ell_e$6. Hardness comes from Dominating Set via even-$\ell_e$7 and odd-$\ell_e$8 gadget constructions based on subdivision and added branching paths (Das et al., 28 Feb 2026).

For each $\ell_e$9, $H$0-Step Domination}) and $H$1-Hop Domination}) parameterized by $H$2 are W[2]-complete, even when restricted to bipartite or chordal graphs. The membership arguments again use distance-encoder graphs, now reducing to Total Dominating Set and Dominating Set, respectively. The hardness proofs add $H$3 forcing vertices together with branching paths so that any small solution must contain those forcing vertices plus a subset corresponding to a dominating set in the original graph (Das et al., 28 Feb 2026).

The lower-bound landscape is correspondingly strong. Because the reductions from Dominating Set are linear in $H$4, Cygan et al.’s ETH-based lower bound transfers: unless ETH fails, none of $H$5-Hop Domination}), $H$6-Step Domination}), or $H$7-Hop Roman Domination}) admits a $H$8-time algorithm on graphs with $H$9 vertices and $P$0 edges. The same reductions imply that for any $P$1, no polynomial-time algorithm can achieve a $P$2-approximation for these problems, even on bipartite or chordal graphs. On the positive side, the reduction to Roman Domination means that any exact $P$3-time algorithm for Domination yields an $P$4-time algorithm for minimum $P$5-Hop Roman dominating set; the summary explicitly notes that Iwata’s polynomial-space $P$6 algorithm transfers in this way (Das et al., 28 Feb 2026).

3. Hop-constrained network design and tree embeddings

Hop constraints also define a major line of work in network design. In the Hop-Constrained Steiner-Tree Problem, one is given an undirected graph $P$7 with positive edge costs, a root $P$8, a set of terminals $P$9, and a hop-limit $\sum_{e\in P}\ell_e\le H$0. The objective is a minimum-cost subtree spanning $\sum_{e\in P}\ell_e\le H$1 and all terminals such that the number of edges on the unique $\sum_{e\in P}\ell_e\le H$2-to-$\sum_{e\in P}\ell_e\le H$3 path is at most $\sum_{e\in P}\ell_e\le H$4 for every included vertex $\sum_{e\in P}\ell_e\le H$5. When $\sum_{e\in P}\ell_e\le H$6, this becomes the Hop-Constrained Minimum Spanning-Tree Problem (Jabrayilov, 2020).

A central structural obstacle is that hop-constrained distances are far from being a metric. For a complete weighted graph $\sum_{e\in P}\ell_e\le H$7 and hop bound $\sum_{e\in P}\ell_e\le H$8, the $\sum_{e\in P}\ell_e\le H$9-hop-constrained distance is

$r$0

This quantity is symmetric and nonnegative, but may violate the triangle inequality. The key advance of the tree-embedding line is that $r$1 can nevertheless be approximated by distributions over partial tree metrics with bounded exclusion probability, bounded hop-stretch, and polylogarithmic expected stretch. The embedding theorem in “Tree Embeddings for Hop-Constrained Network Design” yields a randomized polynomial-time algorithm producing well-separated partial tree metrics with exclusion-probability at most $r$2, worst-case approximation $r$3, and induced expected stretch $r$4 (Haeupler et al., 2020).

This embedding perspective supports bicriteria approximations. Chekuri–Jain formulate a path-based LP with edge variables $r$5 and path variables $r$6 over all simple $r$7-$r$8 paths of length at most $r$9. From this LP they obtain, for hop-constrained Steiner forest, a randomized $H$0-approximation, and for hop-constrained set connectivity, a $H$1-approximation. Their buy-at-bulk reduction yields an $H$2 approximation with respect to the natural LP, and they also obtain polylogarithmic bicriteria approximations for fault-tolerant variants, including a randomized $H$3 bicriteria guarantee in the single-source setting for fixed $H$4 (Chekuri et al., 2024).

At the modeling level, Jabrayilov’s comparison between assignment-based and partial-ordering-based ILPs for HSTP isolates a polyhedral difference. If $H$5 and $H$6 denote the projections of the two LP relaxations onto the arc variables, then

$H$7

and the inclusion is strict for some instances. On 216 standard HMSTP/HSTP benchmark instances, the partial-ordering model solved approximately $H$8 instances to optimality within a 10 h limit, whereas the assignment model solved only approximately $H$9 (Jabrayilov, 2020). This supports the more general conclusion that hop constraints are not merely added side conditions; they often determine the geometry of the relaxation itself.

4. Multi-hop retrieval, relation extraction, and graph representation learning

In open-domain QA, HopRetriever defines a hop as a pair

$d_G(u,v)=r$0

where $d_G(u,v)=r$1 is a hyperlink mention in document $d_G(u,v)=r$2 pointing from entity $d_G(u,v)=r$3 to entity $d_G(u,v)=r$4, and $d_G(u,v)=r$5 is the outbound document for $d_G(u,v)=r$6. The system encodes the mention embedding and document embedding separately with BERT, fuses them with attention weights $d_G(u,v)=r$7, retrieves iteratively from top-500 TF–IDF candidates with beam search size 8, and updates an RNN state across hops. On HotpotQA full-wiki dev, HopRetriever improves over PathRetriever from $d_G(u,v)=r$8 to $d_G(u,v)=r$9 on top-$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$00 “Ans exists,” from $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$01 to $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$02 on “Sent exists,” and from $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$03 to $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$04 on “All docs exist.” Its interpretability is quantified through the structured-vs-unstructured fusion weights: on bridging questions the average weights are $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$05, $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$06, while on comparison questions they are $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$07, $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$08 (Li et al., 2020).

For knowledge-based question answering, UHop uses “one hop” to mean a single KG relation traversal. Instead of exhaustive search over all one-hop, two-hop, and up-to-$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$09-hop chains, it adopts a transition-based search in which the model selects one relation at a time and halts when the score of the last chosen relation exceeds the score of any continuation. The resulting complexity is $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$10, compared with $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$11 for exhaustive chain-based search. On WebQSP, where the average out-degree is approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$12, the paper notes that exhaustive 2-hop search examines approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$13 chains, whereas UHop inspects on average approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$14 candidates, a reduction of more than $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$15 (Chen et al., 2019).

Graph representation learning uses hops as layers of neighborhood aggregation. HHR-GNN computes hop-specific embeddings $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$16 and learns node-specific relation scores between the central node’s 0-hop embedding and its $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$17-hop embeddings through a Neural Tensor Network, thereby producing a personalized receptive field. The model reports competitive performance on five benchmarks and is described as “up to 13K faster in terms of time cost per training epoch on large heterogeneous graphs” than Graph Transformer Networks (Zhang et al., 2020). HOPF, by contrast, studies deep collective classification and diagnoses “Node Information Morphing,” the exponential dilution of the original node features across many propagation layers. Its Node Information Preserving formulation injects $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$18 into every layer, and its iterative inference mechanism uses only $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$19 differentiable layers per iteration while reaching an effective $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$20 hops with memory $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$21 rather than $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$22. On 11 datasets, NIP-MEAN outperforms its WL counterparts on 9/11 datasets with Wilcoxon $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$23; I-NIP-MEAN has average shortfall approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$24, and on inductive PPI it achieves $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$25 micro-F1 versus $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$26 for GCN-MEAN and $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$27 for the neighbor-only baseline (Vijayan et al., 2018).

5. HOP as a continual reinforcement learning architecture

In continual reinforcement learning, HOP stands for Hierarchical Orchestra of Policies. The method targets catastrophic forgetting by maintaining a modular set of policy checkpoints and dynamically combining them on the basis of observation similarity, without requiring explicit task labels. Each frozen checkpoint $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$28 stores a set $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$29 of trusted states collected from trajectories whose return exceeds a reward threshold $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$30. Given the current state $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$31, HOP finds the most similar stored state by cosine similarity, activates checkpoint $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$32 if the similarity exceeds a threshold $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$33, and combines the current policy with all activated frozen policies through hierarchical weights

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$34

so that more recent policies receive greater influence when they activate (Cannon et al., 2024).

The hierarchy grows by freezing the current policy at fixed intervals of training steps $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$35. During training, the agent samples actions from the joint policy $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$36, stores $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$37 in a replay buffer, and updates the current policy and value function via PPO using the stored activations. The summary states that gradients back-propagate through $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$38 always, and through each frozen $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$39 only for states where $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$40, so module refinement is selective rather than global (Cannon et al., 2024).

The empirical evaluation uses Procgen benchmarks—Ninja, StarPilot, Climber, and CoinRun—with 30 sequential levels, $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$41 RGB frames, and 15 discrete actions. Training proceeds in three 3 M-step phases over a 9 M-step total schedule: Env$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$42, then Env$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$43, then back to Env$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$44. Relative to PPO, HOP shortens recovery on StarPilot$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$45Climber$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$46StarPilot from $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$47 M to $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$48 M steps, a $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$49 reduction; on Ninja$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$50CoinRun$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$51Ninja it reduces steps-to-return from $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$52 M to $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$53 M, a $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$54 drop. Final returns also improve: for StarPilot–Climber, PPO reaches $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$55, HOP $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$56, and PNN $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$57; for Ninja–StarPilot, PPO reaches $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$58, HOP $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$59, and PNN $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$60 (Cannon et al., 2024).

The paper emphasizes that HOP matches or outperforms Progressive Neural Networks in most settings despite not using task labels. It also identifies limitations: the similarity threshold $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$61 and reward threshold $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$62 require tuning, and immediate performance drops after environment switches indicate remaining adaptation latency (Cannon et al., 2024).

6. HOP in continual learning for NLP

A second framework named HOP appears in continual NLP, where it denotes a method that “permits to hop across tasks and domains” through three components: adapters inserted into a frozen BERT encoder, high-order moments over token embeddings, and auxiliary heads specialized for each end problem. At each incremental step, a new set of bottleneck adapters is allocated and previous adapters remain frozen; the BERT backbone is frozen throughout. This isolates new parameters in $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$63 space per problem while allowing forward transfer by initialization from the previous adapters (Michieli et al., 2024).

The distinctive pooling mechanism computes central moments over the distribution of token embeddings. If $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$64 are the token vectors and

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$65

then the $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$66-th central moment vector is

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$67

with the power taken element-wise. The pooled representation is the concatenation $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$68. This is then processed by a two-layer MLP head; in Task-IL there is one head per task, whereas in Domain-IL a single head is updated across domains (Michieli et al., 2024).

The training objective is standard cross-entropy on the current dataset $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$69, with only the current adapters and corresponding head trainable:

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$70

The paper explicitly states that no extra regularizer is needed, because freezing prior parameters and isolating new adapters already acts as a stability constraint (Michieli et al., 2024).

The evaluation spans four NLP applications, five benchmarks, and both Task-IL and Domain-IL setups: aspect-level sentiment classification, document-level sentiment classification, topic classification on 20News, and natural language inference on MultiNLI. On DSC-small, HOP reaches $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$71 mean accuracy in TIL versus $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$72 for CTR, and $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$73 in DIL versus $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$74 for CTR. Across the five benchmarks and two setups, the summary reports that HOP yields the highest average mean accuracy and Macro-F1, with forgetting near $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$75. The parameter overhead is described as only approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$76 more total parameters and approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$77 more per-task training time than plain Adapter-BERT fine-tuning (Michieli et al., 2024).

The ablations attribute much of the gain to moment order. On DSC-small, [CLS] pooling performs worst at about $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$78 TIL mean accuracy; AVG pooling rises to about $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$79; HOP with $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$80 already beats AVG+MAX; and $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$81 is optimal, while $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$82 degrades slightly. Measured by Wasserstein distance between task feature distributions, the first moment has average distance about $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$83, the second about $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$84, the third about $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$85, and the fourth about $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$86, which motivates the use of moments up to order three (Michieli et al., 2024).

7. Hop-by-hop systems in routing, localization, and quantum communication

In communication systems, hop-by-hop design often replaces global shortest-path logic by local decisions informed by congestion or physical constraints. CARP, a hop-by-hop congestion-aware routing protocol for heterogeneous MANETs, assigns each one-hop link from node $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$87 to node $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$88 a weight

$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$89

where link quality $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$90 is derived from received RTS signal strength, $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$91 under IEEE 802.11 DCF, $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$92, and $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$93 is estimated by sending $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$94 dummy packets along an $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$95-hop path. End-to-end route cost is the sum of these weights, and the source selects the route of minimum total cost. In NS-2 simulations against AOMDV, CARP yields a 10–20% throughput improvement, roughly 15–25% fewer packet drops, packet-delivery ratio around $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$96 or above versus approximately $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$97–$$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$98, and end-to-end delay reductions of up to $$d_G(u,v)=\text{length of a shortest path between }u,v\text{ in }G,$$99 (0907.5441).

In IoT localization, Shen and Wang propose Distance-Based Connectivity Consistency as a hop-loss model for DV-Hop. The activation condition checks only first-order connectivity consistency,

$N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$00

exactly when $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$01, and the individual loss is the continuous penalty $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$02. The resulting DCC loss eliminates repeated predicted hop-count recomputation, has per-candidate complexity $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$03 instead of $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$04, and is proved to have full coverage of hop errors: if $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$05, then some node pair on a shortest path must activate the loss. Across 96 scenario combinations, DCC is on average 10–20% more accurate than DEMN-DV-Hop and reduces total computation time by 30–40%; for random topology with $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$06 anchors and $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$07 m, mean localization error drops from $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$08 to $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$09 (Shen et al., 2024).

In quantum networking, HOPPER extends the hop-by-hop idea to entanglement distribution in asynchronous repeater chains. The protocol removes global slots, lets links generate EPRs and repeaters swap immediately upon availability, and makes autonomous hop-by-hop decisions over local memory resources. In a homogeneous chain with memory size $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$10, entanglement-generation rate $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$11, and link success probability $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$12, the summary gives an approximate steady-state throughput

$N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$13

with startup delay approximately $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$14, whereas a synchronous alternative is upper-bounded by $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$15 and its slot length grows with path length. Numerical simulations show that in a long-distance regime with $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$16 km per link, $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$17 Hz decoherence, and $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$18 Hz, synchronous performance tops out at about $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$19 ebits/s for any memory $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$20, while HOPPER saturates at about $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$21 ebits/s once $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$22 and 30 concurrent application requests are present; fidelity remains higher by $N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$23–$N_r(x)=\{\,y\in V:d_G(x,y)=r\}.$24 (Cicconetti, 15 May 2026).

Taken together, these systems show that hop-by-hop design is not limited to abstract graph problems. It also governs local control in classical routing, continuous surrogates for discrete hop inconsistencies in localization, and asynchronous resource arbitration in quantum repeater networks. This suggests a recurring engineering pattern: replacing globally synchronized or exhaustive computations by local hop-level decisions can improve scalability, but the form of the gain depends on the domain-specific objective—throughput and delay in MANETs, localization error and runtime in IoT, or end-to-end ebit rate and fidelity in quantum networks.