GreedyTensile Routing: A Knowledge-Guided Approach

• GreedyTensile routing is a local packet-forwarding policy that combines distance-to-destination and node stretch within a knowledge-guided framework for near-optimal routing.
• It employs a deep neural network whose learned neighbor rankings are distilled into a symbolic two-linear-action rule for explainable and ultra-low-latency decisions.
• Empirical results demonstrate that GreedyTensile outperforms traditional greedy forwarding on both Euclidean and hyperbolic graphs while ensuring efficient recovery and stability.

GreedyTensile routing is a local packet-forwarding policy introduced in "Knowledge-Guided Machine Learning for Stabilizing Near-Shortest Path Routing" (Chen et al., 8 Sep 2025). It is designed for the all-pairs near-shortest path problem on geometric random graphs in Euclidean metric spaces, where each node forwards a packet using only its own state and the states of neighboring nodes. The policy emerges from a knowledge-guided machine-learning framework in which deep neural networks (DNNs) are trained on a small number of samples from a single seed graph and then distilled into a symbolic rule. In the formulation reported in the paper, GreedyTensile uses both distance-to-destination and node stretch as input features; the resulting policy almost always outperforms greedy forwarding, while remaining explainable and ultra-low-latency at run time (Chen et al., 8 Sep 2025).

1. Problem setting and core definitions

The underlying setting is geometric routing over wireless graphs, with packets sent from an origin $O$ to a destination $D$. The Euclidean distance between nodes $u$ and $t$, with Cartesian coordinates $(x_u,y_u)$ and $(x_t,y_t)$, is defined as

$d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$

For an origin-destination pair $(O,D)$, the shortest-path length in the wireless graph is denoted $d_{sp}(O,D)$, computed by A* or Dijkstra, and the straight-line distance is $d_e(O,D)=d(O,D)$. The end-to-end path stretch is then

$D$0

A central local feature in GreedyTensile is node stretch. For a packet currently at node $D$1 en route from $D$2 to $D$3, node stretch is

$D$4

If $D$5 lies exactly on the straight line $D$6, then $D$7. This feature is local in the sense used by the paper: it is computed for the current forwarding context and becomes part of the per-neighbor ranking criterion (Chen et al., 8 Sep 2025).

These definitions position GreedyTensile between purely geometric forwarding and learned policy optimization. Distance-to-destination captures immediate geometric progress, whereas node stretch encodes how a candidate hop sits relative to the origin-destination geometry. A plausible implication is that the policy is intended to suppress locally attractive but globally destabilizing moves by augmenting raw distance reduction with a geometric regularizer.

2. Knowledge-guided feature design and DNN policy representation

At each forwarding node $D$8, the method constructs, for each neighbor $D$9, a joint feature vector

$u$0

where

$u$1

and

$u$2

Thus the full GreedyTensile input has $u$3 dimensions. The paper also reports a simpler $u$4 variant using only the two distances $u$5, and one of those distance-only DNNs exactly matches the well-known Greedy Forwarding policy (Chen et al., 8 Sep 2025).

In practice, the two feature components are each scaled to $u$6 by dividing by the maximum communication radius or by the maximum observed stretch in the seed graph. The DNN topology is specified as follows:

• input layer of dimension $u$7 or $u$8;
• two fully connected hidden layers;
• layer 1 with $u$9 neurons and ReLU activations;
• layer 2 with $t$0 neurons and ReLU activations;
• output layer with one linear neuron.

The network computes

$t$1

where $t$2 is an estimate of cumulative negative path-length reward from $t$3 via neighbor $t$4. The forwarding decision is

$t$5

The paper characterizes this design as knowledge-guided machine learning because network domain knowledge is used both in selecting the features and in shaping the policy function. The stated objective is an approximately optimal policy that generalizes from a small amount of data taken from a single seed graph.

3. GreedyTensile as a symbolic two-linear-action policy

A defining property of GreedyTensile is that the learned four-feature DNN admits a low-complexity symbolic interpretation. After training, the DNN surface

$t$6

is reported to be well approximated by two affine planes separated by a linear guard (Chen et al., 8 Sep 2025).

The guard is

$t$7

The corresponding piecewise metric is

$t$8

GreedyTensile forwarding then selects

$t$9

In operational terms, a node loops over its neighbors, computes $(x_u,y_u)$0, $(x_u,y_u)$1, and $(x_u,y_u)$2, evaluates $(x_u,y_u)$3, applies the corresponding affine branch, and forwards to the neighbor with the largest metric. If no next hop is selected, the pseudocode invokes recovery, for example DFS in an elliptical region.

This symbolic representation is significant because it converts a learned ranking function into an explicit decision rule with very low arithmetic cost. The paper states that the symbolic policy needs fewer than 10 multiplies/adds per neighbor, whereas the DNN requires approximately $(x_u,y_u)$4 multiplies. The result is not merely a compression of the network; it is an interpretable decomposition into two linear actions with a linear switching condition.

4. Theoretical formulation and generalization claims

The routing problem is formalized as an MDP in which each state-action pair $(x_u,y_u)$5 yields reward

$(x_u,y_u)$6

This reward penalizes path length while enforcing the near-shortest path criterion through the stretch-dependent term (Chen et al., 8 Sep 2025).

The paper reports several theoretical statements about learnability and transfer:

• Learnability (Theorem 1): any ranking metric $(x_u,y_u)$7 that is pointwise-monotonic and has the RankPres property with respect to optimal $(x_u,y_u)$8 can be realized by a DNN trained on a subset of node samples.
• Cross-node generalizability (Lemma 2): if $(x_u,y_u)$9 matches $(x_t,y_t)$0-rankings for almost all neighbors at nodes in a single seed graph, one can learn $(x_t,y_t)$1 on just those node-neighborhood samples and achieve near-optimal forwarding everywhere in that graph.
• Cross-graph generalizability (Lemma 3): if the same $(x_t,y_t)$2 has high ranking-similarity over a class $(x_t,y_t)$3 of random Euclidean graphs, and later hyperbolic graphs, then a policy trained on one seed graph generalizes zero-shot to all graphs in $(x_t,y_t)$4.
• Concrete instantiation (Proposition 1): the linear forms

$(x_t,y_t)$5

and

$(x_t,y_t)$6

each satisfy the above conditions with high probability in uniform random Euclidean graphs.

These results place GreedyTensile within a ranking-based perspective on routing. Rather than requiring exact value prediction, the framework emphasizes preservation of neighbor orderings relative to $(x_t,y_t)$7. This suggests that the policy’s generalization behavior depends critically on stable local rankings across graph realizations, which is consistent with the paper’s reliance on a single seed graph and sparse node sampling.

5. Empirical behavior relative to greedy forwarding and related baselines

The empirical study compares four policies on Euclidean grids with $(x_t,y_t)$8 and density $(x_t,y_t)$9, over 80 random instances each (Chen et al., 8 Sep 2025). The compared policies are:

• GF: greedy forwarding by $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$0;
• SR-NS: symbolic regression pick $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$1;
• GT-RL: GreedyTensile learned by reinforcement learning;
• GT-S: GreedyTensile learned by supervised learning on a single seed graph of size $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$2 with $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$3, subsampling from $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$4 nodes.

Performance is reported as average APNSP prediction accuracy, defined as the fraction of origin-destination pairs routed within $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$5. For Euclidean graphs, the average accuracies are:

• at $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$6: GF $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$7, SR-NS $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$8, GT-RL $d(u,t)=\sqrt{(x_u-x_t)^2 + (y_u-y_t)^2}\,.$9, GT-S $(O,D)$0;
• at $(O,D)$1: GF $(O,D)$2, SR-NS $(O,D)$3, GT-RL $(O,D)$4, GT-S $(O,D)$5;
• at $(O,D)$6: GF $(O,D)$7, SR-NS $(O,D)$8, GT-RL $(O,D)$9, GT-S $d_{sp}(O,D)$0;
• at $d_{sp}(O,D)$1: GF $d_{sp}(O,D)$2, SR-NS $d_{sp}(O,D)$3, GT-RL $d_{sp}(O,D)$4, GT-S $d_{sp}(O,D)$5.

The paper highlights a maximum improvement of GT-S over GF of $d_{sp}(O,D)$6 at $d_{sp}(O,D)$7. It also reports that GT-RL closes most of this gap, with $d_{sp}(O,D)$8 at $d_{sp}(O,D)$9, without supervised labels. SR-NS outperforms GF in dense regimes but lags in sparse ones.

Beyond Euclidean graphs, the paper reports zero-shot transfer to hyperbolic graphs with average degree $d_e(O,D)=d(O,D)$0, where GT-S and GT-RL exceed GF by up to $d_e(O,D)=d(O,D)$1. The summary further characterizes this as generalization across both Euclidean and scale-free (hyperbolic) random graphs.

A common misconception would be to treat GreedyTensile as a minor perturbation of greedy forwarding. The reported results do not support that characterization. Greedy forwarding is recovered exactly only in the distance-only DNN variant, whereas the GreedyTensile policy uses distance and stretch jointly and shows systematically higher APNSP accuracy in the reported experiments.

6. Computational characteristics, stabilization, and recovery

GreedyTensile is explicitly framed as a local method. It needs only one round of local neighbor evaluation and uses no global state or flooding (Chen et al., 8 Sep 2025). This is central to its computational profile. The DNN implementation requires approximately

$d_e(O,D)=d(O,D)$2

multiplications per neighbor, whereas the symbolic two-plane policy requires fewer than 10 multiplies per neighbor, corresponding to an approximately $d_e(O,D)=d(O,D)$3 speedup.

The implementation notes go further and state that the symbolic policy performs fewer than 10 floating-point operations per candidate neighbor; even on a 100 MHz microcontroller, this is less than $d_e(O,D)=d(O,D)$4 per hop. The paper also describes the method as fully self-stabilizing: if topology changes, each node simply recomputes distances and stretches.

When a dead end is encountered, recovery uses DFS limited to an elliptical region $d_e(O,D)=d(O,D)$5. In practice this region is reported to be small, and the recovery cost is $d_e(O,D)=d(O,D)$6 in the local subgraph $d_e(O,D)=d(O,D)$7. The recovery mechanism is therefore bounded to a geometrically constrained neighborhood rather than a network-wide search.

These properties distinguish GreedyTensile from routing strategies that depend on global recomputation or message flooding. A plausible implication is that the policy is intended for environments where per-hop latency and local adaptability matter as much as path quality, especially under topology changes.

7. Position within knowledge-guided routing research

Within the scope defined by the paper, GreedyTensile exemplifies a specific synthesis: domain-guided feature engineering, DNN-based approximation of near-optimal neighbor rankings, and post hoc symbolic distillation into a concise decision rule (Chen et al., 8 Sep 2025). The framework begins with a seed-graph training regime, uses theoretical ranking-based conditions to justify generalization, and yields an executable policy that can be written in closed form.

The paper’s own comparison to greedy forwarding is especially instructive. A DNN trained with distance-to-destination as the only input feature exactly reproduces the classical policy that forwards to the neighbor with the shortest distance to the destination. GreedyTensile extends that paradigm by adding node stretch, thereby introducing a second geometric signal that can alter neighbor rankings when pure distance minimization is insufficient for near-shortest path behavior.

The symbolic form also clarifies why the policy is described as explainable. Its behavior can be interpreted through two linear actions separated by a linear guard, rather than through an opaque high-dimensional nonlinear map. For a research audience, this makes GreedyTensile notable not because it abandons learning, but because it turns a learned routing rule into a low-complexity analytic object whose structure remains tied to the underlying geometric features.