pith. sign in

arxiv: 2506.04500 · v3 · submitted 2025-06-04 · 💻 cs.AI · cs.RO

"Don't Do That!": Guiding Embodied Systems through Large Language Model-based Constraint Generation

Amin Seffo , Aladin Djuhera , Masataro Asai , Holger Boche This is my paper

Pith reviewed 2026-05-19 10:25 UTC · model grok-4.3

classification 💻 cs.AI cs.RO
keywords large language modelsconstraint generationrobotic navigationpath planningpoint cloudsembodied systemsGazebo simulationcode generation
0
0 comments X

The pith

LLMs translate natural-language 'don't do' rules into Python functions that let robots plan fully compliant paths

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

This paper proposes STPR, a framework that prompts large language models to convert informal instructions about forbidden behaviors into executable Python functions. These functions are evaluated directly on point-cloud representations of the environment so that ordinary search algorithms can find paths guaranteed to respect the original constraints. The approach moves the hard part of constraint interpretation into a one-time code-generation step, avoiding repeated complex reasoning or hallucinations during planning. Simulated Gazebo trials show that the resulting paths always satisfy multiple constraints across different scenarios while keeping runtimes short. The same pipeline works with smaller code-focused LLMs, lowering the barrier to using the method on modest hardware.

Core claim

STPR prompts an LLM to produce Python functions that encode spatial, mathematical, and conditional constraints given as natural-language statements of 'what not to do.' These functions are then applied to point-cloud data to score candidate paths, allowing classical search algorithms to return trajectories that satisfy every constraint. Experiments confirm complete compliance in varied Gazebo scenarios, short planning times, and continued effectiveness when smaller LLMs replace larger ones.

What carries the argument

STPR framework that turns LLM-generated Python constraint functions into point-cloud evaluators for use inside classical search planners

If this is right

  • Planning stays efficient because the LLM is called only once per constraint set rather than at every planning step.
  • Full constraint compliance is achieved without requiring the planner itself to perform symbolic reasoning.
  • The method remains practical on compact hardware when smaller code LLMs are substituted.
  • Users can add new spatial rules using ordinary language instead of writing custom mathematical code.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • If the generated functions transfer reliably to noisy real-world sensors, the technique could reduce the engineering effort needed for safe robot deployment.
  • Reusable libraries of common constraint functions might emerge, letting new environments inherit safety rules without fresh LLM calls.
  • The same code-generation step could feed into optimization-based planners or learned policies instead of pure search.

Load-bearing premise

The large language model will produce correct, executable Python functions that accurately capture the user's intended constraints without logical errors or hallucinations.

What would settle it

A generated function that returns 'valid' for a trajectory the human can see violates one of the stated constraints, such as entering a mathematically forbidden region.

Figures

Figures reproduced from arXiv: 2506.04500 by Aladin Djuhera, Amin Seffo, Holger Boche, Masataro Asai.

Figure 1
Figure 1. Figure 1: Gazebo environment with a garage, util￾ity room, living room, and kitchen. A dangerous fireplace with a specific heat dissipation radius (red) must be avoided by the cleaning robot. Real-world navigation involves not only reach￾ing a goal but also adhering to constraints spec￾ified by human operators, which may be non￾standardized, vague, implicit, or informal, cap￾turing semantic information that is diffi… view at source ↗
Figure 2
Figure 2. Figure 2: STPR Overview: LLM generates a Python function based on user constraints using a prompt [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Top: STPR prompt template for constraint code generation, including the System Instruction (“You are a robot ...”) in orange, the Environment Block in black, the Constraint Block representing the user-specific instruction (here: Scenario 4: Fireplace Heat Avoidance) in blue, and the Python function Signature Scaffold. Bottom: Corresponding constraint function generated by the LLM. U(zi , zi). For each gi ,… view at source ↗
Figure 4
Figure 4. Figure 4: Planning results for STPR and baselines. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: Annotated top-down view of the Gazebo environment for (S1): Evading a Security Camera. [PITH_FULL_IMAGE:figures/full_fig_p012_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: Prompt for end-to-end naive LLM-based path planning with GPT 4o/o3-mini-high for (S1): [PITH_FULL_IMAGE:figures/full_fig_p012_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: Top: STPR prompt template for constraint code generation, including the System Instruction (“You are a robot ...”) in orange, the Environment Block in black, the Constraint Block representing the constraint-specific instruction (here for Scenario 1: Evading a Security Camera) in blue, and the Python function Signature Scaffold. The robot is explicitly told to avoid the field of view (FOV) of the security c… view at source ↗
Figure 8
Figure 8. Figure 8: Top: STPR prompt template for constraint code generation, including the System Instruction (“You are a robot ...”) in orange, the Environment Block in black, the Constraint Block representing the constraint-specific instruction (here for Scenario 2: Avoiding a Hole) in blue, and the Python function Signature Scaffold. The robot is instructed to avoid falling into a hole in the floor. The prompt describes t… view at source ↗
Figure 9
Figure 9. Figure 9: Top: STPR prompt template for constraint code generation, including the System Instruction (“You are a robot ...”) in orange, the Environment Block in black, the Constraint Block representing the constraint-specific instruction (here for Scenario 3: Animal in the Kitchen) in blue, and the Python function Signature Scaffold. The robot is warned about the presence of a raccoon in the kitchen, but is not expl… view at source ↗
Figure 10
Figure 10. Figure 10: Context-grounding JSON description for (S4)’s utility room environment. Defines: (1) [PITH_FULL_IMAGE:figures/full_fig_p017_10.png] view at source ↗
Figure 11
Figure 11. Figure 11: Planning results for STPR and baseline methods in all four scenarios (S1-S4), shown [PITH_FULL_IMAGE:figures/full_fig_p018_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: Software-in-the-Loop architecture for evaluating STPR in simulation. Natural language [PITH_FULL_IMAGE:figures/full_fig_p021_12.png] view at source ↗
Figure 13
Figure 13. Figure 13: Flow diagram of the LLM-based constraint prompting, point cloud sampling, and con [PITH_FULL_IMAGE:figures/full_fig_p022_13.png] view at source ↗
Figure 14
Figure 14. Figure 14: SLAM-generated occupancy grid map using LiDAR data, visualized in RVIZ. Static [PITH_FULL_IMAGE:figures/full_fig_p022_14.png] view at source ↗
read the original abstract

Recent advancements in large language models (LLMs) have spurred interest in robotic navigation that incorporates complex spatial, mathematical, and conditional constraints from natural language into the planning problem. Such constraints can be informal yet highly complex, making it challenging to translate into a formal description that can be passed on to a planning algorithm. In this paper, we propose STPR, a constraint generation framework that uses LLMs to translate constraints (expressed as instructions on ``what not to do'') into executable Python functions. STPR leverages the LLM's strong coding capabilities to shift the problem description from language into structured and interpretable code, thus circumventing complex reasoning and avoiding potential hallucinations. We show that these LLM-generated functions accurately describe even complex mathematical constraints, and apply them to point cloud representations with traditional search algorithms. Experiments in a simulated Gazebo environment show that STPR ensures full compliance across several constraints and scenarios, while having short runtimes. We also verify that STPR can be used with smaller code LLMs, making it applicable to a wide range of compact models with low inference cost.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 2 minor

Summary. The manuscript proposes STPR, a framework that uses large language models to translate natural-language constraints phrased as 'what not to do' instructions into executable Python functions. These functions are then applied to point-cloud representations of the environment together with traditional search algorithms for embodied navigation. The authors claim that the generated functions accurately capture even complex mathematical constraints, and report that experiments in a Gazebo simulator achieve full compliance across several constraints and scenarios while maintaining short runtimes. The approach is additionally shown to work with smaller code LLMs.

Significance. If the accuracy of the LLM-to-code translation step can be more rigorously established, the work would offer a practical route for incorporating informal yet mathematically complex constraints into robotic planning without manual formalization. Shifting the burden to code generation and then using established search methods is a sensible design choice that may reduce certain classes of hallucination. Demonstrating usability with compact models further increases potential applicability. At present the empirical support remains thin, limiting the assessed significance.

major comments (2)
  1. Abstract: the claim that the LLM-generated functions 'accurately describe even complex mathematical constraints' is supported only by end-to-end Gazebo compliance and runtime figures; no quantitative accuracy metrics, error rates, constraint-complexity measures, or test-coverage statistics are supplied, leaving the central translation claim only partially evidenced.
  2. Evaluation (Gazebo experiments): full compliance is reported, yet the manuscript provides no direct verification that the generated Python functions correctly implement the intended point-cloud constraints (e.g., via unit tests, edge-case analysis, or comparison against ground-truth oracles). This gap is load-bearing because simulation success could mask subtle logical errors in the generated code.
minor comments (2)
  1. The abstract and experimental description would be clearer if a table or appendix listed the specific constraints tested, their mathematical form, and the corresponding compliance/runtimes observed.
  2. Consider adding one or two concrete examples of LLM-generated Python functions (with the original natural-language constraint) to illustrate the translation quality.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for their constructive comments. We address the major concerns point by point below and describe the revisions that will be incorporated to strengthen the evidence for our claims.

read point-by-point responses

  1. Referee: Abstract: the claim that the LLM-generated functions 'accurately describe even complex mathematical constraints' is supported only by end-to-end Gazebo compliance and runtime figures; no quantitative accuracy metrics, error rates, constraint-complexity measures, or test-coverage statistics are supplied, leaving the central translation claim only partially evidenced.

    Authors: We agree that the abstract claim currently rests on indirect evidence from end-to-end simulation results. While full compliance in Gazebo across multiple scenarios and constraints demonstrates practical utility, direct quantitative assessment of the LLM-to-code translation would provide stronger support. In the revised manuscript we will add a new evaluation subsection that reports (i) the fraction of generated functions that pass manual correctness review against the natural-language intent, (ii) a simple complexity measure (e.g., number of mathematical operations and conditional branches) for each tested constraint, and (iii) success rates when the same prompts are given to the smaller code LLMs already evaluated in the paper. revision: yes

  2. Referee: Evaluation (Gazebo experiments): full compliance is reported, yet the manuscript provides no direct verification that the generated Python functions correctly implement the intended point-cloud constraints (e.g., via unit tests, edge-case analysis, or comparison against ground-truth oracles). This gap is load-bearing because simulation success could mask subtle logical errors in the generated code.

    Authors: The referee correctly notes that end-to-end compliance does not isolate potential errors inside the generated constraint functions. We will therefore augment the evaluation section with direct verification: (a) unit tests executed on synthetic point clouds that exercise both nominal and edge-case inputs for each constraint, (b) explicit comparison of a representative subset of LLM-generated functions against hand-written oracle implementations, and (c) reporting of any discrepancies found. These additions will be presented alongside the existing Gazebo results so that readers can assess both system-level and function-level correctness. revision: yes

Circularity Check

0 steps flagged

No significant circularity; evaluation uses independent simulator and traditional algorithms

full rationale

The paper's core chain translates natural-language constraints into LLM-generated Python functions, then applies those functions to point-cloud data via standard search algorithms inside an external Gazebo simulator. Compliance results are measured against the simulator's independent dynamics rather than any fitted parameter or self-referential definition internal to the paper. No equations, ansatzes, or uniqueness theorems are invoked that reduce the accuracy claim to a prior fit or self-citation by construction. The reported evidence (full compliance and short runtimes) is therefore externally falsifiable and does not collapse into the input generation step.

Axiom & Free-Parameter Ledger

0 free parameters · 1 axioms · 0 invented entities

The central claim rests on the established coding ability of LLMs and the applicability of classical search to the generated functions; no new free parameters, invented entities, or ad-hoc axioms beyond standard domain assumptions are introduced.

axioms (1)
  • domain assumption Large language models can translate informal natural-language constraints into accurate executable Python code without hallucinations or logical errors.
    This assumption underpins the shift from language to structured functions that traditional planners can use.

pith-pipeline@v0.9.0 · 5731 in / 1174 out tokens · 61292 ms · 2026-05-19T10:25:32.061206+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Lean theorems connected to this paper

Citations machine-checked in the Pith Canon. Every link opens the source theorem in the public Lean library.

What do these tags mean?
matches
The paper's claim is directly supported by a theorem in the formal canon.
supports
The theorem supports part of the paper's argument, but the paper may add assumptions or extra steps.
extends
The paper goes beyond the formal theorem; the theorem is a base layer rather than the whole result.
uses
The paper appears to rely on the theorem as machinery.
contradicts
The paper's claim conflicts with a theorem or certificate in the canon.
unclear
Pith found a possible connection, but the passage is too broad, indirect, or ambiguous to say the theorem truly supports the claim.

Reference graph

Works this paper leans on

39 extracted references · 39 canonical work pages · 3 internal anchors

  1. [1]

    Huang, P

    W. Huang, P. Abbeel, D. Pathak, and I. Mordatch. Language Models as Zero-Shot Planners: Extracting Actionable Knowledge for Embodied Agents. In Proc. of the International Conference on Machine Learning (ICML), pages 9118–9147. PMLR, 2022

    work page 2022

  2. [2]

    Sparks of Artificial General Intelligence: Early experiments with GPT-4

    S. Bubeck, V . Chandrasekaran, R. Eldan, J. Gehrke, E. Horvitz, E. Kamar, P. Lee, Y . T. Lee, Y . Li, S. Lundberg, et al. Sparks of Artificial General Intelligence: Early Experiments with GPT-4. arXiv preprint arXiv:2303.12712, 2023

    work page internal anchor Pith review Pith/arXiv arXiv 2023

  3. [3]

    Y . Liu, L. Palmieri, S. Koch, I. Georgievski, and M. Aiello. DELTA: Decomposed Efficient Long- Term Robot Task Planning using Large Language Models. arXiv preprint arXiv:2404.03275, 2024

    work page arXiv 2024

  4. [4]

    Evaluation of openai o1: Opportunities and challenges of agi,

    T. Zhong, Z. Liu, Y . Pan, Y . Zhang, Y . Zhou, S. Liang, Z. Wu, Y . Lyu, P. Shu, X. Yu, et al. Evaluation of OpenAI o1: Opportunities and Challenges of AGI. arXiv preprint arXiv:2409.18486, 2024

    work page arXiv 2024

  5. [5]

    Chib and E

    S. Chib and E. Greenberg. Understanding the Metropolis-Hastings Algorithm. The american statistician, 49(4):327–335, 1995

    work page 1995

  6. [6]

    P. E. Hart, N. J. Nilsson, and B. Raphael. A Formal Basis for the Heuristic Determination of Minimum Cost Paths. Systems Science and Cybernetics, IEEE Transactions on, 4(2):100–107, 1968

    work page 1968

  7. [7]

    Karaman and E

    S. Karaman and E. Frazzoli. Sampling-Based Algorithms for Optimal Motion Planning. Int. J. Robot. Res.(IJRR), 30(7):846–894, 2011

    work page 2011

  8. [8]

    Koenig and A

    N. Koenig and A. Howard. Design and Use Paradigms for Gazebo, an Open-Source Multi-Robot Simulator. In Proc. of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), volume 3, pages 2149–2154 vol.3, 2004. doi:10.1109/IROS.2004.1389727

    work page doi:10.1109/iros.2004.1389727 2004

  9. [9]

    C. R. Qi, H. Su, K. Mo, and L. J. Guibas. PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation. In Proc. of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 652–660, 2017

    work page 2017

  10. [10]

    S. Shi, X. Wang, and H. Li. PointRCNN: 3D Object Proposal Generation and Detection from Point Cloud. In Proc. of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–779, 2019

    work page 2019

  11. [11]

    W. R. Gilks and P. Wild. Adaptive Rejection Sampling for Gibbs Sampling. Journal of the Royal Statistical Society: Series C (Applied Statistics), 41(2):337–348, 1992

    work page 1992

  12. [12]

    J. L. Bentley. Multidimensional Binary Search Trees Used for Associative Searching. Commun. ACM, 18(9):509–517, Sept. 1975. ISSN 0001-0782. doi:10.1145/361002.361007. URL https: //doi.org/10.1145/361002.361007

    work page doi:10.1145/361002.361007 1975

  13. [13]

    J. D. Gammell, S. S. Srinivasa, and T. D. Barfoot. Informed RRT*: Optimal Sampling-Based Path Planning Focused via Direct Sampling of an Admissible Ellipsoidal Heuristic. In Proc. of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 2997–3004. IEEE, 2014

    work page 2014

  14. [14]

    Y . Li, Z. Littlefield, and K. E. Bekris. Asymptotically Optimal Sampling-Based Kinodynamic Planning. Int. J. Robot. Res.(IJRR), 35(5):528–564, 2016

    work page 2016

  15. [15]

    D. Fox, W. Burgard, and S. Thrun. The Dynamic Window Approach to Collision Avoidance. IEEE Robotics & Automation Magazine, 4(1):23–33, 1997

    work page 1997

  16. [16]

    Macenski and I

    S. Macenski and I. Jambrecic. SLAM Toolbox: SLAM for the Dynamic World. Journal of Open Source Software, 6:2783, 05 2021. doi:10.21105/joss.02783

    work page doi:10.21105/joss.02783 2021

  17. [17]

    Isaac ROS Visual SLAM , 2025

    NVIDIA. Isaac ROS Visual SLAM , 2025. URL https://nvidia-isaac-ros.github.io/ repositories_and_packages/isaac_ros_visual_slam/index.html. Accessed: 2025-04-09

    work page 2025

  18. [18]

    The Llama 3 Herd of Models

    A. Grattafiori, A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten, A. Vaughan, et al. The Llama 3 Herd of Models. arXiv preprint arXiv:2407.21783, 2024

    work page internal anchor Pith review Pith/arXiv arXiv 2024

  19. [19]

    Cox, Ruchir Puri, and Rameswar Panda

    M. Mishra, M. Stallone, G. Zhang, Y . Shen, A. Prasad, A. M. Soria, M. Merler, P. Selvam, S. Suren- dran, S. Singh, et al. Granite Code Models: A Family of Open Foundation Models for Code Intelligence. arXiv preprint arXiv:2405.04324, 2024. 10

    work page arXiv 2024

  20. [20]

    R. E. Fikes, P. E. Hart, and N. J. Nilsson. Learning and Executing Generalized Robot Plans.Artificial Intelligence, 3(1-3):251–288, 1972. doi:10.1016/0004-3702(72)90051-3

    work page doi:10.1016/0004-3702(72)90051-3 1972

  21. [21]

    M. Ahn, A. Brohan, N. Brown, Y . Chebotar, O. Cortes, B. David, C. Finn, C. Fu, K. Gopalakrishnan, K. Hausman, et al. Do As I Can and Not As I Say: Grounding Language in Robotic Affordances. In Proc. of Conference on Robot Learning, pages 287–318. PMLR, 2023

    work page 2023

  22. [22]

    B. Liu, Y . Jiang, X. Zhang, Q. Liu, S. Zhang, J. Biswas, and P. Stone. LLM+P: Empowering Large Language Models with Optimal Planning Proficiency. arXiv preprint arXiv:2304.11477, 2023

    work page internal anchor Pith review Pith/arXiv arXiv 2023

  23. [23]

    M. Kwon, Y . Kim, and Y . J. Kim. Fast and Accurate Task Planning using Neuro-Symbolic Language Models and Multi-level Goal Decomposition. arXiv preprint arXiv:2409.19250, 2024

    work page arXiv 2024

  24. [24]

    Y . Chen, J. Arkin, C. Dawson, Y . Zhang, N. Roy, and C. Fan. AutoTAMP: Autoregressive Task and Motion Planning with LLMs as Translators and Checkers. In Proc. of IEEE International Conference on Robotics and Automaton (ICRA), pages 6695–6702. IEEE, 2024

    work page 2024

  25. [25]

    Y . Hao, Y . Zhang, and C. Fan. Planning Anything with Rigor: General-Purpose Zero-Shot Planning with LLM-based Formalized Programming. In Proc. of the International Conference on Learning Representations (ICLR), 2025. URL https://openreview.net/forum?id=0K1OaL6XuK

    work page 2025

  26. [26]

    M. Katz, H. Kokel, K. Srinivas, and S. Sohrabi Araghi. Thought of Search: Planning with Language Models Through the Lens of Efficiency. Proc. of the Advances in Neural Information Processing Systems (Neurips), 37:138491–138568, 2024

    work page 2024

  27. [27]

    W. Guo, Z. K. Kingston, and L. E. Kavraki. CaStL: Constraints as Specifications through LLM Translation for Long-Horizon Task and Motion Planning. In Proc. of the Advances in Neural Information Processing Systems (Neurips), 2024

    work page 2024

  28. [28]

    Curtis, N

    A. Curtis, N. Kumar, J. Cao, T. Lozano-P ´erez, and L. P. Kaelbling. Trust the PRoC3S: Solving Long-Horizon Robotics Problems with LLMs and Constraint Satisfaction. In Proc. of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2024

    work page 2024

  29. [29]

    Blackmore, M

    L. Blackmore, M. Ono, and B. C. Williams. Chance-Constrained Optimal Path Planning with Obstacles. IEEE Transactions on Robotics, 27(6):1080–1094, 2011

    work page 2011

  30. [30]

    Lewis, E

    P. Lewis, E. Perez, A. Piktus, F. Petroni, V . Karpukhin, N. Goyal, H. K ¨uttler, M. Lewis, W.-t. Yih, T. Rockt¨aschel, et al. Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. Advances in Neural Information Processing Systems, 33:9459–9474, 2020

    work page 2020

  31. [31]

    C. Peng, F. Xia, M. Naseriparsa, and F. Osborne. Knowledge Graphs: Opportunities and Challenges. Artificial Intelligence Review, 56(11):13071–13102, 2023

    work page 2023

  32. [32]

    S. M. LaValle and J. J. Kuffner. Randomized Kinodynamic Planning. IJRR, 20(5):378–400, 2001

    work page 2001

  33. [33]

    Cheng and S

    P. Cheng and S. M. LaValle. Resolution Complete Rapidly-Exploring Random Trees. In Proc. of IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) , volume 1, pages 267–272. IEEE, 2002

    work page 2002

  34. [34]

    "" Check if the input satisfies constraints. Parameters: - x, y, z (float): Point coordinates. Returns: - bool: True if the point is forbidden, otherwise False

    O. Salzman and D. Halperin. Asymptotically Near-Optimal RRT for Fast, High-Quality Motion Planning. IEEE Transactions on Robotics, 32(3):473–483, 2016. 11 A Naive LLM-Based Planning This section describes the details of naive end-to-end LLM-based path generation. Fig. 5 and Fig. 6 show the annotated image and the corresponding prompt used for scenario (S1...

    work page 2016

  35. [35]

    Select a random state xrand from the entire free space X ,

    work page

  36. [36]

    Select the nearest neighbor xnearest of xrand from the set of nodes of the tree, 19

    work page

  37. [37]

    Generate a new state xnew by generating a collision-free path from xnearest to xrand using a local planner

    work page

  38. [38]

    Add an edge (xnearest, xnew) to the tree

    work page

  39. [39]

    Terminate if xnew satisfies a goal criteria (e.g., proximity to a goal state xgoal). In RRT*, Step 4 instead adds an edge from one of the nodes already in the tree that are close to xnew (within a dynamically shrinking radius as a function of |V |) and has the smallest cost from the root, if the cost is smaller than that of xnearest. Goal-biased sampling ...

    work page 2000