Modeling Tables as Graphs for Structural Reasoning

23 concepts18 papers1 proposal

When we read a table, our eyes naturally navigate a two-dimensional grid. We instantly connect a data cell to its corresponding column header above and its row attribute to the left. However, when standard Large Language Models (LLMs) process tabular data, they are forced to read it through a straw.

Standard architectures require tables to be flattened into a linear sequence of text tokens—such as comma-separated values (CSV), Markdown, or HTML strings. This linearization introduces a fundamental mismatch between the multi-dimensional topology of structured data and the one-dimensional input space of sequential models. To overcome this limitation, a growing body of research advocates for treating tables not as flat text, but as structured graphs.

The Linearization Tax

Why does flattening a table degrade a model's ability to reason over it? Linearization destroys spatial proximity. As observed by Chuang Liu et al. in Tab-CQA: A Tabular Conversational Question Answering Dataset on Financial Reports, treating tables as unstructured paragraphs discards the explicit row and column boundaries that are essential for complex numerical and logical reasoning.

In a large table, a column header and a data cell in the 50th row are semantically tightly coupled, yet textually separated by thousands of tokens. This spatial dislocation triggers two primary failure modes:

  1. The "Lost in the Middle" Phenomenon: Transformers inherently struggle to retrieve and reason over information buried deep within long context windows.
  2. Misalignment Errors: When navigating long text strings, models frequently misattribute cell values to the wrong headers or rows, especially when confronted with blank cells or sparse data (Yuxiang Wang et al. in Beyond Linearization: Attributed Table Graphs for Table Reasoning).

Even structured text formats like Markdown, which provide weak layout hints to vision-language models (Chao Deng in LongDocURL: a Comprehensive Multimodal Long Document Benchmark Integrating Understanding, Reasoning, and Locating), fail to explicitly preserve the underlying relational dependencies of complex layouts.

The Graph Abstraction

Graph-based table modeling solves this by mapping the table's visual and logical structure directly into a network of nodes and edges.

[Header: Year] <====== (Column Edge) ======> [Cell: 2026]
      ||                                           ||
 (Row Edge)                                   (Row Edge)
      ||                                           ||
[Header: Revenue] <==== (Column Edge) ======> [Cell: $5M]

In this formulation:

  • Nodes represent discrete textual or structural elements, such as individual cells, headers, entire rows, or a global table root.
  • Edges explicitly encode the topological relationships between these elements, such as "shares a row," "shares a column," or "is header of."

This abstraction applies across the entire lifecycle of table processing. For structure recognition from raw document images or PDFs, Yiren Li et al. in GFTE: Graph-Based Financial Table Extraction and Murat Şimşek in Handling big tabular data of ICT supply chains: a multi-task, machine-interpretable approach demonstrate that reconstructing a table's grid can be framed as predicting horizontal and vertical edges between cell nodes. For downstream reasoning, models use these pre-defined edges to route information directly between related entities (Rihui Jin et al. in TabPrompt: Graph-based Pre-training and Prompting for Few-shot Table Understanding; Wenting Zhao et al. in Localize, Retrieve and Fuse: A Generalized Framework for Free-Form Question Answering over Tables).

Why Graph Representations Work

Shifting from linear strings to graphs fundamentally alters how neural networks compute representations of tabular data. The performance gains observed in recent architectures stem from three primary structural mechanisms.

1. Short-Circuiting Distance via Message Passing

In a graph, the distance between a column header and a cell at the bottom of that column is exactly one edge hop, completely independent of how many rows sit between them. By utilizing Graph Convolutional Networks (GCNs) or specialized attention mechanisms, models can pass messages directly along these structural pathways.

This preserves multi-dimensional context that is otherwise lost in sequential processing (Xingyao Zhang et al. in A Graph Representation of Semi-structured Data for Web Question Answering). Information flows natively through the layout topology, allowing models to accurately link headers with distant data values without suffering from attention dilution (Tanishq Gupta et al. in DiSCoMaT: Distantly Supervised Composition Extraction from Tables in Materials Science Articles).

2. Managing Layout Complexity Natively

Real-world tables are rarely uniform grids; they frequently feature hierarchical multi-row headers, merged cells, and nested lists. Linear text strings become highly ambiguous under these conditions.

Graphs handle this complexity by varying node and edge types. Rihui Jin et al. in HeGTa: Leveraging Heterogeneous Graph-enhanced Large Language Models for Few-shot Complex Table Understanding show that heterogeneous graphs can explicitly preserve non-adjacent topological relationships, such as a multi-level header hierarchy overseeing a merged data cell.

Taking this further, Liyao Li et al. in Table as a Modality for Large Language Models introduce a hypergraph framework. Instead of simple pairwise edges, entire rows or columns are modeled as hyperedges that encompass groups of nodes simultaneously. This preserves the global grid context and hierarchical semantics natively, allowing the table to be treated as a distinct modality within LLMs.

3. Permutation Invariance

If you shuffle the rows of a CSV file, the text sequence changes entirely, forcing an LLM to process a completely novel string. However, swapping two rows in an attributed table graph does not alter the topological connections between the cells and their respective column headers.

As demonstrated by the training-free framework proposed by Yuxiang Wang et al. in Beyond Linearization: Attributed Table Graphs for Table Reasoning, decomposing a table into structured graph triples allows algorithms like PageRank to surface question-relevant data cells. Because the underlying graph topology remains identical regardless of visual ordering, the model's reasoning process becomes inherently robust to table permutations.

Beyond the Standard Grid

The intuition behind graph-based table modeling extends naturally to adjacent domains where relational structure dominates text sequence.

By replacing the rigid, sequential constraints of text strings with the flexible, topological pathways of graphs, these approaches allow deep learning models to reason over structured data using the same multi-dimensional relationships in which the data was originally conceived.

Key Foundational Work

A Graph Representation of Semi-structured Data for Web Question Answering (2020) — contributed 2 concept elements to this direction.
GFTE: Graph-Based Financial Table Extraction (2020) — contributed 2 concept elements to this direction.
Representations for Question Answering from Documents with Tables and Text (2021) — 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_graph_based_table_representation_2120687e,
  title = {graph-based table representation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/graph-based-table-representation/rdr_2120687e4ea143c8acab33535f9fc550},
  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_graph_based_table_representation_2120687e_v1,
  title = {graph-based table representation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/graph-based-table-representation/rdr_2120687e4ea143c8acab33535f9fc550/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