Full-History Graph: Temporal Evolution

• Full-History Graph is a graph representation that preserves the entire temporal evolution of a system by recording all events, revisions, or deltas.
• The architecture leverages delta trees and version chains to optimize storage, indexing, and efficient point-in-time snapshot retrieval.
• It serves as a foundation for dynamic learning applications and temporal analytics, enhancing tasks like anomaly detection and network embedding.

In the cited literature, a full-history graph is a graph representation that preserves the entire temporal or versioned evolution of a system rather than restricting analysis to isolated snapshots. The concept appears in several closely related forms: as a historical graph store built from an initial state plus an ordered event stream; as an evolving graph expressed through revision-level additions and deletions; and as a time-unrolled graph with one node per entity per time step and separate structural and temporal edges. Across these formulations, the central objective is the same: to make graph change first-class, so that retrieval, analytics, learning, and reasoning can operate on exact historical state rather than on coarse temporal summaries (Khurana et al., 2012, Khurana et al., 2015, Mohammed et al., 5 Aug 2025).

1. Definitions and formal variants

A classical systems-oriented definition models a full-history graph over a discrete time domain $T=\{0,1,\dots,t_{\max}\}$ as $G_{\mathrm{hist}}=(G_0,E)$, where $G_0=(V_0,E_0,A_0)$ is the initial graph and $E=\{e_1,e_2,\dots,e_U\}$ is a chronologically ordered event stream containing node insertion or deletion, edge insertion or deletion, and node or edge attribute update. A snapshot at time $t$ is reconstructed by replaying all events up to $t$: $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$. In this formulation, the full-history graph is the persistent record that makes arbitrary historical snapshots retrievable (Khurana et al., 2012).

A related abstraction treats the full-history graph over $[t_0,t_n]$ as the union of all vertices and edges at all times, annotated by validity. If $G(t)=(V(t),E(t))$ is the snapshot at time $t$, then

$G_{\mathrm{hist}}=(G_0,E)$0

The same framework introduces atomic changes between successive snapshots as $G_{\mathrm{hist}}=(G_0,E)$1 and $G_{\mathrm{hist}}=(G_0,E)$2, with event-level deltas used to encode additions, deletions, and attribute changes (Khurana et al., 2015).

In evolving RDF knowledge graphs, the history is expressed as a revision sequence. For an entity $G_{\mathrm{hist}}=(G_0,E)$3, each revision $G_{\mathrm{hist}}=(G_0,E)$4 is serialized as an RDF graph $G_{\mathrm{hist}}=(G_0,E)$5, and revision-to-revision change is represented by deletion and addition sets

$G_{\mathrm{hist}}=(G_0,E)$6

If all revisions are globally ordered by revision id, the evolving graph obeys

$G_{\mathrm{hist}}=(G_0,E)$7

This yields a full-history, evolving RDF knowledge graph whose basic unit of change is the triple-level delta (Schmelzeisen et al., 2021).

A distinct machine-learning-oriented construction unfolds each entity across time. With timesteps $G_{\mathrm{hist}}=(G_0,E)$8 and entity set $G_{\mathrm{hist}}=(G_0,E)$9, one creates

$G_0=(V_0,E_0,A_0)$0

together with intra-time-step edges $G_0=(V_0,E_0,A_0)$1 for relations within a frame and inter-time-step edges $G_0=(V_0,E_0,A_0)$2 connecting an entity to itself across consecutive frames. The full-history graph is then $G_0=(V_0,E_0,A_0)$3. This formulation makes temporal continuity explicit in the graph topology itself (Mohammed et al., 5 Aug 2025).

These definitions are not identical, but they are structurally aligned. A plausible implication is that “full-history graph” functions as an umbrella term for representations that preserve exact temporal provenance, whether the primitive update is an event, a delta, a revision, or a time-unrolled node copy.

2. Storage, indexing, and retrieval architectures

Early full-history graph systems emphasize compact archival and efficient point-in-time reconstruction. DeltaGraph organizes the event stream hierarchically. The stream $G_0=(V_0,E_0,A_0)$4 is partitioned into leaf-eventlists of size $G_0=(V_0,E_0,A_0)$5; leaves correspond to leaf snapshots; interior tree nodes represent synthetic graphs defined by a differential function $G_0=(V_0,E_0,A_0)$6 over children; and each edge stores a delta $G_0=(V_0,E_0,A_0)$7 such that $G_0=(V_0,E_0,A_0)$8. The framework exposes explicit trade-offs among arity $G_0=(V_0,E_0,A_0)$9, leaf-eventlist size $E=\{e_1,e_2,\dots,e_U\}$0, and differential function choice, including Intersection, Balanced, Skewed, and Mixed variants. For the Balanced function, the storage model is

$E=\{e_1,e_2,\dots,e_U\}$1

and single-point snapshot retrieval is modeled as

$E=\{e_1,e_2,\dots,e_U\}$2

GraphPool complements the index by overlaying multiple resident snapshots using bit-vectors, so that hundreds of historical graph instances can coexist in main memory non-redundantly (Khurana et al., 2012).

Historical Graph Store generalizes time-centric and entity-centric indexing through the Temporal Graph Index (TGI). TGI combines partitioned eventlists, derived partitioned snapshots arranged as a hierarchical delta tree, and per-vertex version chains that point directly to relevant deltas. If there are $E=\{e_1,e_2,\dots,e_U\}$3 horizontal partitions and $E=\{e_1,e_2,\dots,e_U\}$4 time spans, the index may be viewed as $E=\{e_1,e_2,\dots,e_U\}$5, where $E=\{e_1,e_2,\dots,e_U\}$6. Under the paper’s balance assumptions, snapshot reconstruction at time $E=\{e_1,e_2,\dots,e_U\}$7 costs roughly

$E=\{e_1,e_2,\dots,e_U\}$8

while vertex-history retrieval depends on the size of the corresponding version chain rather than on the size of the entire graph. TAF, the Temporal Graph Analysis Framework above TGI, introduces temporal operands such as NodeT, SoN, SubgraphT, and SoTS, together with operators including select, timeslice, graph, nodeComputeTemporal, nodeComputeDelta, compare, evolution, and tempAggregate (Khurana et al., 2015).

Wikidated 1.0 applies the same principles to an evolving knowledge graph extracted from Wikidata’s “pages-meta-history” dumps. The pipeline streams entity revisions, converts JSON blobs to RDF graphs via Wikidata Toolkit, computes per-revision deletions and additions, emits incremental revision records, and then performs an external multiway merge by revision id to build a global stream without materializing everything in RAM. Storage is offered in two GZIP-compressed JSON Lines variants: tar-archived per-entity streams and a single global stream. Each incremental revision stores entity ID, revision ID, timestamp, user, comment, and arrays of string-serialized RDF triples named “deletions” and “additions.” The implementation also resolves the blank-node issue by dropping blank-node IDs because, in Wikidata’s RDF export, blank nodes only occur for “some”-value placeholders and each occurs in exactly one triple (Schmelzeisen et al., 2021).

Taken together, these systems establish a recurring architectural pattern: archival history is compressed as deltas; retrieval is accelerated by hierarchical organization and entity-local access paths; and analytical interfaces are built above exact temporal state rather than above ad hoc snapshot collections.

3. Learning over explicit history

Full-history graphs have also become learning substrates. One line of work addresses dynamic network embedding directly. “Dynamic Graph Embedding via LSTM History Tracking” proposes a method that integrates the history of nodes over time into the current state of nodes. Its stated contributions are generating dynamic network embedding by combining both dynamic and static node information, tracking history of neighbors of nodes using LSTM, and significantly decreasing the time and memory by training an autoencoder LSTM model using temporal walks rather than adjacency matrices of graphs. The paper evaluates the method on anomaly detection, link prediction, and node classification across datasets from various domains (Khoshraftar et al., 2019).

A more explicit full-history construction appears in ETDNet. Here every entity-time pair is a node, and the edge set is split into $E=\{e_1,e_2,\dots,e_U\}$9 and $t$0. ETDNet stacks $t$1 layers, each with three parallel components: Step Attention over $t$2, History Attention over $t$3, and a Fusion module. The graph-attention branch aggregates frame-local neighbors through multi-head attention and residual projection; the temporal branch attends over an entity’s predecessor sequence $t$4; and the fusion step combines the original embedding with both messages using a residual MLP: $t$5 On Waymo driver-intention forecasting, ETDNet lifts joint accuracy to $t$6 versus $t$7 for TGN, with speed F1 improving from $t$8 to $t$9 and direction F1 from $t$0 to $t$1. On Elliptic++ Bitcoin fraud detection, ETDNet reaches illicit-F1 $t$2 and AUPRC $t$3, while the reported temporal baselines TGN and DyGFormer reach approximately $t$4–$t$5 illicit-F1. The ablations further separate the roles of the two edge families: SA-only yields F1 approximately $t$6, HA-only approximately $t$7, and the full dual-branch model approximately $t$8 (Mohammed et al., 5 Aug 2025).

The same literature also clarifies what full-history representations are meant to preserve. ETDNet argues that representing each entity’s state at every time step as its own node preserves exact causal ordering and structural context without compressing events into coarse “snapshots,” while edge-type splitting prevents a single aggregator from mixing signals that evolve at very different rates. This suggests that the learning benefit is not merely longer context, but architectural separation between spatial interaction and temporal recurrence.

4. Knowledge graphs, conversational state, and agent memory

In conversational KBQA, history can itself be graph-structured. HSGE converts every past turn’s logical form into a single, growing history semantic graph $t$9 whose nodes are entities and Wikidata-derived types and whose edges are predicates plus an IsA relation. Node and edge labels are initialized with BERT embeddings of their surface forms, updated by a single TransformerConv layer, and augmented by a temporal embedding based on turn distance $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$0, either sinusoidal or learned: $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$1 These graph representations are then injected into a Transformer-based encoder through token-level and utterance-level multi-head attention before grammar-guided decoding. On the CSQA benchmark of $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$2K dialogs, HSGE reports an overall score of $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$3 versus $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$4 for LASAGNE; it reaches $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$5 F1 on logical-reasoning versus $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$6, and $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$7 accuracy on Boolean verification versus $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$8. Removing the history semantic graph drops the overall score to $$G_t = G_0 \oplus \{e_i \mid \mathrm{time}(e_i)\le t\}$$9, and removing temporal modeling yields $[t_0,t_n]$0 (Sun et al., 2023).

A different question is whether full history should be shown to the LLM at every decision. In LLM-based KGQA, Full-History Graph prompting serializes the entire symbolic path $[t_0,t_n]$1 into each routing prompt through $[t_0,t_n]$2. Bounded Path Context replaces this with a $[t_0,t_n]$3-bounded suffix $[t_0,t_n]$4, while the controller still retains full symbolic paths in memory for expansion and answer extraction. Under a controlled sweep on complete WebQSP and CWQ test sets with Qwen3.5-9B-AWQ, $[t_0,t_n]$5 achieves WebQSP F1 $[t_0,t_n]$6 versus $[t_0,t_n]$7 for full history, and $[t_0,t_n]$8 reaches CWQ F1 $[t_0,t_n]$9 versus $G(t)=(V(t),E(t))$0, with $G(t)=(V(t),E(t))$1 and $G(t)=(V(t),E(t))$2 fewer input tokens respectively. The paper reports that $G(t)=(V(t),E(t))$3–$G(t)=(V(t),E(t))$4 of examples tie across history-length settings, and characterizes the affected cases as either “Disambiguation wins” or “Stale-context losses” (Shan et al., 26 May 2026).

The same separation between retained history and exposed context appears in LLM-agent memory. Engram stores extracted facts as bi-temporal tuples

$G(t)=(V(t),E(t))$5

with optional end-times, a supersedes pointer, provenance metadata, surface text, embedding, salience, and confidence. Contradictions are resolved by non-destructive invalidation: older facts are clipped in valid-time and transaction-time, never deleted, so that provenance and supersession chains remain intact. Retrieval uses an “as-of” filter

$G(t)=(V(t),E(t))$6

together with dense, lexical, graph, recency, and salience signals fused by weighted scoring and Reciprocal Rank Fusion. On the full $G(t)=(V(t),E(t))$7-question LongMemEval$G(t)=(V(t),E(t))$8, Engram’s lean configuration answers from an approximately $G(t)=(V(t),E(t))$9k-token retrieved slice, never the full history, and scores $t$0 versus $t$1 for the full-context baseline, with paired McNemar exact $t$2 and approximately $t$3 fewer tokens $t$4k versus $t$5k$t$6 (Wang, 5 Jun 2026).

A common misconception is therefore that a full-history graph implies full-history prompting. The recent KGQA and agent-memory results show the opposite design: retain complete symbolic or graph history for auditability and exact answer extraction, but expose only a bounded or retrieved slice at inference time.

5. Representative datasets and empirical domains

Full-history graphs are now instantiated at Internet and blockchain scale, as well as in collaborative knowledge systems.

Resource	History unit	Reported scale
Wikidated 1.0	RDF triple additions and deletions between revisions	96.6 M entities; 1.43 B revisions
Software Heritage graph	Full Merkle-DAG of public VCS history	$t$7; $t$8
BTC full-history network	Transaction-derived address graph from genesis to block 845651	1 013 989 952 transactions; 1 411 482 182 distinct addresses

Wikidated 1.0 covers 30 Oct 2012–2 Jun 2021 and is described as the first large dataset of an evolving knowledge graph. Its summary statistics show a graph whose updates are usually small but whose long tail is operationally important: revisions per entity have mean $t$9, standard deviation $G_{\mathrm{hist}}=(G_0,E)$00, and median $G_{\mathrm{hist}}=(G_0,E)$01; only $G_{\mathrm{hist}}=(G_0,E)$02 of entities have a single revision; $G_{\mathrm{hist}}=(G_0,E)$03 have fewer than $G_{\mathrm{hist}}=(G_0,E)$04 revisions. Inter-revision times have median $G_{\mathrm{hist}}=(G_0,E)$05 days and mean $G_{\mathrm{hist}}=(G_0,E)$06 days, yet $G_{\mathrm{hist}}=(G_0,E)$07 occur within $G_{\mathrm{hist}}=(G_0,E)$08 seconds. Additions per revision have mean $G_{\mathrm{hist}}=(G_0,E)$09 and median $G_{\mathrm{hist}}=(G_0,E)$10; deletions have mean $G_{\mathrm{hist}}=(G_0,E)$11 and median $G_{\mathrm{hist}}=(G_0,E)$12; $G_{\mathrm{hist}}=(G_0,E)$13 of revisions add fewer than $G_{\mathrm{hist}}=(G_0,E)$14 triples and $G_{\mathrm{hist}}=(G_0,E)$15 delete none. Triple churn is asymmetric: $G_{\mathrm{hist}}=(G_0,E)$16 of all added triples are never deleted, $G_{\mathrm{hist}}=(G_0,E)$17 are deleted exactly once, and less than $G_{\mathrm{hist}}=(G_0,E)$18 see more than one deletion, though some “edit wars” exceed $G_{\mathrm{hist}}=(G_0,E)$19 toggles (Schmelzeisen et al., 2021).

Software Heritage exposes public software development history as a directed acyclic Merkle graph with node types for contents, directories, revisions, releases, snapshots, origins, and visits. As of the September 25 2018 snapshot, the reported node counts include $G_{\mathrm{hist}}=(G_0,E)$20 contents, $G_{\mathrm{hist}}=(G_0,E)$21 directories, $G_{\mathrm{hist}}=(G_0,E)$22 revisions, $G_{\mathrm{hist}}=(G_0,E)$23 snapshots, and $G_{\mathrm{hist}}=(G_0,E)$24 origins, for a total of approximately $G_{\mathrm{hist}}=(G_0,E)$25 nodes. The average parent-degree of a revision is $G_{\mathrm{hist}}=(G_0,E)$26, reflecting predominantly linear commit histories with rarer merges. A complementary large-scale topological analysis compresses an approximately $G_{\mathrm{hist}}=(G_0,E)$27-billion-node, $G_{\mathrm{hist}}=(G_0,E)$28-billion-edge graph to approximately $G_{\mathrm{hist}}=(G_0,E)$29 GB on disk using WebGraph compression, reports one giant connected component of size approximately $G_{\mathrm{hist}}=(G_0,E)$30–$G_{\mathrm{hist}}=(G_0,E)$31, and observes average commit-layer path lengths of approximately $G_{\mathrm{hist}}=(G_0,E)$32–$G_{\mathrm{hist}}=(G_0,E)$33 hops with diameter approximately $G_{\mathrm{hist}}=(G_0,E)$34–$G_{\mathrm{hist}}=(G_0,E)$35 (Pietri et al., 2020, Pietri et al., 2020).

In Bitcoin analysis, Cheng et al. build a full-history transaction graph from block $G_{\mathrm{hist}}=(G_0,E)$36 through block $G_{\mathrm{hist}}=(G_0,E)$37. They synchronize a full Bitcoin Core node to block $G_{\mathrm{hist}}=(G_0,E)$38 and, using BlockSci, extract $G_{\mathrm{hist}}=(G_0,E)$39 transactions, $G_{\mathrm{hist}}=(G_0,E)$40 inputs, $G_{\mathrm{hist}}=(G_0,E)$41 outputs, and $G_{\mathrm{hist}}=(G_0,E)$42 distinct addresses. Because the UTXO model does not record explicit input-to-output pairings, each transaction with inputs $G_{\mathrm{hist}}=(G_0,E)$43 and outputs $G_{\mathrm{hist}}=(G_0,E)$44 is converted into the complete bipartite directed edge set $G_{\mathrm{hist}}=(G_0,E)$45, with edge weights allocated in proportion to output value. On top of this full-history graph, the paper defines decentralization measures based on centrality dispersion, top-balance concentration $G_{\mathrm{hist}}=(G_0,E)$46, ranking stability, and normalized HHI-based decentralization $G_{\mathrm{hist}}=(G_0,E)$47, and reports three phases: “rapid decentralization” from Jan 2009–Feb 2010, “re-centralization” from Feb 2010–Mar 2012, and “long-term stability” from Mar 2012–May 2024 (Cheng et al., 2024).

These datasets show that “full history” is not tied to one domain. It covers collaboratively edited KGs, public software archives, financial transaction networks, and, by extension in the cited work, traffic and fraud graphs.

6. Limits, misconceptions, and research directions

The main practical limitation of full-history graphs is scale, but the cited systems show that scale interacts with access pattern rather than with raw size alone. DeltaGraph makes storage and retrieval tunable through $G_{\mathrm{hist}}=(G_0,E)$48, $G_{\mathrm{hist}}=(G_0,E)$49, and differential-function choice; TGI uses partitioned eventlists and version chains to avoid whole-graph scans; ETDNet notes that the Step-Attention branch may be accelerated via sparse-attention kernels or neighbor sampling, while the History-Attention branch requires only $G_{\mathrm{hist}}=(G_0,E)$50 memory per node (Khurana et al., 2012, Khurana et al., 2015, Mohammed et al., 5 Aug 2025).

A second limitation is incompleteness of the historical record. Wikidated 1.0 omits deleted entities and revisions because they are absent from public “pages-meta-history” dumps, excludes lexicographic data because Wikidata Toolkit does not yet serialize lexemes, forms, or senses, and does not include talk pages, templates, or other meta wikitext. Software Heritage’s public-history studies also note crawl lag and exploratory methodology limits, including the absence of full goodness-of-fit testing in the reported power-law analysis (Schmelzeisen et al., 2021, Pietri et al., 2020).

A third issue is methodological: full-history data are not always directly observed. “Reconstructing Graph Diffusion History from a Single Snapshot” studies DASH, where only the final snapshot $G_{\mathrm{hist}}=(G_0,E)$51 is available and the true diffusion parameters are unknown. The paper proves that parameter estimation is NP-hard under SIR and that MLE-based history recovery is sensitive to parameter error. It therefore replaces single-history MLE with a barycenter formulation based on posterior expected hitting times, and implements DITTO using mean-field parameter estimation, an unsupervised GNN proposal, and Metropolis–Hastings MCMC. Reported results include mean-field $G_{\mathrm{hist}}=(G_0,E)$52 with NRMSE $G_{\mathrm{hist}}=(G_0,E)$53 on synthetic data, approximately $G_{\mathrm{hist}}=(G_0,E)$54 NRMSE gain on COVID relative to baselines, and runtime $G_{\mathrm{hist}}=(G_0,E)$55 (Qiu et al., 2023).

The recent prompt-engineering and memory papers further correct a common overgeneralization. Full-history graphs preserve exact symbolic or temporal state, but that does not imply that the entire state should be serialized into every prompt. Bounded Path Context argues that path-serialization length $G_{\mathrm{hist}}=(G_0,E)$56 should be treated as a tunable interface hyperparameter rather than as a fixed default, and Engram shows that a lean retrieved context can outperform full-history replay even when the underlying memory remains lossless and bi-temporal (Shan et al., 26 May 2026, Wang, 5 Jun 2026).

Several forward directions are already explicit in the literature. ETDNet identifies continuous-time extension, adaptive history-window learning, and theoretical analysis of over-smoothing in decoupled message passing as open directions. Wikidated’s update statistics suggest cheap incremental updates for most revisions, but the non-negligible fraction of rapid edits and high-frequency churn argues for dynamic index structures and caching; the long tail of repeated triple flips invites change-classification research (Mohammed et al., 5 Aug 2025, Schmelzeisen et al., 2021).

Across these strands, the durable idea is exact historical state. Whether realized as event replay, delta streams, bi-temporal facts, revision-level RDF changes, or time-unrolled entity replicas, the full-history graph is the mechanism by which graph evolution becomes directly queryable, learnable, and auditable.