EIRM*: Effort Informed Roadmaps

• The paper presents EIRM*, which minimizes validation effort by reusing collision-check work across multiple queries using decomposed checks, bidirectional search, and batch rewinding.
• EIRM* is a sampling-based roadmap algorithm that employs an edge-implicit RGG and an effort-aware metric to efficiently guide motion planning in robotics, particularly for manipulation and TAMP tasks.
• Empirical results demonstrate up to a 17× reduction in initial planning time while maintaining solution quality and asymptotic optimality, highlighting practical efficiency gains.

Effort Informed Roadmaps (EIRM*) are multiquery asymptotically optimal motion planning algorithms that explicitly minimize the total computational effort, with a focus on maximizing the reuse of collision-check and validation work across multiple planning queries. EIRM* builds upon the sampling-based roadmap paradigm and introduces novel algorithmic mechanisms—particularly decomposed collision checking, asymmetric bidirectional search, and batch-based roadmap rewinding—to enable substantial effort savings and improved initial solution times, especially in robot manipulation and task and motion planning (TAMP) settings where problem structure is repetitive and information reuse is critical (Hartmann et al., 2023, Hartmann et al., 2022).

1. Formal Problem Setting and Notation

EIRM* addresses the multiquery motion planning problem for robots (primarily manipulators) operating among static and movable obstacles. The configuration space is denoted $C \subset \mathbb{R}^n$ (with $q \in C$), and planning occurs as a sequence of motion-planning queries. Each query $$\alpha_i = (q_{i, start}, q_{i, goal}, M_i, \Theta_i)$$ seeks a path $\pi_i: [0, 1] \to C_{\mathrm{free}, i}(\Theta_i)$, where $C_{\mathrm{free}, i}(\Theta_i)$ is the collision-free configuration space as determined by the current poses $\Theta_i$ of movable objects $O \subset \{1, \dots, N\}$. A complete manipulation plan is a sequence $A = \{\alpha_1, \dots, \alpha_K\}$, with the terminal configuration of each query coinciding with the start of the next.

Two principal quantities are tracked:

• Path cost $c(\pi)$: typically the length of the path in configuration space.
• Planning effort $e(q, q')$: the computational cost to validate the straight-line edge from $q$ to $q'$, often proportional to the number of discrete collision checks required.

The multiquery scenario is especially relevant for manipulation and TAMP contexts, where planners must repeatedly answer robotic motion subproblems that share environment and workspace structure (Hartmann et al., 2023).

2. Decomposition and Reuse of Collision Checking

EIRM* exploits the repetitive structure of manipulation planning by decomposing collision checking into reusable and non-reusable parts. The collision-free space for a single query is partitioned as follows:

$$C_{\mathrm{free}, i}(\Theta_i) = C_{\mathrm{free}} \cap C_{\mathrm{free}}(\theta_{M_i}) \cap C_{\mathrm{free}}(\Theta_i)$$

where:

• $C_{\mathrm{free}}$: configurations collision-free with respect to the robot itself and static environment (always reusable).
• $C_{\mathrm{free}}(\theta_{M_i})$: configurations considering static environment and current movable obstacle placements (reusable when the subset $M_i$ is unchanged).
• $C_{\mathrm{free}}(\Theta_i)$: collision-free with the full current arrangement (query-specific).

Each edge $\ell = (q, q')$ in the roadmap stores for each of the above partitions a validity flag in $\{\text{unknown}, \text{valid}, \text{invalid}\}$, allowing selective and sparse re-validation.

Pseudocode for sparse validation (abstracted) follows:

validate(ℓ, Θᵢ, Mᵢ): for each interpolated configuration q_int along ℓ do check only those sub–checks whose flag==unknown if any sub–check fails, mark that flag=invalid and return false end for mark all three flags=valid and return true

This layered approach permits amortization of expensive validation checks across related queries and across different problem instances (Hartmann et al., 2023).

3. EIRM* Algorithmic Framework

EIRM* is structurally based on PRM* but incorporates critical modifications to actively minimize planning effort:

• Edge-Implicit Random Geometric Graph (RGG): The planner uses a set of samples $S \subset C$ to maintain an RGG; edges are considered lazily.
• Effort-Aware Edge Metric: For edge $\ell = (q, q')$, the estimated validation effort is

$$e(\ell) = e_{r/s}(q, q') + e_{o/s}(q, q'|\theta_{M_i}) + e_{r/o}(q, q'|\Theta_i)$$

where each $e$ counts only unknown validity checks.

• Bidirectional Search with Effort Heuristics: The algorithm performs:
  • A reverse search from the goal, which is guided by an admissible heuristic $d(q)$ quantifying remaining validation effort (prioritizing regions with previously reusable effort).
  • A forward search from the start, prioritizing paths by cost $g(\cdot)$ with an effort-based tiebreaker. Edges along the search frontier are validated only as needed.
• Batch-Based Rewinding (Graph Size Management): A global buffer of all previously sampled nodes enables "replaying" only promising samples per new query (those with $f(\cdot) < c_{\text{best}}$), ensuring the roadmap does not grow without bound and remains consistent with PRM* optimality requirements.

Essential algorithmic steps:

• Each loop alternates between reverse (heuristic update) and forward (path validation/expansion) search, or triggers roadmap refinement (batch-rewind) as needed.
• The reverse search never performs collision checks but updates cost and effort labels.
• Only edges required to achieve path improvement are fully validated, thus minimizing unnecessary effort (Hartmann et al., 2023, Hartmann et al., 2022).

4. Theoretical Properties

EIRM* inherits key guarantees from PRM* and LazyPRM*, under standard assumptions such as uniform sampling and non-degenerate free space (Hartmann et al., 2022):

• Probabilistic Completeness: As the number of samples $n \to \infty$, the probability of finding a feasible path (if one exists) approaches one.
• Asymptotic Optimality: The path cost $c_{\text{best}}$ converges almost surely to the optimal path cost $c^*$ as $n \to \infty$.
• Validation Effort Minimization: Once the roadmap is sufficiently rich, the expected number of new edge validations per query is $O(1)$, as the algorithm efficiently reuses previously validated edges. In contrast, LazyPRM* generally requires $O(n)$ new checks.

The batch-rewinding mechanism ensures the set of roadmap samples at every iteration covers the informed set $f(\cdot) < c_{\text{best}}$, matching the connectivity properties needed for PRM*-like optimality proofs (Hartmann et al., 2022).

5. Empirical Performance

EIRM* has been benchmarked on manipulation planning problems in both simulated and abstract scenarios, including:

• Wall-Gap (2D)
• Multi-Insertion (3D)
• Bin-Picking (7D)
• Brick-Wall (8D)
• Handover (14D)

Metrics recorded include:

• $t_{\text{init}}$: time to first feasible solution for the entire query sequence.
• $c_{\text{init}}$: cost of the initial solution.
• Anytime performance (best path cost as a function of computation time).
• Success-over-time curves.

Key empirical results:

• Effort-ordered planners including EIRM* and eo-LazyPRM* achieve up to $2\times$ reduction in $t_{\text{init}}$ relative to LazyPRM* (e.g., $0.098\,\mathrm{s}$ vs $0.206\,\mathrm{s}$ on Wall-Gap; $0.114\,\mathrm{s}$ vs $0.163\,\mathrm{s}$ on Bin-Picking).
• Solution quality ($c_{\text{init}}$) is comparable across all optimal planners (within 5%).
• In multiquery experiments with perturbed environments, EIRM* and eo-LazyPRM* maintain speedup ($\sim2.5\times$) over single-query methods due to the exploitation of reusable checks (Hartmann et al., 2023).
• On 2D and 7D problems, EIRM* achieves up to $17\times$ reduction in $t_{\text{init}}$ compared to PRM* and $5$–$20\times$ over LazyPRM* (Hartmann et al., 2022).

6. Practical Guidelines and Implementation Insights

Empirically supported guidelines for applying EIRM*:

• Collision-Checking Resolution: The false-positive rate should be $\leq 0.1\%$. For high-dimensional robotic problems, $10^{-3}$–$10^{-4}$ is typical.
• Batch Size: $m=500$ samples per batch are effective for high-dimensional settings; smaller batches speed up initial planning but slow long-term convergence.
• Graph Size Management: Batch-rewinding is essential; omitting it yields unmanageable roadmap growth and degrades planner efficiency.
• Limitations: When collision checks become computationally cheap or the solution path nears optimality, nearest-neighbor (NN) computations may dominate. Caching or fast NN data structures (e.g., k-d trees) are advantageous.
• Applicability: EIRM* is especially effective for long sequences of similar motion queries, such as manipulation or TAMP loops.
• Integration: Minimal code changes are required from lazy-PRM* frameworks; per-edge validity flags, effort tracking, and the bidirectional search and batch-rewind logic are the main additions.

The core concept of decomposing collision checking and prioritizing effort-reuse is broadly adaptable to other validity checks, such as force-closure or visibility, provided some aspects are reusable across queries (Hartmann et al., 2023).

7. Algorithmic Comparison and Distinguishing Features

Table: Comparison of Multiquery Planning Approaches

Planner	Validates Edges	Effort Reuse Strategy	Asymptotic Optimality
PRM*	Precomputes all	None	Yes
LazyPRM*	On-demand	Passive (uses cached flags)	Yes
EIRM*	On-demand, prioritized	Active, effort-informed, replays	Yes

EIRM* distinguishes itself by active ordering of edge validation steps, maximizing the savings from previously invested validation work, and ensuring anytime optimality with provable guarantees. It avoids the drawbacks of both excessive preprocessing (as in PRM*) and the lack of effort-aware prioritization (as in standard LazyPRM*). Its batch-rewinding approach prevents uncontrolled roadmap growth, an issue for passive-experience-based planners (Hartmann et al., 2022).

EIRM* represents a significant advancement in multiquery optimal motion planning, specifically tailored for domains where validation effort is the dominant planning cost and information reuse is essential for scalability.