Learning-Based Informed Trees (LIT*)

• The paper demonstrates LIT*'s main contribution: co-adapting batch size (B) and neighbor count (k) via a learned deep fuzzy module for enhanced planning efficiency.
• LIT* leverages obstacle density metrics, deep fuzzy sets, and DDPG-based training to dynamically adjust parameters, outperforming fixed-parameter planners.
• The method achieves faster convergence and lower path costs in high-dimensional spaces, as confirmed by improved performance metrics across multiple benchmark domains.

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 (Zhang et al., 28 Aug 2025).

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)$ (Zhang et al., 28 Aug 2025).

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$0 only; LIT* is characterized as the first to co-adapt both parameters (Zhang et al., 28 Aug 2025).

The central modeling premise is obstacle-density awareness. The planner encodes both a global invalid ratio $k$1 and local invalid ratios $k$2 and $k$3. 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 $k$4, the set of collision-free samples, and $k$5, the set of collision samples. It then defines the invalid ratio

$k$6

This ratio is used in both global and local forms. The third observation is the Lebesgue measure $k$7 of the current informed subset, described in the source as the prolate ellipsoid (Zhang et al., 28 Aug 2025).

Each observation $k$8 is mapped into three Gaussian fuzzy sets, $k$9 (sparse), $\lambda(\hat X_f)$0 (medium), and $\lambda(\hat X_f)$1 (dense), using

$\lambda(\hat X_f)$2

The resulting nine membership values are concatenated into a $\lambda(\hat X_f)$3 fuzzy feature vector

$\lambda(\hat X_f)$4

This representation is the input to the learned actor modules B-Net and K-Net (Zhang et al., 28 Aug 2025).

Defuzzification is performed by a Takagi–Sugeno–Kang weighted sum,

$\lambda(\hat X_f)$5

where $\lambda(\hat X_f)$6 are firing strengths and $\lambda(\hat X_f)$7 are learned linear consequents. For B-Net, the scalar output is rounded to an integer batch size $\lambda(\hat X_f)$8. For K-Net, the output is a real weighting factor $\lambda(\hat X_f)$9. The actual neighbor count is then determined by the modified RGG expression

$B$0

where $B$1 is the space dimension and $B$2 (Zhang et al., 28 Aug 2025).

The learning objective is DDPG-based. With actor $B$3 and critic $B$4, the critic loss is

$B$5

and the actor loss is

$B$6

The source further distinguishes a reward $B$7 for B-Net, designed to encourage fast convergence and stable improvements, and a reward $B$8 for K-Net, designed to encourage short, direct paths (Zhang et al., 28 Aug 2025).

3. Planning procedure and learned control pipeline

The planning loop begins with $B$9, $\lambda(\hat X_f)$0, $\lambda(\hat X_f)$1, $\lambda(\hat X_f)$2, and $\lambda(\hat X_f)$3. At each iteration, the planner samples $\lambda(\hat X_f)$4 points, partitions them into new valid and invalid states, computes the global invalid ratio, computes local invalid ratios using a local neighborhood radius $\lambda(\hat X_f)$5 around the current tree path, and evaluates $\lambda(\hat X_f)$6 for the current informed subset. When expansion is needed, it looks up or predicts $\lambda(\hat X_f)$7, converts it into

$\lambda(\hat X_f)$8

and expands each tree node by its $\lambda(\hat X_f)$9 nearest neighbors in informed RRT* style. States outside the updated informed set are then pruned before the next iteration (Zhang et al., 28 Aug 2025).

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 $B$0D tensors, tensor_B and tensor_K, so that run-time queries for $B$1 and $B$2 become constant time. The source explicitly states an $B$3 lookup for both quantities after training (Zhang et al., 28 Aug 2025).

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 $B$4D kernels of sizes $B$5, $B$6, and $B$7 to produce $B$8 output channels, then passes the flattened representation through an MLP with layers $B$9 and ReLU activations. The output layer contains three neurons, one per defuzzification rule output, and the final scalar $k$0 is produced by TSK defuzzification. The critic uses the same base architecture but takes $k$1 as input and outputs a scalar $k$2. Training uses DDPG with prioritized experience replay, soft target updates with $k$3, and minibatch size $k$4 (Zhang et al., 28 Aug 2025).

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 (Zhang et al., 28 Aug 2025).

The same source summary also contains a differently worded interpretation in its “Key improvements” discussion, stating that “low $k$5 and large $k$6 help jump quickly toward the goal” in sparse regions and that “high $k$7 and small $k$8 help thread narrow passages” in cluttered regions. Taken together, these passages indicate a consistent high-level claim—namely, adaptive co-tuning of $k$9 and $k$0 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 $k$1 and $k$2 may depend on the specific local/global ratio inputs and the learned policy surface (Zhang et al., 28 Aug 2025).

This adaptive interpretation is also reflected in the reward design. The B-Net reward

$k$3

with

$k$4

is described as encouraging fast convergence and stable improvements. The K-Net reward

$k$5

is described as encouraging short, direct paths. In this formulation, $k$6 and $k$7 are not merely heuristic knobs; they are learned controls optimized for distinct but coupled planning objectives (Zhang et al., 28 Aug 2025).

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 $k$8 per insertion, dominated by nearest-neighbor search over $k$9 vertices. LIT* is reported to preserve the same $k$0 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 $k$1 table lookup for $k$2 and $k$3; 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 (Zhang et al., 28 Aug 2025).

The benchmark domains are Random Rectangles (RR) and Narrow Passage (NP) in $k$4, $k$5, and $k$6 within Planner Developer Tools, together with a dual-arm Barrett WAM manipulation task in $k$7 in OpenRAVE. The reported metrics include median initial solution time $k$8, median initial cost $k$9, and final cost $B$0 (Zhang et al., 28 Aug 2025).

Domain	FIT*	LIT*
RR–$B$1	$B$2 s, $B$3, $B$4	$B$5, $B$6, $B$7
RR–$B$8	$B$9, $k$00, $k$01	$k$02, $k$03, $k$04
RR–$k$05	$k$06, $k$07, $k$08	$k$09, $k$10, $k$11
NP–$k$12	$k$13, $k$14, $k$15	$k$16, $k$17, $k$18
NP–$k$19	$k$20, $k$21, $k$22	$k$23, $k$24, $k$25
NP–$k$26	$k$27, $k$28, $k$29	$k$30, $k$31, $k$32

From these results, the source highlights a $k$33 speed-up for RR–$k$34, $k$35 for RR–$k$36, $k$37 for RR–$k$38, $k$39 for NP–$k$40, $k$41 for NP–$k$42, and $k$43 for NP–$k$44. It also reports that, in the dual-arm $k$45 manipulation task, LIT* finds the first feasible dual-arm pick-and-place path in approximately $k$46 s versus $k$47 s for BIT*, with an average path-length reduction of approximately $k$48. 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 $k$49 of allotted time across all dimensions, especially in narrow passages (Zhang et al., 28 Aug 2025).

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 (Zhang et al., 28 Aug 2025). 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 $k$50 receives a predicted weight $k$51 and a composite priority

$k$52

with $k$53, in order to obtain depth bounds of order $k$54 and, with $k$55, static optimality (Chen et al., 2022).

The search-tree framework also extends to dynamic self-reorganization and B-tree analogues. Its working-set instantiation uses

$k$56

yielding expected access cost

$k$57

and total cost

$k$58

while supporting insertions, deletions, and prediction updates. In that setting, “LIT*” designates a learning-augmented search-tree scheme rather than a robot motion planner (Chen et al., 2022).

This naming overlap matters because both uses involve “trees,” “learning,” and “informed” behavior, but they address different technical objects. The motion-planning LIT* adapts $k$59 and $k$60 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.