Trajectory Trees: Hierarchical Motion & Data Structures

• Trajectory Trees are hierarchical structures organizing trajectories into branches, each encoding motion, decision, and prediction semantics.
• They enable efficient kinodynamic planning, uncertainty-aware decision making, and multimodal future prediction across varied domains.
• Applications span robotics motion planning, interpretable pedestrian forecasting, and high-speed spatiotemporal data retrieval through optimized indexing.

Trajectory trees are tree-structured representations in which trajectories, trajectory segments, or trajectory-derived keys are organized hierarchically. In the literature, the term does not denote a single canonical object. In kinodynamic planning, it refers to search trees whose nodes are system states and whose edges are dynamically feasible trajectory segments (Ye et al., 2021). In uncertainty-aware planning, it may denote one Monte Carlo Tree Search tree per sampled start state, or a pair of aligned trees for ego actions and environment responses (Stegmaier et al., 2022, Chen et al., 2023). In prediction, a root-to-leaf path can encode a multimodal future, a recursive sequence of sub-goals, or an interpretable intention hypothesis (Shi et al., 2022, Jurgenson et al., 2019, Zhang et al., 18 Nov 2025). In data management, trajectory trees appear as hierarchical indexes, compressed snapshot structures, or tries over trajectory sketches (Schoemans et al., 2024, Bernardo et al., 2016, Kanda et al., 2020). The common feature is hierarchical branching over motion, but the semantics of nodes, edges, and branching vary substantially by domain.

1. Structural interpretations across domains

Across the surveyed work, trajectory trees serve at least four distinct roles: executable motion search, contingent decision structure, multimodal prediction scaffold, and data-management index. This plurality is explicit in the formal definitions used by the papers, rather than being a matter of informal terminology (Ye et al., 2021, Stegmaier et al., 2022, Chen et al., 2023, Shi et al., 2022, Schoemans et al., 2024).

Setting	What the tree stores	Meaning of branching
Kinodynamic planning	States and dynamically feasible trajectory segments	Alternative expansions or local deformations
Uncertainty-aware planning	Belief-sample trees, scenario trees, or observation-contingent branches	Distinct hypotheses, sampled start states, or future responses
Prediction	Motion primitives, sub-goals, or intention prototypes	Multimodal future behaviors
Indexing and retrieval	Bounding predicates, snapshots, compressed logs, or sketch prefixes	Hierarchical partitioning for pruning and lookup

In kinodynamic motion planning, the tree is a state-space search structure. In "STD-Trees: Spatio-temporal Deformable Trees for Multirotors Kinodynamic Planning" (Ye et al., 2021), nodes are multirotor states and edges are LQMT trajectory segments with associated control and duration. In "Train-Once Plan-Anywhere Kinodynamic Motion Planning via Diffusion Trees" (Hassidof et al., 28 Aug 2025), edges are short propagated subtrajectories produced by applying a learned action sequence to the true dynamics. In "Model Predictive Trees: Sample-Efficient Receding Horizon Planning with Reusable Tree Search" (Lathrop et al., 2024), a finite-horizon UCT tree is rebuilt and re-rooted at each MPC iteration.

In uncertainty-aware planning, the tree may no longer be a single forward rollout of physical state. In "Cooperative Trajectory Planning in Uncertain Environments with Monte Carlo Tree Search and Risk Metrics" (Stegmaier et al., 2022), a trajectory tree is the MCTS tree rooted at one sampled start state from a root belief, and the planner builds multiple such trees. In "Tree-structured Policy Planning with Learned Behavior Models" (Chen et al., 2023), an ego trajectory tree and a scenario tree are coupled stage by stage. In "Optimizing Trajectory-Trees in Belief Space" (Phiquepal et al., 3 May 2026), a trajectory-tree alternates deterministic trajectory stages and probabilistic belief-update stages.

Prediction papers use trees differently. In "Social Interpretable Tree for Pedestrian Trajectory Prediction" (Shi et al., 2022), a root-to-leaf path corresponds to a coarse candidate future defined by motion primitives such as forward, left-turn, and right-turn. In the sub-goal-tree framework (Jurgenson et al., 2019, Jurgenson et al., 2020), internal nodes recursively split a start-goal segment by predicting midpoints. In "Unified Multimodal Vessel Trajectory Prediction with Explainable Navigation Intention" (Zhang et al., 18 Nov 2025), branches correspond to sustained intention prototypes and leaves arise from transient latent sampling.

Database papers treat trajectory trees as indexes rather than plans. "Multi-Entry Generalized Search Trees for Indexing Trajectories" (Schoemans et al., 2024) uses multi-entry GiST and SP-GiST structures, "A new method to index and store spatio-temporal data" (Bernardo et al., 2016) uses a $k^2$-tree over spatial snapshots plus compressed movement logs, "GraCT" (Brisaboa et al., 2016) combines $k^2$-tree snapshots with grammar-compressed logs, and "Succinct Trit-array Trie for Scalable Trajectory Similarity Search" (Kanda et al., 2020) organizes LSH sketches of trajectories in succinct tries.

2. Kinodynamic planning and control

In kinodynamic planning, trajectory trees are central because they simultaneously encode reachability, dynamics, and cost. STD-Trees formalize this explicitly through deformation units consisting of one node and all incident edges, with decision variables given by the node state $\mathbf{x}_n$ and the durations of the incoming and outgoing edges $\mathbf{T}_n$ (Ye et al., 2021). The local objective is a weighted sum of edge costs over the corresponding sub-tree, using path-count weights $d_i$, plus soft penalties for obstacle avoidance and dynamical limits. For multirotors, the paper uses differential flatness, a third-order integrator model with $s=3$, jerk control, and polynomial edge parameterization. A notable feature is that optimization is both spatial and temporal: the node location and the edge durations are adjusted together, and the resulting non-smooth problem is solved with LMBM because distance-field interpolation is non-smooth (Ye et al., 2021).

Algorithmically, STD-Trees insert deformation into an RRT-style loop after the first feasible solution is found. The paper defines NODE, TRUNK, BRANCH, and TREE variants, followed by cascade rewiring in the style of RRT$^\#$ (Ye et al., 2021). The reported results show that all variants converge much faster than the no-deformation baseline, that BRANCH slightly outperforms TREE, and that spatio-temporal deformation outperforms spatial-only deformation across kRRT, kRRT*, and kRRT$^\#$ (Ye et al., 2021). The paper further argues that local deformation preserves the current homotopy class of a root-to-leaf path unless the optimized state opens a better local corridor within that class.

Diffusion-guided tree growth replaces local optimization with learned action sampling. DiTree plugs a conditional diffusion or flow-matching policy into the action-selection step of an RRT-like planner and samples short action sequences conditioned on the expansion node, a relative target, and a local occupancy grid (Hassidof et al., 28 Aug 2025). The tree remains a standard kinodynamic search tree: forward propagation uses the given dynamics, and every edge is accepted only after collision checking. The paper proves probabilistic completeness under Lipschitz dynamics and a full-support action sampler, with failure probability bounded by $a e^{-bk}$, and safety follows from collision checking of every propagated edge (Hassidof et al., 28 Aug 2025). Empirically, DiTree is reported as on average $3\times$ faster than classical SBPs and as achieving roughly $k^2$0 higher success rate across out-of-distribution scenarios (Hassidof et al., 28 Aug 2025).

Model Predictive Trees shift emphasis from expansion quality to search reuse. MPT grows a depth-$k^2$1 UCT tree, selects the best child of the root, executes one step, and then reuses the entire selected subtree as the next MPC warm start (Lathrop et al., 2024). The node state includes cumulative value and visit count, and the UCT score is

$k^2$2

The paper derives a steady-state tracking-error bound under time-varying dynamics,

$k^2$3

which makes the reuse trade-off explicit: larger $k^2$4 improves foresight but worsens the bound when the disturbance changes quickly (Lathrop et al., 2024). Numerical studies report that MPT reaches average cumulative reward $k^2$5 with $k^2$6 simulated trajectories, compared with $k^2$7 for CEM, $k^2$8 for CEM-Reuse, and more than $k^2$9 for UCT; onboard hardware experiments run at $\mathbf{x}_n$0 Hz with about $\mathbf{x}_n$1 simulated trajectories every $\mathbf{x}_n$2 s (Lathrop et al., 2024).

3. Uncertainty, interaction, and risk-sensitive branching

When uncertainty is central, trajectory trees often branch over hypotheses rather than controls alone. In the cooperative MCTS planner of (Stegmaier et al., 2022), the world state is only known through a root belief $\mathbf{x}_n$3 built from Gaussian, unbiased, independent sensor models with diagonal covariance. Multiple start states are sampled from that belief, progressive widening decides when to add new start states, and one continuous-action MCTS tree is built for each sampled start state. The resulting action values are then aggregated across trees by kernel regression using a Gaussian radial basis kernel, and final selection is performed by KRLCB or CCVaR (Stegmaier et al., 2022). This produces a two-level interpretation of a trajectory tree: locally, each tree is a determinized MCTS search tree; globally, the collection of trees approximates a return distribution over uncertain initial conditions. On 15 scenarios with up to 8 vehicles and 300 random seeds, the uncertain baseline degrades to mean success rates of roughly $\mathbf{x}_n$4–$\mathbf{x}_n$5, whereas KRLCB and CVaR rise to around $\mathbf{x}_n$6–$\mathbf{x}_n$7, with modest runtime overheads (Stegmaier et al., 2022).

Tree Policy Planning makes the contingency structure explicit by separating ego choices from environment responses (Chen et al., 2023). The ego trajectory tree contains dynamically feasible stagewise motion segments generated from sampled terminal states and cubic polynomials, while the scenario tree contains stagewise multimodal, ego-conditioned environment futures with branch probabilities from a learned predictor. Because both trees share the same stage structure, the planner reduces to a finite-horizon discrete MDP with Bellman backup

$\mathbf{x}_n$8

The ego-conditioned version requires a causally consistent ensemble of scenario trees (Chen et al., 2023). In closed-loop nuScenes simulations, TPP reduces crash and offroad rates relative to non-contingency baselines across rasterized, PredictionNet, and Agentformer predictors, although temporally inconsistent Gaussian latents degrade performance (Chen et al., 2023).

Belief-space trajectory trees push this logic further by optimizing branches directly in belief space (Phiquepal et al., 3 May 2026). In PO-MPC, there is a single branching horizon: controls before branching are constrained by non-anticipativity, and each branch is weighted by its hypothesis probability $\mathbf{x}_n$9. In PO-LGP, trajectory-trees at the motion level are paired with decision trees at the task level, with deterministic observations pruning hypotheses (Phiquepal et al., 3 May 2026). The generic PO-MPC problem enforces shared pre-branch controls,

$\mathbf{T}_n$0

and is solved by the Distributed Augmented Lagrangian algorithm, which parallelizes the branchwise subproblems (Phiquepal et al., 3 May 2026). The paper reports lower costs than single-hypothesis plans in both adaptive cruise control and slalom examples, and planning times compatible with $\mathbf{T}_n$1 Hz (Phiquepal et al., 3 May 2026).

4. Prediction, multimodality, and interpretability

Prediction-oriented trajectory trees use branching to represent futures rather than to execute them. SIT is a clear example: the tree is hand-crafted from high-order velocity, with branching factor $\mathbf{T}_n$2, depth $\mathbf{T}_n$3, and $\mathbf{T}_n$4 candidate paths (Shi et al., 2022). A path such as [forward, forward, right] explicitly encodes a behavior sequence. The tree is first scored using trajectory encodings and a social-interaction encoding produced by a GCN with self-attention, then the highest-confidence path is greedily optimized, and finally a teacher-forcing refinement module predicts the fine trajectory (Shi et al., 2022). With the default $\mathbf{T}_n$5, the tree has $\mathbf{T}_n$6 paths. On ETH-UCY, SIT reports an average $\mathbf{T}_n$7 ADE / $\mathbf{T}_n$8 FDE; on SDD, $\mathbf{T}_n$9 yields $d_i$0 ADE / $d_i$1 FDE, and the raw untrained tree with depth $d_i$2 already reaches average $d_i$3 on ETH-UCY (Shi et al., 2022). The paper explicitly contrasts this with CVAE and GAN approaches, arguing that tree paths are interpretable because they directly encode rough motion decisions.

The vessel-prediction framework of (Zhang et al., 18 Nov 2025) separates sustained and transient intentions. Sustained intention trees are built from historical AIS trajectories by autoencoding and clustering prototype trajectories, then selecting the top-$d_i$4 prototypes for each observed vessel via cross-attention. Each selected branch stores $d_i$5, and each branch spawns $d_i$6 leaves through CVAE latent sampling and destination decoding (Zhang et al., 18 Nov 2025). A non-local attention module with encounter mask $d_i$7 refines joint predictions for global consistency. On Zhoushan, DI-MTP reports $d_i$8 ADE/FDE, versus $d_i$9 for TBENet and $s=3$0 for TUTR; on Hainan, it reports $s=3$1, versus $s=3$2 and $s=3$3 respectively (Zhang et al., 18 Nov 2025). Because each branch is associated with a prototype trajectory shape, the paper presents explainability as a direct property of the tree.

Sub-goal trees treat a trajectory as a recursive midpoint decomposition rather than as a left-to-right sequence (Jurgenson et al., 2019, Jurgenson et al., 2020). The central recurrence is

$s=3$4

with $s=3$5 and $s=3$6. For $s=3$7, the discrete APSP version recovers the exact shortest-path cost (Jurgenson et al., 2019, Jurgenson et al., 2020). This yields two consequences emphasized by the papers: prediction can be parallelized to depth $s=3$8 rather than sequential depth $s=3$9, and approximation errors accumulate more favorably than in sequential Bellman-style rollout. On 2D motion-planning domains, the supervised sub-goal-tree model improves success rate and reduces prediction time sharply relative to sequential baselines, and in RL the SGT-based controllers improve long-range navigation relative to goal-conditioned FQI (Jurgenson et al., 2019, Jurgenson et al., 2020).

5. Indexing, compression, and retrieval

A different lineage uses trajectory trees as secondary indexes or compressed storage structures. MGiST and MSP-GiST extend GiST and SP-GiST to multi-entry indexing, so that a single trajectory contributes multiple bounding predicates $^\#$0 rather than one coarse box (Schoemans et al., 2024). This directly improves filter effectiveness for point, range, and KNN queries. The paper instantiates multi-entry R-Trees, Quad-Trees, and KD-Trees with trajectory-specific splitting methods such as EquiSplit, MergeSplit, ManualSplit, AdaptSplit, and LinearSplit (Schoemans et al., 2024). On BerlinMOD, the multi-entry Quad-Tree achieves up to $^\#$1 speedup on a spatial-only intersection query, and on real AIS vessel data the multi-entry Quad-Tree yields about $^\#$2 speedup for a spatial port-entry query and about $^\#$3 for a spatio-temporal port-entry query (Schoemans et al., 2024). The paper recommends roughly 5–10 boxes per trajectory and generally favors the multi-entry Quad-Tree.

The $^\#$4-tree approach of (Bernardo et al., 2016) stores full positions of moving objects at regular snapshots in a compact spatial tree and encodes intermediate movements as relative displacements. It supports time-slice, time-interval, and per-object trajectory queries without decompressing the whole dataset (Bernardo et al., 2016). On 4,856 boats over one month, with grid cell size $^\#$5 m and 44,640 instants, the best compression ratio reported is $^\#$6 with a 120-minute snapshot period, and average object-search and time-slice times remain in the millisecond range (Bernardo et al., 2016). GraCT replaces the intermediate-log compression with Re-Pair and enriches each grammar rule with duration, net displacement, and MBR metadata, allowing nonterminal skipping during queries (Brisaboa et al., 2016). On AIS data with 3,654 ships, GraCT compresses the 501 MB original dataset to 179.60–196.79 MB depending on snapshot period, while outperforming the SCDC baseline on time-slice and time-interval queries for larger snapshot periods (Brisaboa et al., 2016).

Similarity-search trees follow yet another model. tSTAT indexes LSH sketches of trajectories in multiple succinct tries, one per block of the sketch (Kanda et al., 2020). Internal arrays $^\#$7 use trits to encode whether a transition is absent, points to an internal child, or points to a leaf child, enabling succinct Rank/Select navigation. Querying keeps a per-block Hamming mismatch count and prunes subtrees once the threshold is exceeded (Kanda et al., 2020). For recall at least $^\#$8, tSTAT is reported as up to $^\#$9 faster than FRESH on Taxi, $^\#$0 on NBA, and $^\#$1 on OSM, while using 2.4–2.7 GiB on OSM compared with 27–65 GiB for HmSearch and 50–65 GiB for FRESH (Kanda et al., 2020).

Tree structures can also support semantic alignment for retrieval. In sports-play retrieval, a trajectory tree stores state-specific templates learned hierarchically so that multi-agent plays can be aligned by repeated Hungarian assignment in a coarse-to-fine manner (Sha et al., 2017). The resulting leaf id acts as a hash bucket, while the composed permutation at the leaf supports subset-aware scoring. User studies with domain experts show that this tree-based method improves retrieval performance, especially when only a subset of trajectories is selected (Sha et al., 2017).

6. Guarantees, trade-offs, and recurrent limitations

Theoretical guarantees vary sharply across the literature. DiTree provides probabilistic completeness under Lipschitz dynamics and full-support learned sampling, with safety ensured by collision checking (Hassidof et al., 28 Aug 2025). TPP proves optimality of its finite-horizon policy under the discrete MDP induced by the ego tree and a causally consistent ensemble of ego-conditioned scenario trees (Chen et al., 2023). The sub-goal-tree framework proves exactness of its APSP recurrence once the depth reaches $^\#$2 in the discrete setting (Jurgenson et al., 2019, Jurgenson et al., 2020). MPT derives contraction-based tracking-error bounds for subtree reuse (Lathrop et al., 2024). By contrast, STD-Trees are integrated with planners that retain anytime and asymptotic optimality properties, but the paper explicitly states that it does not provide formal completeness or optimality proofs for the combined method (Ye et al., 2021). D-AuLa proves convergence to the global optimum only for convex problems with equality constraints and remains local in nonconvex settings with inequalities (Phiquepal et al., 3 May 2026).

A recurring misconception is that a trajectory tree is always a search tree over executable controls. The surveyed papers show otherwise. In some cases branches are sampled start states (Stegmaier et al., 2022), environment modes (Chen et al., 2023), observation contingencies (Phiquepal et al., 3 May 2026), intention prototypes (Zhang et al., 18 Nov 2025), midpoint decompositions (Jurgenson et al., 2019), or sketch prefixes for indexing (Kanda et al., 2020). Another misconception is that more branching is always better. Several papers report explicit trade-offs: BRANCH is preferred over TREE in STD-Trees because TREE can be computationally heavy (Ye et al., 2021); deeper or wider trees degrade SIT performance beyond the best depth of $^\#$3 (Shi et al., 2022); larger $^\#$4 in MPT worsens the steady-state error bound when disturbances change quickly (Lathrop et al., 2024); and multi-entry indexing improves filtering only until query-time gains plateau relative to index size (Schoemans et al., 2024).

Limitations are correspondingly domain-specific. STD-Trees assume differential flatness and per-axis decoupling, so severe coupling or yaw effects may require a different parameterization (Ye et al., 2021). The risk-aware MCTS planner uses belief only at the root and ignores belief updates during tree depth, which can miss information-gathering actions (Stegmaier et al., 2022). SIT relies on fixed motion primitives and dataset-wise split angles (Shi et al., 2022). DI-MTP may fail when historical prototypes do not cover rare maritime behaviors, and its transient intention model is destination-centered (Zhang et al., 18 Nov 2025). MGiST/MSP-GiST can be stressed by very long trajectories and high update rates (Schoemans et al., 2024). The compressed snapshot structures of (Bernardo et al., 2016) and the offline grammar-based design of (Brisaboa et al., 2016) are not presented as dynamically updatable online indexes.

Taken together, the literature suggests that trajectory trees are best understood not as one data structure, but as a reusable design pattern for imposing hierarchical structure on motion. In planning they expose local controllable alternatives; in uncertainty-aware systems they encode contingencies; in prediction they make multimodality explicit; and in databases they improve pruning, compression, or alignment. That breadth is precisely why the term persists across otherwise distant areas of robotics, autonomous driving, trajectory forecasting, and spatiotemporal data management.