---
title: Learning-Based Informed Trees (LIT*)
url: https://www.emergentmind.com/topics/learning-based-informed-trees-lit
type: topic
---

# Learning-Based Informed Trees (LIT*)

Searching arXiv for LIT* and closely related informed-tree motion planning papers.
Searching arXiv for "Learning-based Informed Trees" and adaptive informed-tree motion planning.
Learning-based Informed Trees (LIT*) denotes an asymptotically-optimal, single-query motion planner in the style of RRT* / Informed RRT*, but with its two most critical sampling-based parameters—the batch size $B$ and the number of nearest neighbors $k$—chosen on-the-fly by a learned “deep fuzzy” module. The method monitors obstacle density in the configuration space through valid and invalid samples, encodes both global and local ratios together with the Lebesgue measure $\lambda(\hat X_f)$ of the informed subset, and converts these observations into planning parameters by fuzzification, a DDPG-based actor, and Takagi–Sugeno–Kang defuzzification. The reported aim is to adapt exploration and rewiring behavior to obstacle distributions in high-dimensional spaces, yielding faster convergence and lower-cost paths than fixed-parameter baselines [2508.20884].

## 1. Position within informed sampling-based planning

LIT* is presented as a planner in the family of informed-tree methods, specifically in the style of RRT* / Informed RRT*. Its defining difference is that it does not keep the batch size $B$ or nearest-neighbor parameter fixed. Instead, it co-adapts both parameters during planning by using a learned scheduler conditioned on obstacle-density signals. In the source description, the planner constantly monitors how many of the last batch of samples were collision-free versus in collision, and it supplements these counts with local ratios and the informed-set measure $\lambda(\hat X_f)$ [2508.20884].

The comparative framing in the source places LIT* against RRT-Connect, Informed RRT*, BIT*, AIT*, EIT*, FIT*, and APT*. Within that comparison, fixed-parameter planners are described as being handicapped by static choices of $B$ and $k$: if $k$ is small, they may waste time re-wiring too few neighbors, whereas if $k$ is large, they may incur high nearest-neighbor cost. FIT* is described as adaptive in $B$ only, and APT* as adaptive in $k$ only; LIT* is characterized as the first to co-adapt both parameters [2508.20884].

The central modeling premise is obstacle-density awareness. The planner encodes both a global invalid ratio $\rho_{\mathrm{global}}$ and local invalid ratios $\rho_{\mathrm{local},B}$ and $\rho_{\mathrm{local},K}$. These quantities are intended to distinguish obstacle-sparse from obstacle-dense regions and thereby alter sampling and connection behavior accordingly. This suggests that LIT* should be understood less as a new graph-search principle than as a learned parameter-control layer wrapped around an informed asymptotically optimal planner.

## 2. Mathematical formulation

The planner partitions samples into
$X_{\mathrm{valid}}$, the set of collision-free samples, and
$X_{\mathrm{invalid}}$, the set of collision samples. It then defines the invalid ratio
$$
\rho = \frac{|X_{\mathrm{invalid}}|}{|X_{\mathrm{valid}}| + |X_{\mathrm{invalid}}|}.
$$
This ratio is used in both global and local forms. The third observation is the Lebesgue measure $\lambda(\hat X_f)$ of the current informed subset, described in the source as the prolate ellipsoid [2508.20884].

Each observation $o \in \{\rho_{\mathrm{global}}, \rho_{\mathrm{local}}, \lambda(\hat X_f)\}$ is mapped into three Gaussian fuzzy sets, $S$ (sparse), $M$ (medium), and $D$ (dense), using
$$
\mu_{o,i}(x) = \exp\!\left[ - \frac{(x-\theta_{o,i})^2}{2\sigma_{o,i}^2} \right], \qquad i=1\ldots 3.
$$
The resulting nine membership values are concatenated into a $9 \times 1$ fuzzy feature vector
$$
i = [ \mu_{o_1,1}(x_1), \mu_{o_1,2}(x_1), \mu_{o_1,3}(x_1), \mu_{o_2,1}(x_2), \ldots, \mu_{o_3,3}(x_3) ]^T.
$$
This representation is the input to the learned actor modules B-Net and K-Net [2508.20884].

Defuzzification is performed by a Takagi–Sugeno–Kang weighted sum,
$$
z^* = \frac{\sum_{j=1}^N w_j f_j}{\sum_{j=1}^N w_j},
$$
where $w_j$ are firing strengths and $f_j$ are learned linear consequents. For B-Net, the scalar output is rounded to an integer batch size $B \in [20 \ldots 200]$. For K-Net, the output is a real weighting factor $\psi_K \in [3.0 \ldots 15.0]$. The actual neighbor count is then determined by the modified RGG expression
$$
k(q) = \eta e \cdot \psi_K \cdot \left(1 + \frac{1}{n}\right) \cdot \log(|X_{\mathrm{valid}}|),
$$
where $n$ is the space dimension and $\eta \approx 1.1$ [2508.20884].

The learning objective is DDPG-based. With actor $\pi_\theta(s)$ and critic $Q_\phi(s,a)$, the critic loss is
$$
L_\phi = \frac{1}{m} \sum_{t \in \mathrm{batch}} \left[ r_t + \gamma Q_{\phi'}(s_{t+1}, \pi_{\theta'}(s_{t+1})) - Q_\phi(s_t,a_t) \right]^2,
$$
and the actor loss is
$$
L_\theta = -\frac{1}{m} \sum_{t \in \mathrm{batch}} Q_\phi(s_t, \pi_\theta(s_t)).
$$
The source further distinguishes a reward $R_B$ for B-Net, designed to encourage fast convergence and stable improvements, and a reward $R_K$ for K-Net, designed to encourage short, direct paths [2508.20884].

## 3. Planning procedure and learned control pipeline

The planning loop begins with
$X_{\mathrm{valid}}=\{x_{\mathrm{start}}\}$,
$X_{\mathrm{invalid}}=\varnothing$,
$E=\varnothing$,
$B=B_{\mathrm{init}} \in [20\ldots 200]$,
and $K=k_{\mathrm{init}}$.
At each iteration, the planner samples $B$ points, partitions them into new valid and invalid states, computes the global invalid ratio, computes local invalid ratios using a local neighborhood radius $r(q)$ around the current tree path, and evaluates $\lambda(\hat X_f)$ for the current informed subset. When expansion is needed, it looks up or predicts $\psi_K$, converts it into
$$
k = \eta e \cdot \psi_K \cdot \left(1 + \frac{1}{n}\right) \cdot \log(|X_{\mathrm{valid}}|),
$$
and expands each tree node by its $k$ nearest neighbors in informed RRT* style. States outside the updated informed set are then pruned before the next iteration [2508.20884].

A notable systems-level detail is the separation between training-time inference and run-time deployment. When `trainingMode=true`, the ratios are sent to the online DDPG network. After training, the continuous policy outputs are pre-discretized into two $3$D tensors, `tensor_B` and `tensor_K`, so that run-time queries for $B$ and $\psi_K$ become constant time. The source explicitly states an $O(1)$ lookup for both quantities after training [2508.20884].

The network architecture is described as a deep fuzzy module. Fuzzification maps three scalars to nine Gaussian membership values. The actor network, either B-Net or K-Net, takes the 9-dimensional fuzzy vector as input, applies a convolutional layer with three $1$D kernels of sizes $3$, $5$, and $7$ to produce $9$ output channels, then passes the flattened representation through an MLP with layers $[64,128,128,64,32]$ and ReLU activations. The output layer contains three neurons, one per defuzzification rule output, and the final scalar $z^*$ is produced by TSK defuzzification. The critic uses the same base architecture but takes $[state_s; action_{z^*}]$ as input and outputs a scalar $Q(s,a)$. Training uses DDPG with prioritized experience replay, soft target updates with $\tau \approx 10^{-3}$, and minibatch size $m$ [2508.20884].

## 4. Adaptive behavior and interpretation

The operational claim of LIT* is that obstacle distributions should govern both the number of fresh samples and the aggressiveness of neighborhood expansion. The source states that, because the network is trained offline on many different obstacle-density scenarios, LIT* automatically selects small batches and large neighborhoods in sparse regions, and large batches and small neighborhoods in cluttered regions. This is presented as the mechanism by which the planner can drive quickly toward the goal in sparse space while exploring around narrow passages in dense space [2508.20884].

The same source summary also contains a differently worded interpretation in its “Key improvements” discussion, stating that “low $k$ and large $B$ help jump quickly toward the goal” in sparse regions and that “high $k$ and small $B$ help thread narrow passages” in cluttered regions. Taken together, these passages indicate a consistent high-level claim—namely, adaptive co-tuning of $B$ and $k$ in response to obstacle density—but they do not present a completely uniform directional description of how the two parameters move in every regime. A plausible implication is that the primary contribution lies in the learned coupling between obstacle-density statistics and parameter selection, whereas exact monotonic trends for $B$ and $k$ may depend on the specific local/global ratio inputs and the learned policy surface [2508.20884].

This adaptive interpretation is also reflected in the reward design. The B-Net reward
$$
R_B = \alpha_B \cdot \frac{\kappa}{t} + \beta_B \cdot \frac{\kappa}{c(\xi)} - \gamma_B \cdot n_{\mathrm{update}},
$$
with
$$
\kappa(n_{\mathrm{update}})=\max(\nu_{\min}, \nu \cdot \log_2(6.8 - n_{\mathrm{update}})),
$$
is described as encouraging fast convergence and stable improvements. The K-Net reward
$$
R_K = \alpha_K \cdot \frac{1}{t} + \beta_K \cdot \frac{1}{c(\xi)} + \gamma_K \cdot |\xi|
$$
is described as encouraging short, direct paths. In this formulation, $B$ and $k$ are not merely heuristic knobs; they are learned controls optimized for distinct but coupled planning objectives [2508.20884].

## 5. Complexity, benchmarks, and reported performance

The asymptotic complexity discussion begins from the standard informed-tree baseline: the core planning step in RRT* / Informed RRT* is stated as $O(n \log n)$ per insertion, dominated by nearest-neighbor search over $N$ vertices. LIT* is reported to preserve the same $O(N \log N)$ scaling, but with smaller constant factors than BIT*, AIT*, FIT*, or Informed RRT* when obstacle density varies. The added overhead after training is described as only the $O(1)$ table lookup for $B$ and $K$; communication between the C++ planner and the Python-based DDPG during training can be significant, but the two 3D lookup tensors incur no extra asymptotic cost at run time [2508.20884].

The benchmark domains are Random Rectangles (RR) and Narrow Passage (NP) in $\mathbb{R}^4$, $\mathbb{R}^8$, and $\mathbb{R}^{16}$ within Planner Developer Tools, together with a dual-arm Barrett WAM manipulation task in $\mathbb{R}^{14}$ in OpenRAVE. The reported metrics include median initial solution time $t^{\mathrm{med}}_{\mathrm{init}}$, median initial cost $c^{\mathrm{med}}_{\mathrm{init}}$, and final cost $c^{\mathrm{med}}_{\mathrm{final}}$ [2508.20884].

| Domain | FIT* | LIT* |
|---|---|---|
| RR–$\mathbb{R}^4$ | $t=0.0626$ s, $c_{\mathrm{init}}=2.3295$, $c_{\mathrm{final}}=1.9951$ | $t=0.0597$, $1.0621$, $1.8383$ |
| RR–$\mathbb{R}^8$ | $0.1247$, $3.7650$, $3.1704$ | $0.1114$, $3.1188$, $2.8034$ |
| RR–$\mathbb{R}^{16}$ | $0.2778$, $6.2709$, $4.2460$ | $0.2385$, $4.9677$, $3.9552$ |
| NP–$\mathbb{R}^4$ | $0.0084$, $1.3681$, $0.5395$ | $0.0060$, $1.1506$, $0.5096$ |
| NP–$\mathbb{R}^8$ | $0.0291$, $2.7310$, $2.0761$ | $0.0217$, $2.5802$, $1.9441$ |
| NP–$\mathbb{R}^{16}$ | $0.0383$, $4.7280$, $3.8258$ | $0.0262$, $4.0591$, $2.9497$ |

From these results, the source highlights a $4.6\%$ speed-up for RR–$\mathbb{R}^4$, $10.7\%$ for RR–$\mathbb{R}^8$, $14.1\%$ for RR–$\mathbb{R}^{16}$, $28.6\%$ for NP–$\mathbb{R}^4$, $25.4\%$ for NP–$\mathbb{R}^8$, and $31.6\%$ for NP–$\mathbb{R}^{16}$. It also reports that, in the dual-arm $\mathbb{R}^{14}$ manipulation task, LIT* finds the first feasible dual-arm pick-and-place path in approximately $0.45$ s versus $0.75$ s for BIT*, with an average path-length reduction of approximately $12\%$. Final smoothing is said to bring both planners near-optimal, but LIT* is reported to converge faster. The cost-time convergence curves are described as showing the cost dropping more steeply during the first $20\%$ of allotted time across all dimensions, especially in narrow passages [2508.20884].

## 6. Nomenclature and distinction from learning-augmented search trees

The acronym “LIT*” is not unique across arXiv. In robot motion planning, it refers to the learning-based informed-tree planner described above, which uses deep fuzzy learning to select batch size and nearest-neighbor parameters inside an informed asymptotically optimal planner [2508.20884]. In a distinct data-structure context, a related acronym is used for a “Learning-Augmented Informed Trees” framework instantiated by composite-priority Treaps and B-Treaps, where each key $x$ receives a predicted weight $w_x$ and a composite priority
$$
\pi_x = -\lfloor \log_2 \log_2 (1/w_x) \rfloor + \delta_x,
$$
with $\delta_x \sim \mathrm{Unif}(0,1)$, in order to obtain depth bounds of order $O(\log_2(1/w_x))$ and, with $w_x=f_x/m$, static optimality [2211.09251].

The search-tree framework also extends to dynamic self-reorganization and B-tree analogues. Its working-set instantiation uses
$$
w_{i,x}=\frac{1}{(1+I(i,x))^2},
$$
yielding expected access cost
$$
O(\log_B(1+I(i,x(i))))
$$
and total cost
$$
O\!\left(n\log_B n + \sum_{i=1}^m \log_B(1+I(i,x(i)))\right),
$$
while supporting insertions, deletions, and prediction updates. In that setting, “LIT*” designates a learning-augmented search-tree scheme rather than a robot motion planner [2211.09251].

This naming overlap matters because both uses involve “trees,” “learning,” and “informed” behavior, but they address different technical objects. The motion-planning LIT* adapts $B$ and $k$ under obstacle-density observations in configuration spaces; the search-tree LIT* assigns priorities derived from predicted item weights to obtain entropy-sensitive and working-set-sensitive access costs. The shared acronym therefore should not be taken to imply methodological identity between the two lines of work.

Source: https://www.emergentmind.com/topics/learning-based-informed-trees-lit