The Cost of Temporal Discretization in Dynamic Graphs

45 concepts44 papers1 proposal

Real-world networks are inherently continuous. A financial transaction occurs at a specific millisecond, a citation is published on a precise day, and a communication network pulses with real-time messages. However, traditional graph neural networks are built for static structures. To bridge this gap, a common engineering shortcut is to slice time into discrete buckets—flattening a continuous stream of events into a sequence of static graph "snapshots."

While computationally convenient, this discretization introduces a fundamental problem: temporal discretization loss. By forcing continuous interactions into rigid, artificial intervals, we destroy the very temporal dynamics that define how networks evolve. As Lu Yi et al. note in their comprehensive survey, flattening continuous interactions into discrete intervals strips away the fine-grained temporal resolution required for precise event prediction.

To understand why this loss occurs and how modern architectures overcome it, we must look at how discrete snapshots distort graph structure, sequence, and causality.


How Discretization Destroys Information

Slicing a continuous timeline into discrete intervals damages our ability to model networks in three distinct ways: erasing sequence, creating arbitrary boundaries, and conflating distinct structures.

1. Erasing Sequence and Causality

When multiple events occur within the same time slice, their chronological order is completely erased. Consider a simple social interaction: Alice messages Bob, and Bob immediately forwards that information to Charlie. This is a clear causal chain representing information flow. But if both events fall inside the same snapshot, they are collapsed into a single static adjacency matrix where Alice, Bob, and Charlie appear to interact simultaneously.

As Le-kui Zhou et al. demonstrate in Dynamic Network Embedding by Modeling Triadic Closure Process, this loss of chronological order makes it incredibly difficult to model fundamental network processes like triadic closure ("a friend of a friend becoming a friend"). Without exact timestamps, we cannot distinguish between a reciprocal response and two independent, simultaneous actions (Jiasen Yang et al., Decoupling Homophily and Reciprocity with Latent Space Network Models).

Similarly, Timothy LaRock et al. point out in Sequential motifs in observed walks that collapsing trajectory data into static structures makes multi-step navigation indistinguishable from a random collection of unrelated edges.

2. The Boundary Problem and Arbitrary Granularity

Slicing time requires choosing a hyperparameter: the window size (e.g., one hour, one day, one week). This choice introduces severe artifacts. If an event or a high-frequency burst occurs right across a snapshot boundary, it gets fragmented. Eren Cakmak et al. show in Multiscale Snapshots: Visual Analysis of Temporal Summaries in Dynamic Graphs that uniform time-slicing splits continuous events, causing analysis algorithms to misinterpret or entirely lose their structural characteristics.

Choosing the wrong granularity creates a lose-lose scenario:

Chengbin Hou et al. highlight in Towards Robust Dynamic Network Embedding that a model's perceived effectiveness is often merely an artifact of these arbitrary data preprocessing choices rather than its ability to capture true network evolution.

3. Structural Conflation and False Simultaneity

When you aggregate interactions over a long period into a single static snapshot, you artificially merge distinct groups that were never active at the same time. The authors of Detecting the Community Structure and Activity Patterns of Temporal Networks explain that this loss of temporal resolution creates "ghost" structures, obscuring the true rhythm of the system.

For instance, in financial networks, aggregating transactions over long periods completely hides cyclical patterns like payday schedules or seasonal spending shifts (Akrati Saxena et al., The Banking Transactions Dataset and its Comparative Analysis with Scale-free Networks). In community detection, collapsing time-varying data obscures the evolutionary history of how groups form, merge, or dissolve over time (Zhana Kuncheva, Multi-scale Community Detection in Temporal Networks Using Spectral Graph Wavelets).


The Paradigm Shift: Continuous-Time Architectures

To overcome these limitations, researchers have shifted away from discrete snapshots toward frameworks that treat time as a continuous coordinate. Instead of asking "what does the graph look like at time $t$?", these models ask "how does an event at time $t$ change the continuous trajectory of the network?"

Deep Temporal Point Processes

One powerful approach is to model graph evolution as a continuous-time point process, an idea rooted in survival analysis (Duy Quang Vu et al., Dynamic Egocentric Models for Citation Networks).

For example, Rakshit Trivedi et al. introduced DyRep, which models short-term communications and long-term structural changes as interleaved point processes. By learning node embeddings that evolve continuously, the model captures the exact timing of events without needing arbitrary time buckets. Similarly, Hong Huang et al. leverage Hawkes processes in Temporal Heterogeneous Information Network Embedding to model how the influence of an interaction decays continuously over time.

Discrete Snapshots (Lossy):
[ Event 1, Event 2, Event 3 ] ---> Collapsed into Snapshot T1 (Order lost)

Continuous-Time (Preserved):
---(Event 1: t=1.2)---(Event 2: t=1.5)---(Event 3: t=2.1)---> Continuous Trajectory

Functional Time Encodings and Latent Trajectories

Instead of treating time as a discrete index, models can map continuous timestamps directly into vector spaces. Da Xu et al. pioneered this with TGAT, using a mathematically grounded functional time encoding within a self-attention mechanism to inductively infer embeddings at any arbitrary millisecond.

Other frameworks model node embeddings as continuous trajectories through space. Abdulkadir Çelikkanat et al. developed PIVEM, which models node movements as piecewise linear trajectories in a latent space, ensuring that node properties change smoothly and continuously rather than in discrete jumps.


Why Continuous Modeling Matters

Preserving continuous-time dynamics fundamentally changes what models can achieve in downstream tasks:

By moving away from the rigid constraints of discrete snapshots and embracing continuous-time representations, modern graph learning models avoid the destructive effects of temporal discretization loss. They preserve causality, sequence, and exact timing, unlocking the ability to truly model networks as living, breathing systems.

Key Foundational Work

Dynamic Egocentric Models for Citation Networks (2011) — contributed 1 concept elements to this direction.
Fingerprint Matrices: Uncovering the dynamics of social networks in prose literature (2013) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_temporal_discretization_loss_d5f418b1,
  title = {temporal discretization loss},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/temporal-discretization-loss/rdr_d5f418b1601743ab91c3a47a20475d66},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_temporal_discretization_loss_d5f418b1_v1,
  title = {temporal discretization loss},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/temporal-discretization-loss/rdr_d5f418b1601743ab91c3a47a20475d66/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake