Service-Aware Temporal Betweenness Metric

• Service-Aware Temporal Betweenness is a centrality measure that extends temporal betweenness by integrating service constraints like availability, QoS, and capacity into time-respecting paths.
• It combines foundational temporal graph concepts with service attribute filters to restrict feasible traversals and adjust path cost computations.
• The metric supports diverse optimality criteria and waiting-aware dynamics, with both exact and approximate algorithms enabling practical analysis in dynamic service environments.

Searching arXiv for recent and foundational papers on temporal betweenness and service-aware adaptations. Service-Aware Temporal Betweenness Metric is a temporal-centrality construct obtained by extending temporal betweenness from time-varying graphs to paths filtered or weighted by service attributes. In the temporal-network framework, causality is enforced by the ordering of contacts, paths must be time-respecting, and centrality depends on the chosen temporal optimality notion rather than on a static footprint alone (Nicosia et al., 2013). A service-aware variant preserves these temporal notions while restricting feasible traversals to edges whose availability, quality-of-service, capacity, or type satisfy prescribed constraints, or while incorporating such attributes into path costs (Nicosia et al., 2013). Closely related developments arise from activity-driven betweenness based on observed transactions rather than full topology (Ozkaya et al., 2017), algebraic formulations over traveling semirings that attach secondary link attributes to foremost-journey computation (Praprotnik et al., 2016), exact and approximate algorithmics for temporal betweenness under multiple optimality criteria (Buß et al., 2020, Cruciani, 2023), and faster exact computation under waiting constraints in restless settings (Brunelli et al., 22 Jan 2025).

1. Temporal-graph foundations

The underlying model is a time-varying graph constructed from time-stamped contacts over a fixed node set. Let the node set be $\mathcal{N}=\{1,2,\dots,N\}$ observed over an interval $[0,T]$, and let each contact be a quadruplet $c=(i,j,t,\delta t)$, meaning that nodes $i$ and $j$ interact starting at time $t$ for duration $\delta t$ (Nicosia et al., 2013). The observation period is sliced into an ordered sequence of $M$ non-overlapping time windows $[t_m,t_m+\Delta t]$, $m=1,\dots,M$, with $[0,T]$0, and each window is associated to a snapshot $[0,T]$1 whose adjacency matrix $[0,T]$2 records whether $[0,T]$3 and $[0,T]$4 are linked during that window (Nicosia et al., 2013).

In this representation, adjacency is time-dependent: $[0,T]$5 if at least one contact $[0,T]$6 overlaps with $[0,T]$7 (Nicosia et al., 2013). Causality is enforced by the temporal ordering of contacts: information or flow may traverse a link $[0,T]$8 at time $[0,T]$9 only if the link is active at $c=(i,j,t,\delta t)$0, and successive traversals must occur at non-decreasing times (Nicosia et al., 2013). A temporal walk from $c=(i,j,t,\delta t)$1 to $c=(i,j,t,\delta t)$2 is a sequence of edges with traversal times $c=(i,j,t,\delta t)$3, and a temporal path is a temporal walk that visits each node at most once; waiting at nodes is allowed, but causal feasibility requires strictly increasing edge times (Nicosia et al., 2013).

These definitions differ materially from static graph notions. Temporal connectedness is directional: node $c=(i,j,t,\delta t)$4 is temporally connected to $c=(i,j,t,\delta t)$5 if a temporal path exists from $c=(i,j,t,\delta t)$6 to $c=(i,j,t,\delta t)$7 in the observation interval, and strong temporal connectedness requires both directions (Nicosia et al., 2013). Because strong temporal connectedness is not transitive, graph-level strongly connected components are defined as sets in which every pair of nodes is strongly temporally connected, and these correspond to maximal cliques of an affine static graph whose edges link strongly connected node pairs (Nicosia et al., 2013). This suggests that any service-aware centrality layered on top of temporal paths inherits not only time dependence but also nontrivial asymmetry in reachability.

Alternative but compatible temporal-graph formalisms appear in subsequent work. One formulation models a temporal graph as $c=(i,j,t,\delta t)$8 with discrete time steps and time edges $c=(i,j,t,\delta t)$9, together with strict and non-strict temporal walks depending on whether labels must strictly increase or merely be non-decreasing (Buß et al., 2020). Another uses a temporal multiplex with events $i$0 and explicit transfer penalties across layers (Zaoli et al., 2020). The semiring-based framework instead represents time-varying link properties as temporal quantities over a linearly ordered time domain and composes earliest-arrival functions algebraically (Praprotnik et al., 2016). These variants differ in notation, but all enforce time-respecting traversal.

2. Temporal optimality and baseline betweenness

Distances in time-varying graphs combine topological and temporal notions. A temporal path has a topological length $i$1, given by its number of edges, and a temporal length, given by the elapsed time from the first to the last edge used (Nicosia et al., 2013). The chapter’s temporal shortest path between $i$2 and $i$3 is the temporal path with minimum duration, and the corresponding temporal distance is

$i$4

This same framework also supports earliest-arrival and minimum-hop distances with waiting (Nicosia et al., 2013).

Three distance notions are explicit. The earliest-arrival distance from $i$5 to $i$6 given start time $i$7 is

$i$8

with travel time

$i$9

The fastest distance is

$j$0

which allows leaving later than $j$1 if that yields a shorter duration. The minimum-hop distance with waiting is

$j$2

subject to strictly increasing traversal times (Nicosia et al., 2013).

Temporal betweenness centrality extends static path-based betweenness by counting temporal shortest paths. For a node $j$3,

$j$4

where $j$5 is the number of temporal shortest paths between $j$6 and $j$7 according to a chosen temporal distance, and $j$8 is the number of those paths that traverse $j$9 (Nicosia et al., 2013). The general form therefore depends on the optimality criterion.

Subsequent algorithmic work systematizes this dependence. Temporal betweenness can be defined with respect to shortest, foremost, fastest, shortest-foremost, or prefix-foremost temporal paths, and strict versus non-strict labeling materially affects admissible paths (Buß et al., 2020). In that framework, for $t$0,

$t$1

and a vertex-appearance version $t$2 counts the fraction of $t$3-optimal paths that arrive at $t$4 at time $t$5 (Buß et al., 2020). This suggests that a service-aware metric can be defined either at the node level or at the vertex-appearance level, depending on whether service semantics attach to traversals, waiting, or both.

A distinct but related line generalizes geodesics on temporal multiplexes by a cost

$t$6

where $t$7 counts intra-layer events, $t$8 counts inter-layer transfers, and $t$9 is duration (Zaoli et al., 2020). A plausible implication is that service-aware temporal betweenness can also be viewed as a special case of temporal multiplex betweenness when service classes are represented as layers or as transfer-sensitive path costs.

3. Service-aware formulation

The service-aware variant described in the source material is defined by enriching temporal path feasibility with service attributes. Let each edge $\delta t$0 at time $\delta t$1 carry service attributes such as availability, quality-of-service, capacity, and type tags, encoded by a predicate or filter

$\delta t$2

which indicates whether the service constraints are satisfied at time $\delta t$3 (Nicosia et al., 2013). More generally, let attributes be functions $\delta t$4, $\delta t$5, $\delta t$6, and define service feasibility by thresholds $\delta t$7, $\delta t$8, and allowed types $\delta t$9 (Nicosia et al., 2013).

A time-respecting path $M$0 is service-feasible if for every traversal $M$1 at time $M$2,

$M$3

or equivalently

$M$4

For earliest-arrival and fastest distances, the modification is direct: traversals at times failing $M$5 are forbidden, and waiting is allowed at nodes until the next time $M$6 at which some outgoing edge satisfies $M$7 (Nicosia et al., 2013).

Service-aware path counts are then defined as

$M$8

$M$9

and the service-aware temporal betweenness is

$[t_m,t_m+\Delta t]$0

A windowed version restricts traversals to an interval $[t_m,t_m+\Delta t]$1:

$[t_m,t_m+\Delta t]$2

Normalization by $[t_m,t_m+\Delta t]$3 can be applied for comparability (Nicosia et al., 2013).

If service attributes should affect path costs rather than only feasibility, the same source proposes assigning a traversal cost $[t_m,t_m+\Delta t]$4 as a monotone function of attributes, for example

$[t_m,t_m+\Delta t]$5

and computing temporal shortest paths under additive costs while preserving causality (Nicosia et al., 2013). The chapter does not provide an explicit weighted or attribute-aware temporal path definition beyond weighted aggregated graphs, but its framework extends naturally by masking infeasible edges with $[t_m,t_m+\Delta t]$6 in $[t_m,t_m+\Delta t]$7, including waiting edges $[t_m,t_m+\Delta t]$8, and applying the same counting and centrality machinery to service-feasible paths (Nicosia et al., 2013).

The semiring framework gives a more algebraic service-aware construction. In the traveling semiring $[t_m,t_m+\Delta t]$9, each link carries not only an earliest-arrival function $m=1,\dots,M$0 but also a secondary temporal attribute $m=1,\dots,M$1 over a semiring $m=1,\dots,M$2, allowing counts, costs, reliability, or capacity to propagate along journeys (Praprotnik et al., 2016). Parallel alternatives pick the smaller arrival function and combine attributes via $m=1,\dots,M$3 on ties, while sequential composition uses

$m=1,\dots,M$4

in the notation of the source (Praprotnik et al., 2016). This permits service-aware betweenness

$m=1,\dots,M$5

where the second component of the semiring element carries service-aware aggregates rather than raw counts (Praprotnik et al., 2016). This suggests a principled way to encode reliability, capacity, or additive service cost without leaving the temporal-journey formalism.

A different adaptation emerges from Active Betweenness Cardinality. There, the metric for a node $m=1,\dots,M$6 over $m=1,\dots,M$7 is the number of distinct $m=1,\dots,M$8 tuples for a go-through node $m=1,\dots,M$9, where $[0,T]$00 and $[0,T]$01 are source and destination of the communication and $[0,T]$02 represents transaction features (Ozkaya et al., 2017). The proposed Service-Aware Temporal Betweenness extends this by introducing service tags $[0,T]$03, service importance weights $[0,T]$04, temporal windows, and optional decay:

$[0,T]$05

with per-service centralities and normalized multi-commodity aggregation also described in the source (Ozkaya et al., 2017). This is not path-enumeration betweenness in the classical sense; rather, it is an activity-driven, count-distinct analogue suited to systems where only local transaction observations are available.

4. Waiting awareness, windows, and service semantics

Temporal betweenness in time-varying graphs is not only path based but also waiting aware. The chapter defines a time-dependent temporal betweenness in which a node contributes not merely when it forwards at snapshot $[0,T]$06, but also when it holds a message up to $[0,T]$07 before forwarding later:

$[0,T]$08

where $[0,T]$09 counts temporal shortest paths $[0,T]$10 for which $[0,T]$11 is on the path and the path uses $[0,T]$12 at $[0,T]$13, or entered $[0,T]$14 before $[0,T]$15 and leaves after $[0,T]$16 (Nicosia et al., 2013). Averaging over snapshots gives

$[0,T]$17

For service-aware settings, this waiting-aware construction is important because service feasibility may depend on waiting for an edge whose QoS, capacity, or type becomes admissible only later.

A windowed formulation also appears directly:

$[0,T]$18

and the service-aware analogue inherits the same restriction to paths whose traversals lie within a selected interval (Nicosia et al., 2013). Such windows are especially relevant when service availability or policy changes over time.

The activity-driven formulation in (Ozkaya et al., 2017) makes temporal windowing explicit. It defines windowed ABC,

$[0,T]$19

and a weighted temporal version with decay,

$[0,T]$20

The service-aware extension simply conditions these counts on service labels and service-specific weights (Ozkaya et al., 2017). A plausible implication is that, when the operational question concerns distinct communicating pairs under active service use rather than all feasible optimal paths, this count-distinct windowed formulation may be more faithful than classical path-fraction betweenness.

Waiting constraints can also be made explicit through restless walks. In the restless model, a temporal graph is $[0,T]$21 with edges $[0,T]$22, and a walk is valid only if consecutive edges satisfy

$[0,T]$23

The source then generalizes to node-specific waiting intervals $[0,T]$24, requiring

$[0,T]$25

This is explicitly proposed as a way to model service-aware constraints such as minimum transfer times, mandatory dwell, and maximum transfer windows (Brunelli et al., 22 Jan 2025). In service-centric infrastructures, this restless formalization provides a natural semantics for bounded waiting, SLAs, or handoff policies.

Temporal multiplexes provide another service semantics. A time-respecting path is feasible only if

$[0,T]$26

where $[0,T]$27 captures minimum connection time and layer-switching penalty at node $[0,T]$28 (Zaoli et al., 2020). Since service classes, carriers, providers, or modes can be encoded as layers, this formulation gives a service-aware temporal betweenness in which switching penalties are part of the geodesic cost rather than external constraints.

5. Algorithms and computational complexity

Computation of temporal betweenness hinges on temporal shortest-path computation and path counting. Under the snapshot model, one can build a time-expanded network with nodes $[0,T]$29, add temporal edges $[0,T]$30 whenever $[0,T]$31, and add waiting edges $[0,T]$32 for all $[0,T]$33 and $[0,T]$34 (Nicosia et al., 2013). Earliest-arrival distances from a source at start snapshot $[0,T]$35 are solved by breadth-first search on layers if edges are unweighted, or by a Dijkstra-like label-setting procedure if waiting or traversal times induce weights; complexity is $[0,T]$36 per source for BFS-like methods in sparse graphs (Nicosia et al., 2013). Counting $[0,T]$37 can be done with dynamic programming along the DAG induced by earliest-arrival distances, similarly to Brandes-style counting but on the time-expanded graph (Nicosia et al., 2013).

The systematic complexity landscape is stricter. Counting foremost and fastest temporal paths is computationally intractable: foremost and fastest path counting, and hence the corresponding temporal betweenness values, are #P-hard in both strict and non-strict variants (Buß et al., 2020). By contrast, shortest paths and two special foremost-path cases are polynomial-time computable: shortest betweenness, shortest-foremost betweenness, and strict prefix-foremost betweenness admit polynomial-time algorithms (Buß et al., 2020). The source gives complexity $[0,T]$38 time and $[0,T]$39 space for shortest and shortest-foremost betweenness, and $[0,T]$40 time with $[0,T]$41 space for strict prefix-foremost betweenness (Buß et al., 2020).

A faster exact algorithm later improves the shortest and shortest-foremost cases to $[0,T]$42 time and $[0,T]$43 space, where $[0,T]$44 is the number of temporal edges (Brunelli et al., 22 Jan 2025). More importantly for service-aware settings, the same paper extends exact computation to restless walks, giving polynomial-time $[0,T]$45 algorithms for fastest, foremost, shortest, shortest fastest, and shortest foremost under waiting constraints (Brunelli et al., 22 Jan 2025). Since service policies often impose minimum or maximum waiting, this result is directly relevant to operational service-aware temporal betweenness.

Approximation frameworks become necessary when the chosen optimality is intractable or the graph is too large. MANTRA approximates temporal betweenness of all nodes under the polynomially feasible optimalities shortest, shortest-foremost, and prefix-foremost by progressive sampling, with an approximation algorithm whose running time is $[0,T]$46 for related temporal quantities such as diameter and average path length (Cruciani, 2023). For a sampled pair $[0,T]$47, the unbiased estimator is

$[0,T]$48

and its expectation is exactly the temporal betweenness of $[0,T]$49 under the chosen optimality (Cruciani, 2023). The same source states that service-aware MANTRA is obtained by replacing the graph with its service-filtered subgraph, skipping edges with $[0,T]$50 during constrained temporal BFS, and substituting service-feasible counts $[0,T]$51 and $[0,T]$52 into the estimator (Cruciani, 2023).

The algebraic alternative is matrix closure over the traveling semiring. The input temporal adjacency matrix is transformed entrywise to pairs $[0,T]$53, where $[0,T]$54 is the earliest-arrival function and $[0,T]$55 is the service-aware aggregate over ties. Fletcher’s closure algorithm then computes all-pairs earliest-arrival and service-aware aggregates with $[0,T]$56 semiring operations, while exclusion-based centrality requires $[0,T]$57 semiring operations overall, modulo sparsity (Praprotnik et al., 2016). This is exact but typically more costly than the shortest-path-oriented algorithms.

Activity-driven service-aware variants use different data structures. ABC uses HyperLogLog sketches to estimate count-distinct cardinalities of observed $[0,T]$58 tuples traversing a node, with relative error approximately $[0,T]$59 and $[0,T]$60 time per transaction (Ozkaya et al., 2017). Per-node HLL sketches support local SATB estimation, and per-edge HLLs support neighbor-selection strategies such as BN, RW, and BCN for discovering high-centrality nodes from a seed set (Ozkaya et al., 2017). This replaces global path enumeration by streaming local observation.

6. Related centralities, empirical behavior, and interpretive cautions

Temporal betweenness belongs to a broader family of temporal centralities. Temporal closeness is

$[0,T]$61

with $[0,T]$62 taken as temporal shortest-path duration or earliest-arrival time difference, depending on the chosen metric (Nicosia et al., 2013). Spectral centralities generalize Katz centrality to time-varying graphs by summing contributions of all time-respecting walks with geometric down-weighting:

$[0,T]$63

with broadcast and receive communicability defined by row and column sums of $[0,T]$64 (Nicosia et al., 2013). These often identify influential spreaders differently from shortest-path-based centralities (Nicosia et al., 2013). This suggests that service-aware temporal betweenness should not be interpreted as a universal influence score; it measures mediation on service-feasible optimal paths, not general communicability.

Temporal structure also exhibits link persistence and temporal small-world behavior. The topological overlap of node $[0,T]$65’s neighborhood across consecutive snapshots is

$[0,T]$66

Averaging over time and nodes gives the temporal-correlation coefficient $[0,T]$67 (Nicosia et al., 2013). Empirically, real temporal graphs such as functional brain networks, INFOCOM’06 co-location, and Facebook messaging exhibit higher $[0,T]$68 and lower characteristic temporal path length $[0,T]$69 than reshuffled counterparts, indicating temporal small-world behavior (Nicosia et al., 2013). A plausible implication is that service-aware filtering can alter both persistence and effective path length, potentially changing which nodes appear central even when the unfiltered temporal network is unchanged.

Empirical case studies confirm that temporal betweenness can diverge sharply from static centrality. In the ENRON email data, traders are ranked highly by temporal betweenness and closeness, reflecting their mediatory role over time, whereas static aggregated centralities instead elevate nodes with many aggregate contacts, such as a secretary (Nicosia et al., 2013). Simulations of spreading initiated at nodes with high temporal closeness reach more nodes faster than those started from nodes with high static closeness (Nicosia et al., 2013). Likewise, in a knowledge-mobilization network, foremost temporal betweenness uncovers nodes with negligible static centrality but important temporal roles, termed “invisible rapids,” and conversely identifies “invisible brooks” with high static but low temporal mediation (Rad et al., 2015). These examples caution against interpreting service-aware temporal betweenness through a static lens.

In scheduled networks with waiting constraints, different optimality criteria often correlate but are not interchangeable. Exact experiments show general consistency between variants, but also a sensible influence of waiting constraints and some cases of low correlation for certain pairs of criteria (Brunelli et al., 22 Jan 2025). In public transit case studies, shortest fastest and shortest foremost are strongly correlated across waiting bounds, while static betweenness on the underlying graph correlates poorly with schedule-constrained centrality, especially when waiting constraints are small (Brunelli et al., 22 Jan 2025). This supports the view that service-aware temporal betweenness is most informative when its service constraints reflect actual operational rules.

Approximate rankings exhibit similar interpretive nuances. MANTRA reports that strict versus non-strict variants of the same concept often yield very similar rankings for shortest and shortest-foremost, while foremost-type notions are more sensitive (Buß et al., 2020, Cruciani, 2023). The recommendation emerging from the exact and approximate literature is that strict prefix-foremost is often a practical proxy for earliest-arrival semantics when tractability matters (Buß et al., 2020).

7. Scope, limitations, and methodological choices

A first limitation is definitional plurality. “Temporal betweenness” is not a single metric but a family indexed by optimality criterion, strictness, waiting rules, and whether counting is path based, vertex-appearance based, or activity based (Buß et al., 2020, Ozkaya et al., 2017). A service-aware version inherits that plurality. One must therefore specify whether service awareness is implemented by filtering infeasible edges, by reweighting costs, by attaching semiring attributes, by constraining waiting, or by counting observed traffic tuples.

A second limitation is computational. Foremost and fastest counting are #P-hard in general, which implies that exact service-aware temporal betweenness under those optimalities is intractable as well unless further restrictions restore acyclicity or prefix optimality (Buß et al., 2020). The tractable cases are shortest, shortest-foremost, strict prefix-foremost, and several restless-walk variants handled by the $[0,T]$70 algorithm (Brunelli et al., 22 Jan 2025). This suggests that many practical service-aware definitions should preserve earliest arrival as a primary objective and use service cost only as a secondary tie-breaker if exact computation is required.

A third limitation concerns observability. Classical temporal betweenness assumes access to the temporal graph and path counts. ABC-style SATB instead requires only local transaction logs, but then measures distinct observed source-destination-feature tuples traversing a node rather than fractions of all optimal temporal paths (Ozkaya et al., 2017). These are different notions of criticality. A plausible implication is that the choice between them should follow the data regime: full causality-aware graph data favors path-based temporal betweenness, whereas microservice or network telemetry with incomplete topology favors activity-driven SATB.

A fourth limitation is modeling fidelity. The original chapter’s service-aware extension is explicitly natural rather than fully formalized for weighted attribute-aware paths (Nicosia et al., 2013). The semiring formulation is formally rigorous, but it focuses on ubiquitous foremost journeys and inherits the costs of temporal-quantity manipulation (Praprotnik et al., 2016). The temporal multiplex formulation offers explicit transfer penalties and non-instantaneous travel, but requires careful clone filtering in the time-expanded graph to avoid overcounting equivalent paths (Zaoli et al., 2020). The restless-walk formulation handles bounded waiting efficiently, but uses walks rather than paths because restless reachability on paths can be NP-hard (Brunelli et al., 22 Jan 2025).

Finally, normalization and comparability remain context dependent. Some formulations use $[0,T]$71 normalization (Nicosia et al., 2013, Praprotnik et al., 2016); others normalize by $[0,T]$72 over ordered pairs (Cruciani, 2023); the knowledge-mobilization study instead multiplies by a connected-component factor $[0,T]$73 to handle disconnections (Rad et al., 2015). For service-aware applications, comparability across networks or service classes requires making the normalization convention explicit.

Taken together, the literature supports a precise definition of Service-Aware Temporal Betweenness Metric as a causality-respecting centrality on temporal graphs in which path feasibility or path cost depends on service attributes. The exact form may be path-fraction based, semiring based, activity based, waiting constrained, or multiplex aware, but all faithful versions share the same core requirement: service constraints must be imposed without violating the temporal ordering that defines reachability and optimality in the first place (Nicosia et al., 2013).