Papers
Topics
Authors
Recent
Search
2000 character limit reached

Language-Table: Natural-Language Table Understanding

Updated 24 October 2026
  • Language-Table is the research area that enables language models to represent, retrieve, interpret, generate, transform, and extract structured tables across applications such as QA, spreadsheet editing, and document analysis.
  • Effective systems combine table-aware representations, structured serialization, retrieval, instruction tuning, and deterministic execution because tables encode two-dimensional relations, schemas, data types, and spans that ordinary token sequences can obscure.
  • Practical results show that specialized methods improve reliability and scalability, including TableRAG’s 49.2 accuracy on ArcadeQA versus 4.6 for full-table prompting, Table-GPT’s 98 of 104 improvements over vanilla models, and visual systems that evaluate both cell content and logical adjacency.

Language-Table denotes the research area concerned with representing, retrieving, interpreting, generating, transforming, and extracting tabular data through natural-LLMs. It encompasses syntactic lexicons, table-to-text generation, table retrieval, table question answering, spreadsheet manipulation, table editing, multilingual reasoning, document-image extraction, table discovery, heterogeneous-column transformation, and table-specific pre-training. Its central problem is the mismatch between tables as two-dimensional, schema-dependent structures and LLMs as systems primarily trained on one-dimensional token sequences. Recent work addresses this mismatch through explicit syntactic constructions, structured serialization, retrieval, program execution, instruction tuning, table-aware encoders, hypergraph representations, multilingual supervision, and graph-based evaluation.

1. Conceptual foundations and representational regimes

A table is more than a sequence of cell values. Its interpretation depends on headers, row and column membership, data types, spans, metadata, and relations among cells. The survey literature characterizes a structured table as a grid T={cij}T=\{c_{ij}\} with a schema containing headers, data types, and constraints (Lu et al., 2024). Rows and columns often exhibit approximate permutation properties: swapping rows or consistently swapping columns may preserve meaning, unlike permuting words in a sentence. However, order can also be semantically meaningful in rankings, time series, and hierarchical layouts.

The principal representational regimes are:

  • Linear serialization: tables are rendered as Markdown, CSV, HTML, JSON, XML, SQL schemas, or delimiter-based text. This makes tables consumable by ordinary LLMs but may obscure row–column alignment, merged cells, hierarchy, and two-dimensional locality.
  • Structured serialization: cells are represented with coordinates, header spans, row and column identifiers, or tuples. Complex-table QA uses five-tuples for column headers, five-tuples for row headers, and four-tuples for non-header cells (Zhao et al., 2023).
  • Retrieval-based representation: only relevant schemas, rows, columns, cells, or metadata are supplied to the model. TableRAG separates schema retrieval from cell retrieval and uses the LLM as a program-aided solver (Chen et al., 2024).
  • Dedicated table encoders: table structure is modeled with row, column, cell-type, graph, or hypergraph representations. TAMO combines serialized text with a hypergraph encoder whose output is projected into the LLM’s embedding space (Li et al., 30 Nov 2025).
  • Visual and logical representations: document-image extraction systems recover cell contents, adjacency, spans, and logical HTML structure. PulseBench-Tab evaluates tables as directed logical-adjacency graphs rather than as flat OCR strings (Pandey et al., 21 Apr 2026).

Serialization itself influences which relations models preserve. In a controlled lookup task, row-major formatting performs better on tall tables, while locally headed column-major formatting performs better on wide tables. Row-major errors tend to preserve the correct row but lose the target column; column-major errors tend to preserve the correct column but lose the row (Ma et al., 17 Oct 2026). This behavior is described as relational locality: a serialization keeps one relation locally available while making another dependent on positional alignment.

2. Linguistic tables and explicit lexical structure

The Lexicon-Grammar tables constitute a large-coverage French syntactic lexicon rather than merely a collection of words. Lexical items are grouped into classes when they share syntactic and distributional properties. Each table approximately corresponds to one such class, including verbs, predicative nouns, fixed expressions, and adverbs. The shared properties are propriétés définitoires, or table-defining properties (Tolone et al., 2010).

An LG table contains lexical entries and properties or columns, generally marked with +, -, or ~. A + indicates acceptance of a construction, - indicates non-acceptance, and ~ indicates unresolved or uncoded information. A table-defining property applies to all members and belongs in the formal table definition; an entry-level property varies across lexical items and remains an explicit column.

The paper formalizes table definitions through base constructions using LG notation:

  • N0N_0: subject or first nominal argument;
  • N1,N2,N3N_1,N_2,N_3: successive nominal arguments;
  • VV: lexical verb;
  • NhumN_{\text{hum}}: human noun phrase;
  • N-humN\text{-hum}: non-human noun phrase;
  • LocLoc: locative complement;
  • PreˊpPrép: preposition;
  • DetDet: determiner;
  • AdvAdv: adverb;
  • N0N_00: fixed constituents;
  • N0N_01: unspecified sentential context;
  • N0N_02: pronominal personal complement;
  • N0N_03: support verb.

For example, N0N_04 represents a transitive frame, while N0N_05 represents a direct object and an à-introduced complement. The construction is schematic rather than an individual sentence.

The revised definitions separate universal class properties from entry-specific restrictions. In appearance and disappearance classes, transitivity N0N_06 is separated from the semantic property that N0N_07 denotes appearance or disappearance. Symmetric verbs are defined through both a prepositional construction and a coordination-like construction, such as N0N_08 and N0N_09. Dative classes distinguish human-dative conditions from entry-level pronominalization.

The methodology includes tracing published descriptions, comparing them with actual table columns, identifying implicit properties, renaming columns, removing ambiguous uses of +, duplicating conflated columns, splitting tables with incompatible argument structures, and creating missing classes. Locative verbs are divided into source, destination, source-and-destination, static-locative, and residual-movement subclasses. This makes dependencies such as source complements requiring destination complements computationally explicit.

The resulting definitions support parsing by exposing argument number, direct or prepositional status, human or non-human restrictions, source or destination roles, pronominalization, reciprocal relations, fixed constituents, and adverbial placement. The work does not provide a complete database schema, formal ontology, automatic definition-induction algorithm, or numerical parser evaluation. Its contribution is linguistically motivated notation and normalization.

3. Generation, retrieval, and question answering

Table-to-text generation maps a structured region to natural language. Table2Seq represents each attribute–cell pair by combining a cell embedding and an attribute embedding, then uses a GRU decoder with recurrent table attention and a flexible copy-generation mixture (Bao et al., 2018). The recurrent attention mechanism tracks previously attended columns, while the copy gate allocates probability between generating from a fixed vocabulary and copying table values. Table2Seq++ additionally copies attribute names.

The principal datasets include WIKITABLETEXT, WIKIBIO, and SIMPLEQUESTIONS. WIKITABLETEXT contains 4,962 tables and 13,318 row–sentence pairs. Table2Seq reaches 37.90 BLEU-4 on its test set, while Table2Seq++ reaches 38.23. Removing copying reduces test BLEU-4 to 5.41; removing the caption reduces it to 27.06. These ablations indicate that rare-value preservation and global table context are central to generation. The system nevertheless produces repetitions, wrong-column selections, inappropriate relation words, omissions, and semantically plausible paraphrases that receive low lexical-overlap scores.

Table retrieval treats the table as both structured data and language. In ad hoc table retrieval, a short query is used to rank tables rather than identify a single answer cell. A BERT-based select-then-rank architecture first selects salient rows, columns, or cells using fastText similarity, then serializes the query, metadata, headers, and selected items for BERT encoding (Chen et al., 2020). The strongest configuration, Hybrid-BERT-Row-Max, combines BERT with traditional table-retrieval features. On WikiTables it reaches MAP 0.6737, MRR 0.7139, and NDCG@20 0.6926, compared with MAP 0.5711 for STR. Row selection generally outperforms cell and column selection because rows preserve a compact set of related attributes.

Table question answering includes lookup, aggregation, comparison, arithmetic, multi-hop reasoning, fact verification, and free-form generation. Complex-table QA requires explicit hierarchy handling. The GPT-3.5 approach in (Zhao et al., 2023) reconstructs hierarchical tables into position-aware tuples and instructs the model to select headers, locate cells, perform operations, and return a structured five-line answer. It obtains 50.0 test accuracy on HiTAB and 76.73 single-turn accuracy on AIT-QA. The main failure sources are incorrect header localization, excessive or insufficient header selection, row-header neglect, context truncation, multi-turn information loss, and hallucinated explanations.

TableMaster decomposes table QA into structure understanding, table-of-focus construction, semantic verbalization, and adaptive textual or symbolic reasoning (Cao et al., 31 Jan 2025). Its table-of-focus is reconstructed when the initial selection lacks sufficient information. Textual reasoning handles semantic interpretation, while text-guided symbolic reasoning uses Python or SQL for exact computation. On WikiTQ, TableMaster reaches 78.13% accuracy with GPT-4o-mini; on TabFact it reaches 90.12%. Removing textual reasoning causes a 4.28-point WikiTQ decline, while removing reconstruction causes a 2.58-point decline.

4. Table instruction tuning, agents, and transformations

Table-GPT defines a table task as a triple N1,N2,N3N_1,N_2,N_30 comprising an instruction, an input table, and a completion (Li et al., 2023). Table-tuning continues training GPT-style models on diverse table tasks rather than optimizing one task at a time. The training collection includes 14 task types, approximately 1,000 instances per task type, zero-shot and few-shot prompt templates, and tables sampled from deduplicated web and database collections.

The task taxonomy includes missing-value identification, column finding, table question answering, column-type annotation, row-to-row transformation, entity matching, schema matching, data imputation, error detection, natural-language-to-SQL, summarization, row and column augmentation, filtering, sorting, and swapping. Tables are augmented through row and column permutation, sampling, instruction paraphrasing, and completion-level reasoning or explanation. Across 104 comparisons, table-tuned models outperform their vanilla counterparts in 98 tests, tie in 3, and lose in 3. Table-GPT-3.5 has an overall score of 0.705 compared with 0.548 for GPT-3.5.

LLM-powered table agents combine interpretation with retrieval, SQL, Python, spreadsheet APIs, validation, reflection, and execution. The survey describes an iterative observation–plan–action–environment loop (Lu et al., 2024). Such systems use the LLM for question interpretation, schema linking, decomposition, and natural-language generation, while delegating filtering, joins, aggregation, sorting, arithmetic, and exact execution to deterministic tools. The advantages are auditability and numerical reliability; the costs are latency, tool-selection errors, invalid code, privacy risks, and engineering complexity.

WikiTableEdit frames table editing as direct language-to-table transformation rather than code generation. Each instance is N1,N2,N3N_1,N_2,N_31 (Li et al., 2024). Its 223,702 instances cover adding, removing, swapping, reordering, merging, and splitting. HTML represents irregular tables with rowspan and colspan. GPT-3.5-turbo obtains 6.34% exact match in zero-shot evaluation, illustrating the difficulty of producing an entirely correct target table. Merged-cell operations require span recomputation, not merely text permutation.

TabulaX addresses heterogeneous column transformation and unequal-table joins (Nobari et al., 2024). It first classifies transformations as string-based, numerical, algorithmic, or general, then routes them to specialized modules. String transformations produce Python functions; numerical transformations use linear, quadratic, exponential, or rational curve fitting; algorithmic transformations use semantic relationship tagging followed by code generation; general transformations use LLM-based lookup behavior. TabulaX achieves F1 0.983 on Web Tables, 0.952 on Spreadsheet data, and 0.567 on Knowledge Base Web Tables. Its strongest performance is on deterministic transformations; general external-knowledge mappings remain vulnerable to hallucination and one-to-many ambiguity.

5. Retrieval, discovery, and large-scale table access

Full-table prompting becomes infeasible for large tables. A table with 100 columns and 200 rows can exceed 40,000 tokens, and million-cell tables introduce context-length, cost, latency, and positional-bias problems. TableRAG addresses this through separate schema and cell indexes (Chen et al., 2024).

Its offline schema database stores column names, inferred data types, minimum and maximum values for numerical or datetime columns, and frequent categories for categorical columns. Its cell database stores deduplicated column–cell pairs. Query expansion produces schema queries and cell queries. Schema retrieval identifies attributes needed for computation; cell retrieval identifies how entities or categories are represented and where they occur. The solver then receives retrieved evidence and accesses the original dataframe through python_repl_ast.

TableRAG is evaluated on ArcadeQA, BirdQA, and synthetic TabFact settings reaching one million cells. On ArcadeQA, TableRAG obtains 49.2 accuracy with GPT-3.5, compared with 4.6 for full-table prompting and 43.1 for schema-only prompting. On BirdQA it obtains 45.5 compared with 9.1 for full-table prompting. On synthetic million-cell TabFact, performance declines from 83.1 on the smallest setting to 68.4 at N1,N2,N3N_1,N_2,N_32, while full-table prompting becomes infeasible. The method’s principal limitations are frequency bias, rare-value exclusion, query-expansion failure, distinct-value growth, and dependence on the program-aided solver.

TableCopilot extends table access from analysis to discovery. Its Natural Language Conditional Table Discovery scenario accepts both a natural-language condition and an optional query table (Cui et al., 11 Jul 2025). The query table determines structural compatibility, such as unionability or joinability, while the condition specifies semantic, numeric, temporal, or user-specific constraints.

Crofuma combines same-modality table matching with cross-modal natural-language matching. Query-table columns are represented with a contrastively trained column encoder. Union search uses maximum-weight bipartite matching over column similarities; join search compares designated key-column embeddings. Natural-language scoring combines candidate table representations, condition embeddings, metadata, elementwise differences, and Hadamard products. HNSW provides approximate retrieval, and the final score combines table compatibility and condition relevance.

On NLCTABLES, containing 627 queries, 22,080 tables, and 21,200 relevance annotations, Crofuma reaches reported NDCG@5 values of 0.4124 and 0.4825 for NL-conditional union settings and 0.6674 and 0.6976 for NL-conditional join settings. The system reports average query time below 500 ms for a repository containing more than 7,500 tables. The evidence does not establish long-term personalization, million-table latency, predicate verification, or bias mitigation.

6. Multilingual, morphological, and visual table understanding

Multilingual table understanding is constrained by language-resource imbalance, translation quality, tokenization, script, morphology, and table structure. TaTa provides 8,700 examples in nine languages, including Hausa, Igbo, Swahili, and Yorùbá, with Arabic, English, French, Portuguese, and Russian in its multilingual setting (Gehrmann et al., 2022). Its data originate from DHS reports and include screenshots, transcribed tables, translated tables, and natural-language descriptions. Human evaluation shows that only 44% of mT5-XXL outputs are both understandable and attributable to the source. STATA, a source-aware learned metric, reaches Pearson correlation 0.66 with human judgments, compared with 0.16 for chrF.

M3TQA expands multilingual table QA to 97 languages and four tasks: numerical computation, cell extraction, factual verification, and open-ended questions (Shu et al., 22 Aug 2025). It uses 50 Chinese and English source tables, LLM-assisted translation, back-translation validation, human checks, and 39,077 synthetic instruction examples. The benchmark contains 2,916 professionally checked LLM-generated QA pairs and 4,294 human-constructed QA pairs. Synthetic multilingual supervision improves low-resource performance, although multilingual interference causes regressions in some languages after supervised fine-tuning or GRPO.

TabuLM specializes table pre-training for Kinyarwanda (Rakshitha et al., 27 Aug 2026). It extends KinyaBERT with row, column, and cell-type embeddings, a table-structure attention bias, Masked Cell Recovery, and Column Type Prediction. The model is pre-trained on approximately 172 Rwandan government tables containing roughly 35,000 cells and evaluated on TabQA-kin, comprising 526 QA pairs across 31 tables. TabuLM reaches 62.0% exact match, compared with 56.3% for KinyaBERT-large, 50.0% for XLM-R, and 49.3% for mBERT. Removing row, column, and type embeddings reduces performance to 58.0%; removing the learned attention bias, MCR, or CTP does not produce a detectable loss on the small evaluation set.

Table extraction from document images requires recovering both textual content and logical geometry. PulseBench-Tab contains 1,820 human-annotated tables from 380 documents, covering nine languages, four scripts, 2–1,183 cells, and merged or spanning cells in 48.1% of tables (Pandey et al., 21 Apr 2026). Its T-LAG metric parses HTML into a logical grid, constructs directed RIGHT and BELOW adjacency edges, compares source and target cell text with character-level Levenshtein similarity, and uses optimal bipartite matching. The metric combines content and structural fidelity while penalizing missing, extra, shifted, or incorrectly spanned cells.

Pulse Ultra 2 is the best evaluated system in every language, with scores from .910 on English to .972 on French. Unstructured is weakest, ranging from .137 on Korean to .563 on Spanish. AWS Textract reaches .724 on English but only .240 on Arabic, .254 on Korean, .324 on Chinese, and .479 on Japanese. These results demonstrate that aggregate extraction quality can conceal script-specific failures.

7. Current limitations and research directions

Several limitations recur across Language-Table systems. Linearization can lose two-dimensional structure, hierarchy, spans, and relational locality. Retrieval can omit rare but decisive evidence. LLM-generated code can be syntactically valid yet semantically incorrect. Table-to-text metrics can penalize correct paraphrases, while lexical overlap can reward unsupported or hallucinated text. Synthetic supervision can inherit teacher errors. Multilingual resources often depend on translation rather than native tables, and low-resource languages remain underrepresented.

A robust architecture therefore requires a division of labor:

  1. Structural representation: preserve headers, coordinates, row and column identity, spans, cell types, and hierarchy.
  2. Adaptive retrieval: select relevant schemas, rows, columns, cells, metadata, and external knowledge without losing fallback access to the original table.
  3. Semantic interpretation: use LLMs for schema linking, intent understanding, decomposition, and natural-language generation.
  4. Deterministic execution: delegate filtering, joins, sorting, aggregation, arithmetic, SQL, and spreadsheet operations to executable tools.
  5. Verification: validate schema references, tool calls, numerical results, cell provenance, target-table structure, and source attribution.
  6. Multilingual evaluation: report per-language, per-script, per-domain, and per-table-structure results, with coverage and uncertainty.
  7. Representation robustness: evaluate multiple serializations, row and column permutations, source-cell retention, and structural invariance.
  8. Native table data: supplement translated resources with tables authored in the target language and culturally specific domains.
  9. Efficient specialization: use table encoders, adapters, retrieval indexes, morphology-aware modules, and small specialized models where they reduce the cost of general LLM inference.
  10. Human-auditable outputs: return cell coordinates, citations, executable plans, formulas, transformation functions, or structured JSON when exactness matters.

The emerging consensus is not that one representation or model family dominates. Lexicon-Grammar work shows that computational utility requires explicit metadata and typed constructions. Table-to-text systems show that rare-value copying and table context are essential. Retrieval systems show that full-table prompting does not scale. Table-tuned LLMs show that multi-task supervision improves structural operations. Hypergraph and morphology-aware models show that explicit relational and linguistic structure can complement token-level representations. Multilingual and visual benchmarks show that language, script, and document geometry materially affect reliability. Serialization studies further show that apparent model limitations may arise from which table relations a particular linearization makes locally accessible.

Language-Table research therefore treats tables as structured, language-bearing computational objects. The central design problem is to preserve the table’s “what”—its cell content and lexical semantics—together with its “where”—its rows, columns, headers, hierarchy, spans, and relational constraints—while enabling natural-language interaction, exact computation, scalable retrieval, multilingual transfer, and verifiable outputs.

Topic to Video (Beta)

No one has generated a video about this topic yet.

Whiteboard

No one has generated a whiteboard explanation for this topic yet.

Follow Topic

Get notified by email when new papers are published related to Language-Table.