Path Correctness in Computational Systems

• Path Correctness is defined as the verification that an execution trace or path meets explicit constraints such as feasibility, optimality, and preservation.
• It spans applications across constrained routing, formal verification, graph transformations, robotics, and agent evaluation.
• The concept emphasizes using formal semantics and algorithmic rigor to ensure that all steps in a process adhere to domain-specific correctness criteria.

Path correctness denotes a family of correctness criteria in which the object under scrutiny is not merely a final state but a path, execution trace, or route together with the structural, resource, temporal, or semantic constraints that make that path acceptable. In the literature, the term ranges from feasibility and optimality of shortest paths under resource constraints, to satisfaction of temporal-logic missions along all realizations of a multi-robot run, to preservation of reachability under graph transformations, to language-independent partial correctness over all terminating execution paths, and to full-path evaluation of tool-using agents beyond final-state success (Szcześniak et al., 2022, Corcoran et al., 20 Jan 2025, Ulusoy et al., 2012, Böltz et al., 2023, Stefanescu et al., 2018, Michelakis et al., 25 Sep 2025).

1. Core meanings and recurring structure

In constrained routing, path correctness is typically the conjunction of feasibility and optimality. In the resource-constrained generalization of Dijkstra, a correct path must respect resource continuity and contiguity, and the algorithm must return exactly the non-dominated feasible labels for each vertex under a partial order that combines path cost and resource interval inclusion (Szcześniak et al., 2022). In payment channel networks, a correct path is one that respects balances and fee mechanics and is also a lowest-fee feasible path for the requested payment amount (Corcoran et al., 20 Jan 2025).

In formal verification and semantics, path correctness is often universal rather than existential. All-path reachability logic defines correctness as a property holding on all complete terminating execution paths from configurations satisfying a precondition; this generalizes Hoare-style partial correctness to nondeterministic and concurrent languages (Stefanescu et al., 2018). In robotics, the relevant object is the actual timed execution rather than the nominal plan: correctness means that every field execution induced by bounded non-deterministic travel times still satisfies the LTL mission specification, which is enforced by synchronization sequences (Ulusoy et al., 2012).

In graph transformation and abstraction, path correctness concerns preservation. The CP-algorithm for geometric graphs is correct only if removing intersecting edges still preserves connectivity, so every pair of vertices that was connected remains connected by some path in the resulting plane subgraph (Böltz et al., 2023). Correctness kernels of abstract interpretations preserve the spuriousness or non-spuriousness of abstract paths while simplifying the abstract state space, so simplification does not alter which abstract paths correspond to concrete behaviors (0910.4748).

In contemporary agent evaluation, path correctness has become explicitly process-centric. CORE models tasks as DFAs and evaluates whether an agent’s tool-use sequence aligns with valid reference paths, rather than only whether the final state is correct (Michelakis et al., 25 Sep 2025). Taken together, these works suggest a common structure: path correctness requires a formally specified path space, a criterion that distinguishes acceptable from unacceptable paths, and a proof or metric showing that the relevant algorithm, abstraction, or evaluator respects that criterion.

2. Constrained routing and optimal path selection

The paper "Generic Dijkstra: correctness and tractability" (Szcześniak et al., 2022) extends shortest-path search to networks in which paths must carry a nonempty contiguous resource interval $r=[a,b)\subseteq \Omega$ that is available on every edge. The network is a weighted directed multigraph $G=(V,E)$ with cost function $\cost:E\to\mathbb{R}_{\ge 0}$ and available units function $\AU:E\to 2^\Omega$, where $\Omega=[0,U)$. A label is $l=(\cost(l),\RI(l))$, and the algorithm maintains multiple labels per vertex because cost and resource interval inclusion induce only a strict partial order. Efficient labels are the minimal elements under this order.

The correctness proof relies on a generalized Bellman principle: $$P_s=\{(0,\Omega)\}, \qquad P_i=\min\left\{\bigcup_{e\in \mathcal I(v_i)} C_e\right\},$$ where $C_e=P_{\source(e)}\oplus e$, and $\min C$ discards dominated labels. This yields path correctness in the precise sense that every returned label represents a feasible path and no feasible label that is non-dominated is omitted. The proof also depends on monotonicity of path extension: costs do not decrease and resource intervals do not expand. A minor shortcoming in the original generic Dijkstra was that the priority queue sorted labels by cost only; the correction requires a total order on full labels, extending the partial order, because zero-cost extensions can otherwise cause a dominated label to be made permanent (Szcześniak et al., 2022).

The same section of the literature ties correctness to tractability. For each vertex, the maximum number of incomparable labels is

$S=\frac{(|\Omega|+1)|\Omega|}{2},$

so across the graph the search space is $G=(V,E)$0, polynomial rather than exponential (Szcześniak et al., 2022). This is important because the correctness proof depends on exhaustive exploration of all potentially efficient labels while pruning only labels that are already dominated.

An analogous but domain-specific formulation appears in payment channel networks. "An Analysis of the Correctness and Computational Complexity of Path Planning in Payment Channel Networks" (Corcoran et al., 20 Jan 2025) defines a correct path as one that is feasible with respect to balances and fee recurrence and optimal with respect to total fees. If $G=(V,E)$1 is the amount to be received at the destination, then the amount recurrence is

$G=(V,E)$2

with feasibility constraint $G=(V,E)$3 on each arc. The algorithm runs on the transpose graph $G=(V,E)$4, from destination to source, because fees propagate backward. Its correctness depends on a consistent fee map: $G=(V,E)$5 For Lightning-style fees $G=(V,E)$6, this consistency property holds, and the Dijkstra variant is correct and has complexity $G=(V,E)$7 (Corcoran et al., 20 Jan 2025). Without fee consistency, the paper shows that correctness can fail and the problem can be NP-hard. This makes an important negative point: Dijkstra-like routing is not automatically correct merely because edge costs are non-negative in the ordinary sense.

3. Path preservation in transformed or algebraically represented graphs

Path correctness also appears as a preservation property under graph transformation. "On the Verification of the Correctness of a Subgraph Construction Algorithm" (Böltz et al., 2023) studies the CP-algorithm, which removes edges from a geometric graph satisfying redundancy and coexistence properties to obtain a connected, non-intersecting subgraph. Here correctness means that connectivity is preserved: after planarization, there are still paths between all pairs of vertices that were originally connected. The proof uses three lemmas: every deleted edge has an intersecting edge in the retained set $G=(V,E)$8; there exists an edge between components whose intersecting $G=(V,E)$9-edges lie on one side; and a convex-hull path between carefully chosen vertices consists entirely of $\cost:E\to\mathbb{R}_{\ge 0}$0-edges. These lemmas yield the main theorem that the output is a connected plane spanning subgraph (Böltz et al., 2023).

This correctness argument is notable because it is formalized in first-order logic plus an axiomatization of plane geometry and verified with Z3. Paths are represented via linked lists on convex hulls rather than as arbitrary graph-theoretic sequences, precisely because unrestricted connectivity is not first-order definable. The result is a path-preservation theorem stated at the level of reachability but proved through local geometric invariants.

A more abstract, algebraic treatment appears in "Relational Characterisations of Paths" (Berghammer et al., 2018). There, a graph is a binary relation $\cost:E\to\mathbb{R}_{\ge 0}$1, and a path is defined algebraically as a relation that is injective, univalent, and connected. Start and end points are given by relational expressions,

$\cost:E\to\mathbb{R}_{\ge 0}$2

and cycles are characterized by

$\cost:E\to\mathbb{R}_{\ge 0}$3

The paper develops rooted and unrooted path characterizations, shows how concatenation and cycle-breaking preserve path structure, and verifies three graph algorithms in Isabelle/HOL (Berghammer et al., 2018). In this setting, path correctness is the fact that algorithm outputs satisfy these algebraic path laws.

A related preservation notion appears in "Correctness Kernels of Abstract Interpretations" (0910.4748). There, correctness kernels simplify abstract domains while preserving the same best correct approximation of selected concrete semantic functions. In abstract model checking, the corresponding simplification preserves the spuriousness of examples, meaning that if an abstract path is spurious after simplification, it abstracts a spurious path from the original abstraction. This places path correctness at the interface between abstraction refinement and path-based counterexample analysis (0910.4748).

4. Path correctness in semantics and proof systems

In operational semantics, path correctness is explicitly quantified over execution paths. "All-Path Reachability Logic" (Stefanescu et al., 2018) defines an all-path reachability rule $\cost:E\to\mathbb{R}_{\ge 0}$4 to mean that for every complete terminating path starting from a configuration satisfying $\cost:E\to\mathbb{R}_{\ge 0}$5, some configuration along that path satisfies $\cost:E\to\mathbb{R}_{\ge 0}$6. This semantics captures partial correctness for nondeterministic and concurrent languages. The proof system takes unconditional operational semantics as axioms, uses a Step rule to reason over all enabled semantic rules, and includes a Circularity rule for coinductive reasoning about loops and recursion. The paper proves soundness, mechanized in Coq, and relative completeness under the stated assumptions (Stefanescu et al., 2018).

This formulation clarifies an important distinction: path correctness is not merely a may-reach property. One-path reachability corresponds to existential path semantics; all-path reachability is universal over complete paths. The latter is the appropriate notion when correctness claims must survive all schedulings or all nondeterministic branch resolutions.

A different but related foundation is developed in "Left properness of flows" (Gaucher, 2019). The paper gives a correct Reedy-based proof of the left properness of the q-model structure on flows and analyzes how the path space functor $\cost:E\to\mathbb{R}_{\ge 0}$7 interacts with cofibrations and weak equivalences. The earlier proof had relied on an incorrect subdiagram; the correction introduces a Reedy category $\cost:E\to\mathbb{R}_{\ge 0}$8 and a diagram $\cost:E\to\mathbb{R}_{\ge 0}$9 whose colimit computes the path space of a pushout. This establishes that pushouts along q-cofibrations preserve weak equivalences and that the path space functor preserves q-cofibrancy in the relevant cases (Gaucher, 2019). Here path correctness is homotopical: path spaces must be constructed and transformed in a way that preserves the intended weak equivalence structure.

These two literatures meet on a shared methodological point. Whether paths are program executions or execution spaces in directed homotopy, correctness depends on using a formal semantics that is strong enough to support induction, composition, and mechanization, but precise enough to rule out apparently plausible yet invalid proof steps.

5. Robotics, control software, and evolving systems

In multi-robot planning, path correctness extends beyond nominal path synthesis to execution under uncertainty. "Optimal Multi-Robot Path Planning with LTL Constraints: Guaranteeing Correctness Through Synchronization" (Ulusoy et al., 2012) models each robot as a weighted transition system, constructs a team transition system, and seeks runs satisfying

$\AU:E\to 2^\Omega$0

while minimizing

$\AU:E\to 2^\Omega$1

Because actual travel times are non-deterministic within robot-specific bounds, nominally correct runs may violate the LTL mission during deployment. The paper restores correctness by synthesizing synchronization sequences $\AU:E\to 2^\Omega$2, where each step $\AU:E\to 2^\Omega$3 contains a wait-set and a notify-set. A model-checking procedure then removes unnecessary synchronization edges only when every admissible field execution still satisfies $\AU:E\to 2^\Omega$4. The final guarantee is that the actual team word $\AU:E\to 2^\Omega$5 always satisfies the mission, together with the bound

$\AU:E\to 2^\Omega$6

(Ulusoy et al., 2012). In this setting, path correctness means robust satisfaction of temporal specifications by all timed realizations of the planned paths.

A version of the same concern appears in industrial software evolution. "Verifying Correctness of PLC Software during System Evolution using Model Containment Approach" (Bandyopadhyay et al., 6 Sep 2025) translates old and upgraded SFC programs into Petri nets $\AU:E\to 2^\Omega$7 and $\AU:E\to 2^\Omega$8 and defines correctness of the upgrade as model containment,

$\AU:E\to 2^\Omega$9

meaning that every relevant computation of the original has an equivalent computation in the upgrade. The core relation is symbolic path equivalence: for a path $\Omega=[0,U)$0 in $\Omega=[0,U)$1 and $\Omega=[0,U)$2 in $\Omega=[0,U)$3, correctness requires equivalent execution conditions $\Omega=[0,U)$4, identical data transformations $\Omega=[0,U)$5, corresponding cut-points, and aligned tick stamps. A finite path cover theorem then reduces containment to checking equivalence of path covers. On 80 real-world benchmarks from the OSCAT library, the paper reports nearly $\Omega=[0,U)$6 performance improvement over verifAPS (Bandyopadhyay et al., 6 Sep 2025).

These works show that path correctness in cyber-physical systems is rarely just reachability. It is usually tied to temporal structure, synchronization, or regression containment, and it is often evaluated at the level of symbolic path segments rather than isolated states.

6. Full-path evaluation and path selection in learned systems

Recent work on learned systems makes path correctness an explicit evaluation target. "CORE: Full-Path Evaluation of LLM Agents Beyond Final State" (Michelakis et al., 25 Sep 2025) models each task as a DFA

$\Omega=[0,U)$7

executes the agent’s tool-call path $\Omega=[0,U)$8, condenses it by removing self-loops, and defines Path Correctness as the best normalized-Levenshtein similarity against a golden path: $\Omega=[0,U)$9 The framework also defines Path Correctness–Kendall’s tau Composite, Prefix Criticality, Harmful-Call Rate, and Efficiency. The central claim is that final-state evaluation can obscure major differences in safety, efficiency, and intermediate correctness: an agent can reach the right state through a path that is harmful, inefficient, or inconsistent with the expected execution pattern (Michelakis et al., 25 Sep 2025).

A different use of the term appears in symbolic execution. "Empc: Effective Path Prioritization for Symbolic Execution with Path Cover" (Yao et al., 6 May 2025) treats path prioritization as a minimum path cover problem on the inter-procedural CFG. Instead of heuristically ranking exponentially many paths, Empc computes multiple MPCs on transformed DAG subgraphs, uses them to guide symbolic execution, and employs dependence-guided recovery when intended MPC paths are infeasible. The evaluation reports $l=(\cost(l),\RI(l))$0 more covered basic blocks than KLEE’s best search strategy, $l=(\cost(l),\RI(l))$1 more covered lines than cgs, 24 more security violations than KLEE’s best strategy, and memory reduction by up to $l=(\cost(l),\RI(l))$2 (Yao et al., 6 May 2025). This suggests a connection between path correctness and path selection: some path subsets are structurally far more informative for correctness analysis than others.

Two code- and reasoning-oriented papers extend the discussion from explicit paths to probabilistic trust in candidate paths. "Calibration and Correctness of LLMs for Code" (Spiess et al., 2024) distinguishes exact-match correctness from test-passing correctness and shows that generative code models are often poorly calibrated out of the box, while Platt scaling can materially improve calibration for several tasks. The paper explicitly treats test-passing correctness as the behavioral notion closest to path-level correctness on the execution paths exercised by tests. "Sample Smart, Not Hard: Correctness-First Decoding for Better Reasoning in LLMs" (Li et al., 7 Oct 2025) then argues that low-confidence steps in reasoning tasks are often epistemically bad rather than benign branching points, and proposes Greedy-Threshold, Calibrated-TopK, and Calibrated-$l=(\cost(l),\RI(l))$3 to sample from tokens with higher estimated correctness. The empirical result is better maj@k or pass@k on reasoning benchmarks by improving the expected correctness of the sampled reasoning paths (Li et al., 7 Oct 2025).

Taken together, these papers make an important methodological correction. Path correctness is not exhausted by whether a process terminates in the right state, nor by whether a model expresses high confidence. Correctness can depend on the entire sequence of actions or tokens, on whether harmful intermediate steps occur, and on whether path sampling is calibrated to correctness rather than uncertainty alone.

7. Common failure modes and enduring themes

Several recurrent failure modes appear across the literature. Sorting labels by cost only can invalidate generic shortest-path search when zero-cost extensions exist (Szcześniak et al., 2022). Dijkstra-like path planning in payment channel networks is correct only under a consistency property on fees; without it, the problem can be NP-hard (Corcoran et al., 20 Jan 2025). Nominal multi-robot plans can violate LTL missions during deployment unless synchronization is synthesized against timing uncertainty (Ulusoy et al., 2012). Final-state evaluation can miss harmful or inefficient intermediate behaviors in agent traces (Michelakis et al., 25 Sep 2025). Raw confidence can be a poor proxy for correctness of generated code or reasoning paths unless calibrated (Spiess et al., 2024, Li et al., 7 Oct 2025).

A second recurring theme is that safe simplification is possible only when it preserves path semantics. Dominated labels may be pruned in generic Dijkstra because no optimal feasible path is lost (Szcześniak et al., 2022). Correctness kernels can simplify abstract domains while preserving the spuriousness structure of abstract paths (0910.4748). Strict and tame directed paths in higher-dimensional automata are homotopy equivalent to full path spaces, so one may operate with “nice” schedulings without altering the essential topology of executions (Raussen, 2020). These examples indicate that path correctness is compatible with abstraction and tractability, but only when the abstraction preserves the relevant path structure.

The broader implication is that path correctness is best understood not as a single invariant, but as a family of domain-specific equivalence, feasibility, and preservation conditions applied to path objects. In network optimization, those objects are routes with resources or fees. In semantics, they are terminating executions or path spaces. In robotics and PLC evolution, they are timed or symbolic execution segments. In agent evaluation, they are tool-use traces. The unifying demand is that correctness must be stated and checked at the level where path structure actually matters.