Valid-Time Temporal Property Graph

• Valid-Time Temporal Property Graphs are defined as models where graph entities have temporal existence and evolving properties, supporting snapshot queries over discrete time.
• The model comprises point-based and interval-based variants that enable efficient representation and evaluation of temporal queries through techniques like coalescing and the TIM-Tree.
• Empirical results demonstrate significant storage efficiency, latency improvements, and scalable distributed query processing in dynamic networks.

A valid-time temporal property graph is a formal model for representing property graphs whose structure, properties, and/or existence evolve over a discrete time domain. Time is integral to the identity and semantics of graph entities, supporting temporal queries, analytics, and transaction processing over dynamic, real-world network data. The valid-time temporal property graph model has been systematically developed across multiple works, including foundational definitions, succinct storage schemes, application-driven design in data management systems, and distributed evaluation frameworks (Arenas et al., 2021, Song et al., 5 Dec 2025, Ramesh et al., 2020).

1. Mathematical Foundations and Model Variants

The core construct is the temporal property graph (TPG), with two principal variants: point-based and interval-based (also called interval-annotated or interval-centric).

1.1 Point-Based Valid-Time Temporal Property Graph

Let $Lab$, $Prop$, and $Val$ be sets of labels, property keys, and property values, and $\mathcal{T}$ a discrete, totally-ordered temporal domain (e.g., $\mathbb{N}$, or chronons).

A point-based TPG is a 7-tuple: $G = (\mathcal{T}, N, E, p, \lambda, \sigma, o)$ where:

• $N$: finite node set ($N \cap E = \emptyset$), $E$: finite edge set.
• $p: E \to N \times N$: assigns each edge to ordered node pair.
• $\lambda: (N \cup E) \to Lab$: object labeling.
• $$\sigma: (N \cup E) \times \mathcal{T} \to \{\mathrm{true}, \mathrm{false}\}$$: existence predicate; if $\sigma(e, t) = \mathrm{true}$ and $p(e) = (v_1, v_2)$ then $\sigma(v_1, t) = \sigma(v_2, t) = \mathrm{true}$.
• $$o: (N \cup E) \times Prop \times \mathcal{T} \nrightarrow Val$$: (partial) temporal property function, defined only when $\sigma(o,t) = \mathrm{true}$.

This model encodes the state of the property graph as a "snapshot" at each $t \in \mathcal{T}$ (Arenas et al., 2021).

1.2 Interval-Annotated Temporal Property Graph

To reduce redundancy in the point-wise representation, the interval-based ITPG model compresses contiguous runs of existence or property values into maximal intervals: $I = (Q, N, E, p, \lambda, \sigma', o')$ where $Q = [a, b]$ is an interval, $N,E,p,\lambda$ as above,

• $\sigma': (N \cup E) \to FC(Q)$: mapping each object to a family of coalesced intervals (adjacent or overlapping, with the same annotation, are merged).
• $o': (N \cup E) \times Prop \to vFC(Q)$: each property mapped to a value-labeled, non-overlapping interval sequence.

Both the point-wise and interval models support full semantic expansion to the canonical pointwise form (Arenas et al., 2021).

1.3 Chronons, Intervals, and Time Interval Series

A chronon $\tau$ is a discrete, non-decomposable time unit. A time interval $I = [\tau_s, \tau_e)$ represents half-open intervals; $\tau_s < \tau_e$. The Time Interval Series (TIS) encodes sequences of intervals with associated property values: $$\Psi = \langle (I_1,v_1), (I_2,v_2), \dots, (I_n,v_n) \rangle$$ with $I_j$ non-overlapping, consecutive, and coalesced if $v_j = v_{j+1}$ (Song et al., 5 Dec 2025).

1.4 Additional Constraints

Valid-time temporal property graphs enforce:

• Referential integrity: An edge exists only when both endpoints exist.
• Uniqueness: Each entity has a unique identity during its lifespan.
• Constant edge association: Edge endpoints remain unchanged during an edge's lifetime (Ramesh et al., 2020).

2. Data Modeling and System Design

The valid-time TPG model underpins data modeling for dynamic networks where both topology and attribute values are time-dependent.

2.1 Representational Guidelines

• Static attributes (infrequently changing, e.g., road length) are modeled as non-temporal properties $P$.
• Rapidly evolving attributes (e.g., travel_time, jam_status) are modeled as temporal properties $TP$ represented with a TIS (Song et al., 5 Dec 2025).
• Topological changes (node/edge insertions/deletions) utilize the existence function $\sigma$ or interval $\tau$ to define entity lifespan.

2.2 Application Domain: Property Evolution Temporal Graphs

Property evolution temporal graphs, arising in IoT and cyber-physical networks, feature rare topological changes but frequent property updates. PETGraphDB prescribes representing evolving attributes as temporal properties, optimizing for append-heavy, property-centric workloads (Song et al., 5 Dec 2025).

3. Storage, Indexing, and Transactional Management

Efficient storage and query over valid-time TPGs presents unique system design challenges.

3.1 Temporal Interval Merge Tree (TIM-Tree)

PETGraphDB employs the TIM-Tree, analogous to an LSM-Tree, to provide space-efficient and performant storage:

• Data items: $\langle e, tp, I=[\tau_s,\tau_e), v \rangle$ (entity, property, interval, value).
• Partitioning: By property, then by time-span chunks.
• Coalescing: Merges adjacent intervals with the same value; splits intervals across chunk boundaries.
• Read path: Binary search and linear scan within relevant chunks; merge in-memory and on-disk candidates; complexity $O(\log n + a)$ for $a$ matching items (Song et al., 5 Dec 2025).

3.2 Concurrency Control

A fine-grained, multi-level locking protocol:

• Entity-level locks: $L^S(e)$ (shared), $L^X(e)$ (exclusive).
• Property-interval locks: $L^S(e,tp,\tilde{I})$, $L^X(e,tp,\tilde{I})$ (interval-exclusivity).
• Lock compatibility determined by overlapping intervals.
• Temporal transactions managed by private in-transaction buffers, write-ahead logs, and Neo4j-inherited deadlock detection (Song et al., 5 Dec 2025).

4. Query Languages and Temporal Navigation

The query semantics for valid-time TPGs extend classic property graph path queries with time-aware navigation and predicates.

4.1 Temporal Regular Path Queries (TRPQs)

• TRPQs extend the MATCH clause (from Cypher/G-Core) to support temporal axes: PREV (P), NEXT (N), along with structural axes FWD (F), BWD (B).
• Regular path expressions, including concatenation, union, Kleene star, and numeric repetition over path steps, are supported.
• Tests at each navigation step allow label, property, existence, and time predicates; path-existence predicates are also allowed.
• Examples:
  • Snapshot: MATCH (x:Person {risk='low'}) ON contact_tracing
  • One-step backward navigation: MATCH (x:Person {test='pos'})-/PREV/- (x2)
  • Temporal and structural traversal: MATCH (x:Person {test='pos'})-/PREV/FWD/:visits/FWD/- (r:Room) (Arenas et al., 2021).

4.2 Query Language in Distributed Systems

The temporal path query language defined in "A Distributed Path Query Engine for Temporal Property Graphs" supports:

• Property-predicates, time-interval predicates (using Allen's interval relations), edge-time-relationship predicates, and aggregation operators.
• Expressiveness includes dynamic property matching, temporal matching on lifespans, and relational constraints between consecutive edges' validity intervals (Ramesh et al., 2020).

5. Distributed Execution and Cost-Based Optimization

Scalability and low-latency querying over large, evolving graphs are enabled by distributed, interval-centric architectures and cost-based plan selection.

5.1 Interval-Centric Execution Model

• Temporal partitioning: Vertices and edges are split into interval-vertex (and interval-edge) states based on property/value change points.
• Computation: Bulk synchronous supersteps over pre-partitioned graphs, with messaging and computation restricted to matched intervals.
• State sharing: "Message-trees" glue together shared partial paths to conserve bandwidth and memory.
• "In-out" plan splits supported, allowing mid-path query segmentation for performance (Ramesh et al., 2020).

5.2 Query Optimization

• Each temporal property key maintains a 2D histogram over values and time.
• Estimation formulas combine frequency, in/out degree, and predicate selectivity to estimate matched path counts.
• Regression-based cost models predict time per phase, accounting for both property and temporal selectivity.
• Experimental results show the optimizer picks (near-)optimal plans on 98% of workloads, with observed execution times within 10% of oracle optimal (Ramesh et al., 2020).

6. Complexity and Performance Characteristics

Evaluation complexity depends critically on the data representation and query language fragment.

Model	Query Language Fragment	Complexity
Point-based (TPG)	Full NavL[PC,NOI]	Polynomial time
Interval-based (ITPG)	Full NavL[PC,NOI]	PSPACE-complete
Interval-based (ITPG)	NavLNOI	2$^2$-hard
Interval-based (ITPG)	NavLPC	Polynomial time
Interval-based (ITPG)	NavLANOI	NP-complete

Point-based representations favor tractable evaluation of expressive temporal queries, while interval encodings require restrictions for performant evaluation (Arenas et al., 2021).

PETGraphDB achieves empirical storage usage at ~33% of the best uncompressed competitor, single-query latencies up to 267$\times$ faster, and HTAP throughput up to 58$\times$ higher, along with full ACID guarantees (Song et al., 5 Dec 2025). The distributed Granite query engine completes all evaluated temporal path queries with scaling efficiency $\geq 60\%$ (on 8 nodes) and typical latency advantages of $149\times$--$1140\times$ over Neo4j/JanusGraph Spark (Ramesh et al., 2020).

7. Applications and Example Queries

Valid-time temporal property graphs are essential for modeling time-evolving systems in domains such as social interaction networks, transportation/logistics (IoT), epidemiological contact tracing, and enterprise data provenance.

Practical queries include:

• Temporal history: Retrieving the evolution of a property over a time interval (e.g., all values of $r.\mathrm{travel\_time}$ for a given road segment over one month) (Song et al., 5 Dec 2025).
• Path existence with temporal constraints: "Who visited room $R$ after person $X$ tested positive?"
• Multi-hop patterns with interval relations: "Find people tagged 'Hiking' who liked a 'Vacation' post before Don did" (Ramesh et al., 2020).
• Aggregated analytics: Count/min/max properties of terminal vertices in valid temporal paths.

The expressiveness, formal semantics, and evaluability of queries over valid-time temporal property graphs advance the analytic and transactional capabilities of data management systems in temporal graph settings.