History Graphs: Structural Encoding of Past States

• History graphs are structured representations that explicitly encode past states, events, and relations, and are applied in dialog systems, knowledge graphs, evolutionary studies, and software provenance.
• They leverage diverse methodologies like graph-attention and TransformerConv to capture coreference and temporal dependencies, with measurable gains such as improved VisDial NDCG scores.
• Their design underpins efficient storage, retrieval, and forecasting, optimizing computations and enabling scalable analysis in systems like DeltaGraph and ETDNet.

A history graph is a graph-structured representation that makes prior states, prior relations, or prior events explicit objects of computation. In recent literature the label is used for several non-equivalent constructions: a coreference graph over dialog turns, a semantic graph derived from previous logical forms, a time-unfolded graph with one node per entity per timestep, a distributed index over historical snapshots, a knowledge graph assembled from historical corpora, a genome-evolution structure combining ancestry and adjacency, and a content-addressed graph of software development history. This suggests a family of formalisms rather than a single standardized model, with the common feature that history is encoded structurally instead of being treated only as an unstructured sequence (Chen et al., 2021, Paten et al., 2013, Pietri et al., 2020).

1. Terminological scope and conceptual core

The literature uses “history graph” in several technically distinct senses.

Setting	Basic graph unit	Primary function
Visual dialog	Dialog turn	Coreference-aware history reasoning
Conversational KBQA	Entities, types, predicates	Long-range semantic dependency tracking
Temporal interaction modeling	Entity-time node	Joint structural and temporal reasoning
Historical graph systems	Snapshot/delta/index node	Retrieval of past graph states
Historical knowledge graphs	Historical entity/event/action	Queryable archival representation
Genome evolution	Segment, adjacency, branch	Parsimonious evolutionary reconstruction

In visual dialog, the History Graph is a sparse graph whose nodes are history turns and whose edges encode coreference relations among turns (Chen et al., 2021). In conversational KBQA, the History Semantic Graph is defined as

$$\mathcal{G}=\langle \mathcal{V},\mathcal{E}\rangle,\qquad \mathcal{V}=set(e)\cup set(tp),\qquad \mathcal{E}=set(p),$$

so that entities and entity types are nodes and predicates are edges (Sun et al., 2023). In temporal reasoning, a full-history graph instantiates one node for every entity at every time step and separates intra-time-step edges from inter-time-step edges (Mohammed et al., 5 Aug 2025). In genome evolution, a history graph augments a sequence graph with directed ancestry branches (Paten et al., 2013). In archival and humanities settings, history graphs are usually knowledge graphs over people, places, organizations, events, or actions extracted from historical sources (Paiva et al., 2024, Schouten et al., 2021, Dam et al., 8 Jul 2026).

A frequent misconception is that the term names a single graph-learning architecture. The surveyed works do not support that view. Another source of confusion is arXiv record (Khoshraftar et al., 2019), whose metadata advertises a dynamic embedding method but whose supplied document is described in the provided material as an IEEEtran demo/template with no substantive graph-learning content; it therefore does not define a history-graph method (Khoshraftar et al., 2019).

2. Dialog history as explicit graph structure

In visual dialog, GoG introduces the History Graph (H-Graph) as the first stage of a “graph-over-graph” pipeline, motivated by the need to resolve explicit coreference in dialog history before question understanding and image reasoning (Chen et al., 2021). The dialog history is converted into a graph with one node per turn. For a $t$-turn dialog, the adjacency matrix $A$ is defined by

$$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$

This makes the H-Graph a pruned sparse graph: non-coreferent turns are not connected. Coreference links are obtained with a coreference resolution tool from Lee et al. (2017), using the caption and questions rather than QA pairs so that the graph remains constructible at test time. The graph is then processed with the paper’s generic graph-attention operator, yielding the relation-aware history representation $h^*=GraphAtt(h_i,A)$. The output is not terminal; it is fed into the History-aware Q-Graph through an adaptive history vector and then influences the Question-aware I-Graph. Experimentally, the full LTMI-GoG model reaches 62.63 NDCG on VisDial v1.0 validation with the generative decoder, while removing the H-Graph lowers performance to 62.03, and removing the coreference relation gives 62.31. The reported configuration uses 4 heads for all three graph attention networks and hidden feature dimension 512 (Chen et al., 2021).

Conversational KBQA uses a different construction. HSGE converts the logical forms of previous turns into a graph of entities, entity types, and predicates, preserving the outputs of find, find_reverse, and type-filtering actions and adding type edges $\langle e_i, IsA, tp_i\rangle$ from Wikidata (Sun et al., 2023). The graph is processed with TransformerConv, and temporal information is injected by adding a turn-distance embedding: $\bar{h}_i = h_i + e_t .$ The model considers both absolute and relative distance strategies, as well as sinusoidal and learnable positional encodings; the reported empirical choice is that absolute distance works better than relative distance, and token-level aggregation works better than utterance-level aggregation. The resulting graph-enhanced encoder feeds a grammar-guided decoder, an entity recognition module, and a concept-aware attention module. On CSQA, HSGE reports overall F1/Accuracy of 81.38, outperforming LASAGNE, OAT, MaSP, D2A, and S2A-MAML, and ablations show that removing either the History Semantic Graph or temporal information modeling degrades performance (Sun et al., 2023).

Taken together, these two lines of work illustrate a core design distinction. One treats history as discourse-level coreference among turns; the other treats history as a typed semantic memory over entities and predicates. In both cases, the graph is introduced because concatenated text history is considered too noisy or too weakly structured for long-range reasoning.

3. Full-history temporal learning and forecasting

A persistent design issue, suggested by recent temporal-graph work, is how much past information should remain explicit. One answer is the full-history graph of ETDNet, which replaces a sequence of snapshots with a single time-unfolded graph (Mohammed et al., 5 Aug 2025). For dynamic entities $u\in U$, static entities $s\in S$, and timesteps $T=\{0,1,\dots,\tau_{\max}\}$, the node set is

$t$0

and the edge set is partitioned as

$t$1

where $t$2 contains intra-timestep edges and $t$3 contains inter-timestep edges, often self-history edges $t$4. ETDNet then decouples processing by edge type: Step Attention aggregates along $t$5, History Attention attends over bounded predecessors along $t$6, and a Fusion Layer merges the two messages after every layer. On Waymo, ETDNet reports Speed F1 85.7, Direction F1 82.9, and joint accuracy 75.6%, compared with 74.1% for the strongest non-ETDNet baseline, TGN. On Elliptic++, it reports ROC-AUC 0.884, AUPRC 0.863, and illicit-class F1 88.1%, compared with 60.4% for TGN and 61.0% for DyGFormer (Mohammed et al., 5 Aug 2025).

A second answer is to keep per-visit graphs but model their sequence explicitly. The Alzheimer’s HA-GNN constructs a functional connectivity graph from each rs-fMRI visit by parcellating the brain into 100 ROIs with the Schaefer atlas and computing pairwise Pearson correlation between ROI time series (Moghaddami et al., 7 Apr 2026). Each visit graph is encoded by two convolutional blocks, each containing GraphSAGE, GraphNorm, Dropout, and TopK pooling, and the resulting visit embeddings are passed to an RNN block, which can be LSTM, GRU, or vanilla RNN. Distances between consecutive visits are concatenated to the feature vector so that the temporal module is aware of irregular sampling; the paper reports mean separation of 14.78 months and emphasizes robustness to missing visits and varying history lengths. The best model, HA-GNN with LSTM, achieves accuracy 82.9% ± 5.8, AUC-ROC 0.852 ± 0.065, balanced accuracy 0.771 ± 0.114, CN→MCI accuracy 68.8%, and MCI→AD accuracy 67.6% (Moghaddami et al., 7 Apr 2026).

A third answer is selective retention. FLASH argues that historical neighbor sampling in TGNNs is not merely an efficiency trick but part of model expressivity (Feldman et al., 9 Apr 2025). The paper proves that for any $t$7 there exists a dynamic graph on which any TGNN that applies $t$8 recent selection cannot learn, and analogously that for any $t$9 there exist dynamic graphs on which any TGNN that applies uniform sampling of $A$0 historical neighbors cannot learn. FLASH replaces fixed heuristics with a learnable relevance scorer conditioned on spatial, temporal, and pair-specific link context, trained by a self-supervised ranking loss. It reports time complexity $A$1, the same as uniform sampling, and empirical gains across TGAT, TGN, GraphMixer, DyGFormer, and FreeDyG on DyGLib and TGB benchmarks (Feldman et al., 9 Apr 2025).

Temporal knowledge graph forecasting raises the same issue in another form. Chain-of-History (CoH) reasoning argues that LLM-based forecasting should not consume only first-order history; instead it should explore higher-order history chains step by step (Xia et al., 2024). On ICEWS14, ICEWS18, and ICEWS05-15, LLM-only forecasting improves from 31.79 to 34.51 MRR, from 21.51 to 23.94, and from 35.34 to 37.51, respectively, when moving from the earlier ICL-style approach to CoH (Xia et al., 2024). At the same time, “History Repeats Itself” shows that a parameter-light, training-free recurrency baseline can rank first on GDELT and YAGO and third on WIKI, with combined-baseline results of MRR 24.5 on GDELT, 90.9 on YAGO, 81.5 on WIKI, 37.2 on ICEWS14, and 28.7 on ICEWS18 (Gastinger et al., 2024). A plausible implication is that temporal-history architectures should be evaluated not only against complex learned baselines but also against strong recurrence heuristics.

4. Historical graph storage, indexing, and retrieval

In systems work, a history graph is often not a learning representation but an access structure for the entire evolution of a graph. DeltaGraph stores a historical network as a hierarchy of deltas over discrete snapshots $A$2, with graph evolution represented by events $A$3 such that

$A$4

Its two main components are DeltaGraph, an on-disk hierarchical index, and GraphPool, an in-memory overlay structure that can maintain hundreds of historical graph instances in a non-redundant manner (Khurana et al., 2012). Singlepoint retrieval is reduced to a shortest-path problem on the DeltaGraph skeleton and solved with Dijkstra’s shortest path; multipoint retrieval is reduced to a Steiner tree problem, for which the paper uses a 2-approximation based on MST construction. The framework supports differential functions such as Intersection, Union, Skewed, Mixed, Balanced, and Empty, thereby exposing tunable storage–retrieval tradeoffs (Khurana et al., 2012).

Historical Graph Store extends this line by explicitly coupling storage and analytics (Khurana et al., 2015). Its Temporal Graph Index (TGI) is built from partitioned eventlists, derived partitioned snapshots, and per-node version chains $A$5, and it is implemented on Apache Cassandra. Its Temporal Graph Analysis Framework (TAF) runs on Apache Spark and introduces abstractions such as Temporal Node, Set of Temporal Nodes, Temporal subgraphs, and Set of temporal subgraphs. The model defines event and snapshot deltas as

$A$6

TAF provides operators such as Selection, Timeslicing, Graph, NodeCompute, NodeComputeTemporal, NodeComputeDelta, Compare, Evolution, and TempAggregation. A key systems claim is the benefit of incremental temporal computation: for the example of counting nodes with a given attribute in a subgraph, naive recomputation costs $A$7, whereas the incremental NodeComputeDelta scheme costs $A$8 (Khurana et al., 2015).

These storage-oriented history graphs differ fundamentally from learned temporal graphs. Their emphasis is compact persistence, arbitrary-time retrieval, multipoint access, and distributed execution. Yet the underlying conceptual move is the same: past graph states are indexed as first-class entities instead of being discarded after each update.

5. Historical knowledge graphs in humanities, archives, and search histories

In digital humanities and archival computing, a history graph usually denotes a knowledge graph grounded in historical sources. “Towards a Brazilian History Knowledge Graph” proposes a Wikidata-centered graph built from the Brazilian Historical-Biographical Dictionary (DHBB) and enriched with Wikipedia/Wikidata links (Paiva et al., 2024). The DHBB contains 7,863 entries, including over 6,800 biographical entries and around 1,000 thematic entries. For thematic DHBB entries, there are 973 titles, of which 498 can be matched automatically to Wikidata items and 475 produce no Wikidata result at all; for biographical entries, 6,980 names yield 4,300 automatic mappings and 2,590 unmapped names. The project’s argument is that Brazilian history KGs require not only mapping to existing Q items but also adding genuinely missing Brazilian historical entities to Wikidata (Paiva et al., 2024).

“The Wind in Our Sails” constructs a reusable Dutch maritime history knowledge graph over four datasets: Dutch-Asiatic Shipping, Bookkeeper-General Batavia, Places, and VOC Opvarenden (Schouten et al., 2021). The graph is built with CIDOC CRM as base ontology and later extends to a CIDOC CRM extension for social, legal, and economic life. Voyages are the backbone concept. A notable modeling revision changes voyages from subclass CRM:E7 Activity to CRM:E9 Move, allowing goods to be linked through CRM:P25 moved. The datasets contribute about 4,700 outbound voyages, 3,400 return voyages, 18,722 BGB records, 4,252 place instances, and 774,200 crew members. The project emphasizes transparency, accessibility, re-usability, and maintainability as design criteria (Schouten et al., 2021).

“Granularity in Actoin” shifts from entities to actions as the constitutive unit of social-historical analysis (Dam et al., 8 Jul 2026). Its GRAM framework uses nodes for Actions, Actors, and Places, and edges such as NEXT, TAKES_PLACE, HAS_ORIGIN, HAS_DESTINATION, HAS_AGENT, HAS_PATIENT, and HAS_INSTRUMENT. The pipeline begins with OCR/transcription and segmentation, filters texts with a SetFit-style classifier, identifies verb instances with a POS tagger, and then uses DSPy-managed prompting to extract subject, object, location, snippet, verb, infinitive, and title. The worked example reports 836 observations of foregive and, after manual inclusion of semantically close udgive instances, a final pretending dataset of 1091 examples; in the St. Croix material, only 11 related examples are identified. The paper also states that the approach is constrained by verb-centered extraction, source explicitness, and role ambiguity (Dam et al., 8 Jul 2026).

LogCanvas applies the same basic intuition to user search history rather than to formal historical archives (Xu et al., 2018). It segments search logs into sessions according to time intervals, retrieves the top 10 search result snippets for each query, uses Yahoo Fast Entity Linker to identify candidate entities, retains the top 5 entities or concepts, and builds edges from Wikipedia co-occurrence counts normalized with a parameter $A$9. The result is a session-based knowledge graph that captures semantic relationships among queries, supports a session viewer, a knowledge-graph viewer, and a snippets viewer, and extends to collaborative group views (Xu et al., 2018).

Across these humanities and information-retrieval systems, a history graph is less about dynamic message passing than about making dispersed historical material queryable, alignable, and comparable.

6. Biological lineage, software provenance, and inverse histories

In comparative genomics, the history graph is a formal data structure for evolutionary reconstruction under parsimony (Paten et al., 2013). A sequence graph is a bidirected graph $$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$0 whose vertices represent DNA segments and whose adjacencies represent covalent bonds between neighboring DNA ends. A history graph adds a set of directed edges $$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$1 called branches, yielding

$$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$2

with the constraint that the event graph obtained by contracting adjacencies is a DAG. This allows ancestry/homology and physical adjacency/chromosome structure to be represented simultaneously. The paper defines realizations, reductions, lower and upper bounds on substitution and rearrangement cost, and the exact cost

$$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$3

Its central tractable subclass is the ancestral variation graph (AVG), characterized by zero ambiguity $$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$4, for which the lower and upper bounds coincide (Paten et al., 2013).

Software engineering uses yet another variant. The Software Heritage Graph Dataset models public software development history as a fully deduplicated Merkle DAG spanning contents, directories, revisions, releases, snapshots, and origins (Pietri et al., 2020). The paper describes the graph as a single uniform graph of public software history, where identical artifacts are shared across the graph via cryptographic hashes. It reports 85,143,957 origins, 57,144,153 snapshots, 1,125,083,793 revisions, 4,422,303,776 directories, and 5,082,263,206 contents. Because snapshots capture all branches observed during a crawl and origin visits connect URLs and times to snapshots, the dataset supports cross-repository, cross-fork, and cross-VCS history analysis at very large scale (Pietri et al., 2020).

Inverse problems introduce a more probabilistic notion of history graph. DASH studies reconstruction of a complete diffusion history from only a single final snapshot (Qiu et al., 2023). The paper argues that maximum-likelihood estimation is fundamentally brittle because snapshot probability and diffusion-parameter MLE are NP-hard and because likelihoods are sensitive to parameter error. It therefore replaces history MLE with a barycenter formulation over posterior hitting times and solves the problem with DITTO, which combines mean-field parameter estimation, Metropolis–Hastings MCMC, and an unsupervised GNN proposal. On the Covid dataset, DITTO is reported as 10.06% better in NRMSE than the best baseline (Qiu et al., 2023).

At the level of model internals, HISTOGRAPH uses the term for the history of node activations across GNN layers rather than for an external temporal process (Galron et al., 3 Jan 2026). It forms a history tensor from intermediate activations $$A_{ij}=1 \text{ if there is a coreference relation between node } i \text{ and node } j;\ \text{else } A_{ij}=0.$$5, applies unified layer-wise attention and then node-wise self-attention, and reports results including IMDB-B 87.2%, IMDB-M 61.9%, MUTAG 97.9%, PROTEINS 97.8%, and NCI1 85.9%. This specialized usage underscores the breadth of the term: “history graph” can denote a graph of past events in the world, a stored graph of past graph states, or the accumulated internal states of a graph model itself (Galron et al., 3 Jan 2026).

The term therefore has no single canonical meaning. Its stable core is methodological rather than ontological: a history graph is a graph formalism designed to preserve, organize, or reason over historical dependence. What varies across domains is what counts as “history”—dialog turns, logical-form traces, entity-time states, archival actions, software revisions, evolutionary ancestry, or diffusion trajectories—and which graph operation is primary: attention, retrieval, alignment, parsimony, or probabilistic reconstruction.