Temporal Simple Path Graph (tspG)

• Temporal Simple Path Graph (tspG) is the subgraph containing all simple temporal s-t paths within a specified time interval without revisiting vertices.
• The method uses a two-stage polynomial-time upper-bound construction (QuickUBG and TightUBG) followed by bidirectional DFS-based escape edge verification to ensure exact extraction.
• Applications in epidemiology, finance, and travel planning demonstrate the efficiency of VUG, significantly reducing computational costs compared to full path enumeration.

Searching arXiv for the specified paper to ground the article and citation metadata. Using the arXiv search tool to verify (Tang et al., 14 Jul 2025) and related metadata. The temporal simple path graph, denoted $tspG$, is the subgraph consisting of all temporal simple paths from a source vertex to a target vertex within a given time interval. In "Efficient Temporal Simple Path Graph Generation" (Tang et al., 14 Jul 2025), the problem is proposed and investigated for the first time in the setting of directed temporal graphs. The central objective is to generate $tspG_{[\tau_b,\tau_e]}(s,t)$ exactly, while avoiding the computational expense of directly enumerating all temporal simple paths. The paper addresses this by combining a polynomial-time upper-bound construction with a subsequent verification stage that removes residual false positives without exhaustively enumerating all temporal simple $s$-$t$ paths.

1. Formal model and definition of $tspG$

A directed temporal graph is a triple

$\mathcal G=(V,E,T),$

where $V$ is a finite set of vertices, $T\subseteq\mathbb Z$ is a set of integer timestamps, and $E\subseteq V\times V\times T$ is a set of directed temporal edges. Each edge $e=(u,v,\tau)\in E$ represents an interaction from $tspG_{[\tau_b,\tau_e]}(s,t)$0 to $tspG_{[\tau_b,\tau_e]}(s,t)$1 at time $tspG_{[\tau_b,\tau_e]}(s,t)$2. For each vertex $tspG_{[\tau_b,\tau_e]}(s,t)$3, the paper writes

$tspG_{[\tau_b,\tau_e]}(s,t)$4

and assumes that every neighbor-list $tspG_{[\tau_b,\tau_e]}(s,t)$5 and $tspG_{[\tau_b,\tau_e]}(s,t)$6 is sorted by the timestamp component.

Fix a time interval $tspG_{[\tau_b,\tau_e]}(s,t)$7. A temporal path from $tspG_{[\tau_b,\tau_e]}(s,t)$8 to $tspG_{[\tau_b,\tau_e]}(s,t)$9 in $s$0 is a sequence of edges

$s$1

such that

$s$2

Its length is $s$3, and $s$4 denotes the set of all such paths. A temporal simple path is a temporal path that never revisits a vertex, that is, $s$5 for all $s$6. The subset of simple temporal paths is denoted

$s$7

Let $s$8. The vertex and edge sets induced by all simple temporal $s$9-$t$0 paths are

$t$1

The temporal simple path graph is then

$t$2

This formulation makes the object of interest a subgraph rather than a single path. A plausible implication is that the task is not only to determine whether $t$3 reaches $t$4, but to isolate the exact edge-and-vertex support of all simple temporal $t$5-$t$6 connectivity within the interval.

2. Problem statement and computational objective

The input is a directed temporal graph $t$7, two query vertices $t$8, and a time interval $t$9. The output is $tspG$0 (Tang et al., 14 Jul 2025).

The paper also gives two alternative formulations. In decision form, the question is: does an edge $tspG$1 lie on some simple temporal path from $tspG$2 to $tspG$3 in $tspG$4? In optimization form, the goal is to compute the minimal subgraph $tspG$5 such that every simple temporal $tspG$6-$tspG$7 path in $tspG$8 is contained in $tspG$9.

These formulations distinguish existence testing from exact subgraph generation. The distinction is consequential because direct enumeration of all temporal simple paths and then taking their union is computationally expensive, whereas the target output is only the minimal subgraph covering all such paths, not the explicit list of paths themselves.

3. Verification in Upper-bound Graph

The proposed method is Verification in Upper-bound Graph (VUG). Rather than enumerating all simple paths, VUG first builds a polynomial-time upper-bound graph $\mathcal G=(V,E,T),$0 that over-approximates $\mathcal G=(V,E,T),$1, and then verifies each edge in $\mathcal G=(V,E,T),$2 to prune those that cannot appear on any simple temporal $\mathcal G=(V,E,T),$3-$\mathcal G=(V,E,T),$4 path (Tang et al., 14 Jul 2025).

The first stage is Quick Upper-bound Graph, or QuickUBG, which performs temporal-only pruning. For each vertex $\mathcal G=(V,E,T),$5, the earliest arrival time is

$\mathcal G=(V,E,T),$6

and for each $\mathcal G=(V,E,T),$7, the latest departure time is

$\mathcal G=(V,E,T),$8

The temporal-existence lemma states that an edge $\mathcal G=(V,E,T),$9 lies on some, not necessarily simple, path $V$0 in $V$1 if and only if

$V$2

QuickUBG computes $V$3 and $V$4 by two BFS-like scans in $V$5, and then forms

$V$6

The construction time is $V$7, and the space is $V$8.

The second stage is Tight Upper-bound Graph, or TightUBG, which adds simple-path pruning. The key idea is that an edge may survive temporal pruning but still only occur in paths that revisit some vertex twice. To detect this, the paper defines time-stream common vertices. For any $V$9 and any $T\subseteq\mathbb Z$0,

$T\subseteq\mathbb Z$1

which is the set of vertices other than $T\subseteq\mathbb Z$2 that lie on every simple temporal path from $T\subseteq\mathbb Z$3 to $T\subseteq\mathbb Z$4 arriving by time $T\subseteq\mathbb Z$5. Similarly,

$T\subseteq\mathbb Z$6

The paper states that one only needs to store $T\subseteq\mathbb Z$7 for each incoming timestamp to $T\subseteq\mathbb Z$8 in $T\subseteq\mathbb Z$9 and $E\subseteq V\times V\times T$0 for each outgoing timestamp from $E\subseteq V\times V\times T$1, and that each $E\subseteq V\times V\times T$2-set can be computed by a single pass over $E\subseteq V\times V\times T$3 in time $E\subseteq V\times V\times T$4.

For an edge $E\subseteq V\times V\times T$5, let

$E\subseteq V\times V\times T$6

The necessary condition for surviving simple-path pruning is

$E\subseteq V\times V\times T$7

If the intersection is non-empty, then every way to reach $E\subseteq V\times V\times T$8 meets every way out of $E\subseteq V\times V\times T$9 at a common vertex, so $e=(u,v,\tau)\in E$0 can never be on a simple path $e=(u,v,\tau)\in E$1, and it is deleted.

TightUBG processes each edge in nondecreasing time order, computes $e=(u,v,\tau)\in E$2 by two pointer walks, fetches the two sets in $e=(u,v,\tau)\in E$3, intersects them in $e=(u,v,\tau)\in E$4, and keeps the edge if and only if the intersection is empty, or $e=(u,v,\tau)\in E$5, or $e=(u,v,\tau)\in E$6. The result is $e=(u,v,\tau)\in E$7. The time is $e=(u,v,\tau)\in E$8, and the space is $e=(u,v,\tau)\in E$9.

Component	Function	Complexity
QuickUBG	Temporal-only pruning via $tspG_{[\tau_b,\tau_e]}(s,t)$00	$tspG_{[\tau_b,\tau_e]}(s,t)$01 time; $tspG_{[\tau_b,\tau_e]}(s,t)$02 space
TightUBG	Adds simple-path pruning using $tspG_{[\tau_b,\tau_e]}(s,t)$03 and $tspG_{[\tau_b,\tau_e]}(s,t)$04	$tspG_{[\tau_b,\tau_e]}(s,t)$05 time; $tspG_{[\tau_b,\tau_e]}(s,t)$06 space
$tspG_{[\tau_b,\tau_e]}(s,t)$07	Tight upper-bound graph	Over-approximation of $tspG_{[\tau_b,\tau_e]}(s,t)$08

A common misunderstanding would be to treat $tspG_{[\tau_b,\tau_e]}(s,t)$09 as the exact answer. The paper does not do so: $tspG_{[\tau_b,\tau_e]}(s,t)$10 is explicitly an upper bound, and exactness is obtained only after the subsequent verification phase.

4. Escape Edges Verification and exactness

After constructing $tspG_{[\tau_b,\tau_e]}(s,t)$11, the remaining task is to remove edges that satisfy temporal and simple-path conditions individually but still cannot lie on any simple temporal $tspG_{[\tau_b,\tau_e]}(s,t)$12-$tspG_{[\tau_b,\tau_e]}(s,t)$13 path. The paper addresses this by Escape Edges Verification (EEV), which tests each remaining edge via a bidirectional DFS, with several accelerations (Tang et al., 14 Jul 2025).

The first acceleration is batch edge confirmation. If

$tspG_{[\tau_b,\tau_e]}(s,t)$14

is a simple temporal $tspG_{[\tau_b,\tau_e]}(s,t)$15-$tspG_{[\tau_b,\tau_e]}(s,t)$16 path in $tspG_{[\tau_b,\tau_e]}(s,t)$17, then for any $tspG_{[\tau_b,\tau_e]}(s,t)$18, every other edge $tspG_{[\tau_b,\tau_e]}(s,t)$19 with $tspG_{[\tau_b,\tau_e]}(s,t)$20 also lies on some simple $tspG_{[\tau_b,\tau_e]}(s,t)$21 path. Once one such path is identified, all edges that share the same endpoints and fall into the corresponding time window can therefore be marked as verified in one batch.

The second acceleration is the two-hop shortcuts lemma. Any edge adjacent to $tspG_{[\tau_b,\tau_e]}(s,t)$22 or $tspG_{[\tau_b,\tau_e]}(s,t)$23, or within one hop thereof, is automatically verified, because only one step is needed to get away from $tspG_{[\tau_b,\tau_e]}(s,t)$24 or one more step is needed to reach $tspG_{[\tau_b,\tau_e]}(s,t)$25.

The third acceleration is a bidirectional DFS with search-order heuristics. The search proceeds simultaneously forward from $tspG_{[\tau_b,\tau_e]}(s,t)$26 toward $tspG_{[\tau_b,\tau_e]}(s,t)$27 and backward toward $tspG_{[\tau_b,\tau_e]}(s,t)$28, toggling direction as soon as one side completes. If $tspG_{[\tau_b,\tau_e]}(s,t)$29, the search starts forward; otherwise it starts backward. In forward search, later outgoing edges are explored first, and in backward search, earlier incoming edges are explored first.

The EEV procedure is summarized as follows. First, mark as verified all edges within two hops of $tspG_{[\tau_b,\tau_e]}(s,t)$30 or $tspG_{[\tau_b,\tau_e]}(s,t)$31. Second, for every unverified edge $tspG_{[\tau_b,\tau_e]}(s,t)$32 in time order, launch the bidirectional DFS to find any simple path $tspG_{[\tau_b,\tau_e]}(s,t)$33 that uses $tspG_{[\tau_b,\tau_e]}(s,t)$34; if one is found, extract the sequence of edges on that path and batch-confirm all endpoint-equivalent edges in the appropriate time windows. Third, the union of all verified edges is exactly $tspG_{[\tau_b,\tau_e]}(s,t)$35.

The correctness statement is explicit: every edge in $tspG_{[\tau_b,\tau_e]}(s,t)$36 must survive both the upper-bound checks and eventually be verified by being witnessed on some simple path; conversely, anything verified is on a valid simple path by construction. The worst-case time is also explicit: in the pathological case of very large degree $tspG_{[\tau_b,\tau_e]}(s,t)$37 and long interval $tspG_{[\tau_b,\tau_e]}(s,t)$38, a single bidirectional DFS can cost up to $tspG_{[\tau_b,\tau_e]}(s,t)$39, while the space is $tspG_{[\tau_b,\tau_e]}(s,t)$40. The paper further states that in practice the two-hop shortcuts, batch-confirmation, and tight upper-bound graph make EEV extremely fast.

5. Empirical behavior on real-world temporal graphs

The experimental evaluation uses ten real-world temporal graphs from SNAP/KONECT (Tang et al., 14 Jul 2025). The reported datasets are: D1 email-Eu ($tspG_{[\tau_b,\tau_e]}(s,t)$41 V, $tspG_{[\tau_b,\tau_e]}(s,t)$42 M E, span $tspG_{[\tau_b,\tau_e]}(s,t)$43); D2-D4 StackExchange subsets ($tspG_{[\tau_b,\tau_e]}(s,t)$44 K-$tspG_{[\tau_b,\tau_e]}(s,t)$45 K V, $tspG_{[\tau_b,\tau_e]}(s,t)$46-$tspG_{[\tau_b,\tau_e]}(s,t)$47 M E, span $tspG_{[\tau_b,\tau_e]}(s,t)$48-$tspG_{[\tau_b,\tau_e]}(s,t)$49); D5-D7 Wikipedia edits/talk ($tspG_{[\tau_b,\tau_e]}(s,t)$50-$tspG_{[\tau_b,\tau_e]}(s,t)$51 M V, $tspG_{[\tau_b,\tau_e]}(s,t)$52-$tspG_{[\tau_b,\tau_e]}(s,t)$53 M E, span up to $tspG_{[\tau_b,\tau_e]}(s,t)$54); D8 Flickr ($tspG_{[\tau_b,\tau_e]}(s,t)$55 M V, $tspG_{[\tau_b,\tau_e]}(s,t)$56 M E, span $tspG_{[\tau_b,\tau_e]}(s,t)$57); D9 SO full ($tspG_{[\tau_b,\tau_e]}(s,t)$58 M V, $tspG_{[\tau_b,\tau_e]}(s,t)$59 M E, span $tspG_{[\tau_b,\tau_e]}(s,t)$60); and D10 Wiki full ($tspG_{[\tau_b,\tau_e]}(s,t)$61 M V, $tspG_{[\tau_b,\tau_e]}(s,t)$62 M E, span $tspG_{[\tau_b,\tau_e]}(s,t)$63).

The baselines are EPdtTSG, defined as project to $tspG_{[\tau_b,\tau_e]}(s,t)$64 plus enumerate; EPesTSG, defined as "esTSG" temporal-only prune plus enumerate; and EPtgTSG, defined as "tgTSG" Dijkstra-style prune plus enumerate. The metrics are total time for $tspG_{[\tau_b,\tau_e]}(s,t)$65 random $tspG_{[\tau_b,\tau_e]}(s,t)$66 queries where a path exists, and peak memory.

The reported results are specific. VUG is $tspG_{[\tau_b,\tau_e]}(s,t)$67-$tspG_{[\tau_b,\tau_e]}(s,t)$68 faster than any enumeration-based baseline. On D9 and D10, the baselines time out at $tspG_{[\tau_b,\tau_e]}(s,t)$69 h, while VUG answers in a few minutes. VUG uses $tspG_{[\tau_b,\tau_e]}(s,t)$70 of the intermediate memory that enumeration requires, and its footprint is stable across queries. In scalability experiments with respect to $tspG_{[\tau_b,\tau_e]}(s,t)$71, the baselines grow exponentially, while VUG grows roughly linearly.

The paper also quantifies the quality of the upper bounds. QuickUBG already reduces $tspG_{[\tau_b,\tau_e]}(s,t)$72 by $tspG_{[\tau_b,\tau_e]}(s,t)$73-$tspG_{[\tau_b,\tau_e]}(s,t)$74. TightUBG further reduces the graph to within $tspG_{[\tau_b,\tau_e]}(s,t)$75-$tspG_{[\tau_b,\tau_e]}(s,t)$76 of the final $tspG_{[\tau_b,\tau_e]}(s,t)$77, so only a few edges remain to verify. EEV itself is almost negligible cost, amounting to a few percent of total time, due to the two-hop and batch optimizations.

These results establish a consistent separation between upper-bound construction and final verification. A plausible implication is that the empirical efficiency of the overall method depends critically on producing a tight $tspG_{[\tau_b,\tau_e]}(s,t)$78 before invoking DFS-based exact verification.

6. Applications, extensions, and methodological significance

The paper lists several application domains. In epidemiology, the method can reconstruct all possible transmission chains in a time window and identify super-spreaders. In finance, it can trace all simple money-laundering loops between two accounts within a time bracket. In travel planning, it can show all viable transfer sequences from station $tspG_{[\tau_b,\tau_e]}(s,t)$79 to $tspG_{[\tau_b,\tau_e]}(s,t)$80 in the next hour. In social media, it can capture all distinct retweet cascades between influencer and target user (Tang et al., 14 Jul 2025).

The paper also states several extensions. One can add label-constraints, such as types of edges; resource-constraints, such as maximum hops; or adapt the framework to streaming updates by incremental maintenance of $tspG_{[\tau_b,\tau_e]}(s,t)$81, $tspG_{[\tau_b,\tau_e]}(s,t)$82, and the time-stream sets.

Methodologically, the work is positioned around the claim that direct enumeration of all temporal simple paths and constructing the $tspG_{[\tau_b,\tau_e]}(s,t)$83 is computationally expensive, whereas the VUG framework—QuickUBG, TightUBG, and EEV—generates the exact temporal simple path graph through polynomial preprocessing and efficient verification, thereby avoiding the combinatorial explosion of path enumeration. This suggests that $tspG_{[\tau_b,\tau_e]}(s,t)$84 generation can be treated as an exact subgraph extraction problem rather than as a path-enumeration problem, provided that temporal and simple-path constraints are incorporated early and verification is deferred to a much smaller candidate graph.