{"id":"3e5c74c4-04fa-404d-9dc7-9ad45a2e7d94","arxiv_id":"2411.12014","paper_version":1,"verdict":"REJECT","confidence":"HIGH","novelty_score":2.0,"correctness_risk":"high","formal_verification":"none","parameter_count":3,"one_line_summary":"A periodic re-planning wrapper around a static planner is demonstrated in 2D and 3D simulations with randomly appearing and adversarial obstacles, without quantitative benchmarks or comparison to existing dynamic planners.","lead":"This paper presents a path-planning algorithm that repeatedly re-runs a standard route finder while a robot moves, so the robot can swerve around obstacles that appear after the trip starts. It is a simple recipe for adding replanning to existing planners, but the paper offers only pictures as evidence and does not compare with established dynamic planners.","discovery_kind":"incremental","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The multiplicative update T←T*i in Algorithm 1 (lines 8-10) grows the replanning interval beyond Assumption 1's stability span T, so the agent follows stale plans through potential collisions; the claimed completeness rests on an internally violated assumption.","rationale":"The reader's rejection is justified, and my concern is the same load-bearing spot: the re-planning schedule contradicts the environmental stability assumption. The reader's weakest assumption names exactly this—the stability span T, the path[T] indexing, and the multiplicative counter update—so I agree. I would keep the verdict REJECT because the central claim is not supported, and this specific internal inconsistency provides a concrete, falsifiable reason rather than only a complaint about missing comparisons or novelty. The paper itself acknowledges in Section 6 that navigation may fail when a dynamic obstacle blocks a doorway, but the timing violation is more fundamental: as pseudocoded, Algorithm 1 can command the agent to traverse a stale path for longer than the environment is guaranteed to remain unchanged, so the collision-free guarantee demanded by Problem 2.1 is not established. My proposed simulation test would settle the matter directly by showing whether the multiplicative update causes collisions that a fixed-interval replanner avoids.","tokens_in":10544,"tokens_out":4722,"duration_ms":49847,"concrete_test":"Run Algorithm 1 (with the paper's Python implementation if available) on a 1D corridor X=[0,10], x0=0, xg=10, h=0.5, T=1, with a wall obstacle inserted at x=5 at simulation time 3 and a constant-speed agent moving at 1 unit/s along the planned path. Record whether the agent collides during the interval [3,4]. Then run the identical setup with line 10 replaced by a fixed T (i.e., T←T) and compare. If the original version collides while the fixed version reaches the goal, the multiplicative update violates Assumption 1 and invalidates the completeness claim. If neither collides, the test still verifies whether path[T] can be evaluated without index errors or undefined time indexing.","verdict_should_be":"UNCHANGED","load_bearing_attack":"For Problem 2.1 to be solved, the agent must reach xg while staying in the free space. Algorithm 1's progress step is xc ← path[T]; E gets adjusted; T ← T*i; i ← i+1. Assumption 1 guarantees the environment is stable only for the original span T. After the first cycle, i ≥ 2, so the new interval T' = i*T exceeds T; the agent is then instructed to traverse the planned path over [t, t+T'] although the environment may change at t+T. The static plan computed at time t is therefore not validated for the entire interval during which it is executed, and no collision check or dynamic-obstacle prediction is performed between replans. This is not merely a missing proof: it is an internal contradiction between Assumption 1 and line 10. Additionally, path[T] is ambiguous: Algorithm 2 returns a discrete waypoint list, not a time-parameterized trajectory, so path[T] is either an out-of-range index or an undefined time-map. Section 5's claim that the planner 'exhibits completeness by actively seeking solutions within the distortion time' equivocates: the distortion time in Assumption 1 is fixed, while the algorithm multiplies it. Hence the central assertion of successful guidance in static and dynamic scenarios is unsupported as stated.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript proposes the 'On-the-Go Motion Planning Algorithm' (Algorithm 1), which wraps a static planner P in a periodic replanning loop intended for dynamic environments. Under Assumption 1, the environment is stable for a distortion time T; Algorithm 1 plans, advances the agent to path[T], adjusts the environment, and multiplies T by a counter i. Four dynamic scenarios are defined (Cases 1-4), and Algorithm 2 provides a grid-based static planner with an optional kinodynamic-constraint helper. Section 5 reports 2D and 3D simulations, but only as screenshots, and claims completeness in the distortion-time sense. The paper concludes by acknowledging that the planner may fail to reach the goal in Cases 3 and 4.","tokens_in":10865,"tokens_out":5016,"duration_ms":47814,"significance":"If the algorithm worked as described, a simple wrapper around a static planner would provide real-time replanning under a bounded environmental-stability assumption, which could be practically useful. The paper has some strengths: it clearly states Assumption 1, defines four dynamic scenarios, includes the implementation scripts, and explicitly acknowledges limitations in Section 6 and in the remark after Algorithm 1. However, the central guarantee in Problem 2.1 is not established: Algorithm 1 is under-specified, its progress step is undefined, and the reported validation consists of illustrative figures without quantitative metrics or comparisons to existing dynamic planners. On the evidence in the manuscript, the contribution is at best a preliminary demonstration.","major_comments":[{"comment":"The update T ← T*i violates Assumption 1. Assumption 1 guarantees stability only for the original span T, yet after the first cycle the agent is asked to follow a plan for i*T time units while the environment may change at time T. No collision check or dynamic-obstacle prediction is performed between replans, so the progress step xc ← path[T] can advance the agent into an obstacle. This is an internal contradiction, not merely a missing proof, and it undermines the central claim that Problem 2.1 is solved.","section":"Section 2.2 / Algorithm 1, lines 8-10"},{"comment":"path[T] is undefined. Algorithm 2 returns a discrete waypoint list traj, not a time-parameterized trajectory, while T is a real-valued time span in Assumption 1. If path is a list, path[T] with T (after the first update, a real number multiplied by i) is either an out-of-range index or a type error; if path is meant to be time-parameterized, that structure is never defined. The core update of the agent's position therefore cannot be evaluated as written.","section":"Algorithm 1, line 8 / Algorithm 2, line 18"},{"comment":"No termination or collision-avoidance guarantee is proved. The while condition 'approximately close to xg' is informal; there is no invariant or progress measure, and the remark after Algorithm 1 explicitly allows the planner to return 'Road blocked completely.' The Section 5 statement that the planner 'exhibits completeness by actively seeking solutions within the distortion time' is not a formal completeness proof, and it equivocates: the distortion time in Assumption 1 is fixed, while Algorithm 1 multiplies it. Cases 3 and 4 additionally assume obstacles do not appear on the already covered path, but this constraint is not encoded in Algorithm 1.","section":"Algorithm 1 and Section 5"},{"comment":"The experimental validation consists entirely of screenshots. There are no quantitative metrics such as success rate, collision count, replanning frequency, or runtime per planning call, and no comparison with any baseline planner for dynamic environments. The statement that each experiment concluded in at most 6 s is not a meaningful performance measure. Consequently, the claimed effectiveness for both known and unknown environments is unsupported.","section":"Section 5, Figs. 3-12"},{"comment":"The helper IsSatisfiesDynamicConstraint is assumed to return a state x' in X ∩ Φ_h(x_hat) along the agent's kinodynamic trajectory, but no argument is given that such a state exists for the chosen discretization h and the given dynamics. If no such point exists, the kinodynamic branch of Algorithm 2 cannot execute. This is load-bearing for the 3D examples with dynamics (5.2), and the assumption is stated without justification.","section":"Section 4, helper description / Algorithm 2, line 14"}],"minor_comments":[{"comment":"The title and running header contain typographical errors: 'P A TH' and 'st atic' should be corrected.","section":"Title and running header"},{"comment":"The labeling rule is under-specified: the quantifier over x_n is missing and the wavefront propagation condition is unclear. It should be rewritten as a standard multi-source BFS labeling.","section":"Algorithm 2, line 4"},{"comment":"Both captions describe the 'first scenario in Case 2'; one of them should refer to the second subcase, i.e., persistent obstacles with continuous emergence.","section":"Figures 5 and 6"},{"comment":"The conclusion says the approach 'integrates a temporal dimension into the state space,' but neither Algorithm 1 nor Algorithm 2 explicitly constructs a time-augmented state space; the connection should be clarified.","section":"Section 6"}],"recommendation":"reject","confidential_remarks":"The manuscript reads like an early preprint. The attached Python scripts are a positive reproducibility feature, but the absence of any quantitative evaluation and the internal inconsistency in Algorithm 1 make the paper unsuitable for publication in its current form. A corrected algorithm, formal statements, and benchmark experiments would constitute substantially new work; on the present submission I recommend reject."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this is a periodic replanning loop around a static planner. That idea is not new, and the paper doesn't engage with the existing dynamic planning literature (D* Lite, receding-horizon MPC). The bigger problem is that Algorithm 1 multiplies T each cycle, so the replanning interval quickly exceeds the distortion time in Assumption 1. The planner is then executing a plan for longer than the environment is assumed stable, with no collision check in between. That is an internal inconsistency, not just a missing proof. The stress-test note is right.\n\nWhat the paper does well: the writeup is clear about the four environmental cases, the code is attached, and the conclusion openly admits that the algorithm can fail when obstacles block a necessary doorway. That honesty is worth something. Also the 3D drone dynamics in (5.2) are a reasonable test case.\n\nSoft spots: path[T] is never defined properly—Algorithm 2 returns a discrete waypoint list, not a time-parameterized trajectory, so path[T] is either an index into a list (confusing T, a time span, with an integer index) or undefined. The completeness statement in Section 5 is hand-wavy and doesn't follow from anything. The empirical evaluation is figures only; no numbers, no success rates, no comparison to any baseline. The citation list includes standard planners but misses the established dynamic-planning methods, which makes the novelty claim hard to evaluate.\n\nMy take: the central argument does not hold as stated. The algorithm on the page cannot guarantee collision-free navigation even under the paper's own assumption. The simulations are illustrative but not evidence of a working method. I would not send this to peer review in its current form; it needs a corrected algorithm, a baseline comparison, and quantitative results. If the author fixes the T update and adds proper evaluation, there might be a modest useful note here about planner-agnostic replanning, but as it stands the paper is not ready for referees.","headline":"Periodic replanning wrapper that violates its own stability assumption; simulations are illustrative, not evidential.","tokens_in":11345,"tokens_out":3188,"would_cite":false,"duration_ms":31631,"reading_group":"no","serious_thinker":"no","would_accept_peer_review":false},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This work claims that a periodic re-planning wrapper over any static planner can guide a robot through static and dynamic obstacles by re-solving the planning problem at every distortion time T.","keywords":["path planning","dynamic environment","collision avoidance","on-the-go re-planning","distortion time","autonomous navigation","motion planning","kinodynamic constraints"],"falsifier":"Construct a scenario where a dynamic obstacle enters the agent's current cell at a time strictly less than T after the last re-plan, so the agent's position path[T] is already occupied and the next re-plan starts from a colliding state. If the planner does not detect the collision and re-route before execution, the algorithm fails to guarantee collision-free navigation, contradicting the completeness claim. A second test: in Case 4, have the adversary block the only corridor to the goal during the agent's motion and verify whether the algorithm stops with 'Road blocked completely'.","tokens_in":10362,"feed_emoji":"🤖","tokens_out":8896,"duration_ms":80403,"temperature":0.7,"pith_summary":"The paper tries to establish that a dynamic motion planning problem can be reduced to repeated calls to a static planner, provided the environment stays unchanged for a 'distortion time' T between changes. The proposed On-the-Go Motion Planning Algorithm (Algorithm 1) plans a path, advances the agent to the state reached after T, updates the environment according to one of four cases of obstacle dynamics, and replans; the example planner is a grid-discretization algorithm with kinodynamic support (Algorithm 2). The author argues this scheme is complete in the sense of actively seeking solutions within each distortion window, and validates it in 2D and 3D simulations with and without drone dynamics. If correct, the result gives a drop-in upgrade to existing static planners facing real-world moving obstacles.","feed_headline":"Re-running a static planner every T handles dynamic obstacles","feed_subtitle":"Wrapping any static planner, it re-plans every distortion window to avoid sudden obstacles.","key_machinery":"Algorithm 1 (the On-the-Go Motion Planning Algorithm) is the mechanism: a while loop that calls a static planner P, moves the agent to path[T], adjusts the environment, and grows T by a factor of the step counter. Algorithm 2 (a discretized planner with labeling function L and optional kinodynamic constraint handling via IsSatisfiesDynamicConstraint) serves as the concrete instantiation of P used in the experiments. The distortion time T is the pivotal quantity: it defines the re-planning horizon and must be long enough for the static planner to find a path but short enough to stay valid under the environment's dynamics.","core_discovery":"The central claim is that the temporal dynamics of the environment can be bounded by the distortion time T, and that re-planning over that window turns a deterministic static planner into a dynamic one. The paper asserts that for Cases 1 and 2 (random and disappearing obstacles) the agent always reaches the goal, while for Cases 3 and 4 (adversarial obstacles) the planner may return 'Road blocked completely' when no continuation exists. This is demonstrated in 2D and 3D experiments where the planner adjusts the initial path as new obstacles appear, with each run completing in at most 6 seconds. The completeness statement is therefore conditional: the planner seeks solutions during each distortion window, but adversarial dynamics can still cause failure.","pith_inferences":["The scheme is a receding-horizon planner with a fixed horizon T; making T adaptive to observed change rates, or triggering re-planning on collision detection before T expires, would likely weaken Assumption 1 and improve responsiveness.","The paper's four cases form a taxonomy of obstacle dynamics; the same wrapper could be combined with sampling-based planners (RRT, PRM) for high-dimensional spaces, though only a grid-discretized planner is tested here.","If the static planner P is incomplete, the dynamic wrapper inherits that incompleteness; the completeness claim is therefore only as strong as the planner it wraps."],"forward_implications":["Existing deployment of static planners in warehouses, city streets, or drone corridors can gain dynamic-obstacle handling by wrapping the planner in Algorithm 1 without changing its core.","When the environment is genuinely stable for at least T, the agent is guaranteed to reach the goal through Cases 1 and 2, provided the underlying planner never fails.","In adversarial environments (Cases 3 and 4), the planner explicitly returns 'Road blocked completely' when the adversary blocks all routes, providing a clean failure signal for a supervisor.","The growth of T by a counter reduces replanning frequency over the run, which lowers computational load in calm environments."],"supporting_citations":[{"why":"Serves as the inspiration for Algorithm 2, contributing the discretized real-time planning and trajectory-optimization approach used as the static planner in experiments.","marker":"[XWD+12]"},{"why":"Provides the discrete-abstraction technique for planning in polygonal environments that underlies the partition and labeling scheme in Algorithm 2.","marker":"[BIP05]"},{"why":"Grounds the finite-abstraction construction used to discretize the state space into cells with representative points, a step Algorithm 2 relies on.","marker":"[ALZ23]"},{"why":"Extends the finite-abstraction framework to interconnected systems, reinforcing the discretization step that turns the continuous workspace into a labeled grid.","marker":"[AZ24b]"}],"fun_headline_variants":["Re-plan every T to dodge dynamic obstacles","Static planner? Re-plan each distortion window","Bounded distortion time: re-plan to handle moving objects","Distortion-bounded re-planning dodges obstacles","Re-plan each T: static plans go dynamic"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The environment must remain fixed for the entire distortion time T between re-planning cycles, and in the adversarial cases obstacles must never appear on the portion of the path the agent has already traversed.","fun_headline_variants_meta":{"raw":{"variants":["Re-plan every T to dodge dynamic obstacles","Static planner? Re-plan each distortion window","Bounded distortion time: re-plan to handle moving objects","Distortion-bounded re-planning dodges obstacles","Re-plan each T: static plans go dynamic"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000814,"raw_usage":{"total_tokens":3509,"prompt_tokens":827,"completion_tokens":2682,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":443,"completion_tokens_details":{"reasoning_tokens":2609}},"tokens_in":443,"tokens_out":2682,"duration_ms":20022,"temperature":1.0,"reasoning_tokens":2609,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T17:59:46.790835+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Construct a scenario where a dynamic obstacle enters the agent's current cell at a time strictly less than T after the last re-plan, so the agent's position path[T] is already occupied and the next re-plan starts from a colliding state. If the planner does not detect the collision and re-route before execution, the algorithm fails to guarantee collision-free navigation, contradicting the completeness claim. A second test: in Case 4, have the adversary block the only corridor to the goal during the agent's motion and verify whether the algorithm stops with 'Road blocked completely'.","supporting_citations":[],"review_version":1}