ASTRA: Adaptive Semantic Tree Reasoning Architecture for Complex Table Question Answering

Xiaoke Guo; Songze Li; Zhiqiang Liu; Zhaoyan Gong; Yuanxiang Liu; Huajun Chen; Wen Zhang

cs.CLApr 10, 2026

ASTRA: Adaptive Semantic Tree Reasoning Architecture for Complex Table Question Answering

Authors: Xiaoke Guo, Songze Li, Zhiqiang Liu, Zhaoyan Gong, Yuanxiang Liu, Huajun Chen, Wen Zhang

Organizations: Zhejiang University

Abstract

Table serialization remains a critical bottleneck for Large Language Models (LLMs) in complex table question answering, hindered by challenges such as structural neglect, representation gaps, and reasoning opacity. Existing serialization methods fail to capture explicit hierarchies and lack schema flexibility, while current tree-based approaches suffer from limited semantic adaptability. To address these limitations, we propose ASTRA (Adaptive Semantic Tree Reasoning Architecture) including two main modules, AdaSTR and DuTR. First, we introduce AdaSTR, which leverages the global semantic awareness of LLMs to reconstruct tables into Logical Semantic Trees. This serialization explicitly models hierarchical dependencies and employs an adaptive mechanism to optimize construction strategies based on table scale. Second, building on this structure, we present DuTR, a dual-mode reasoning framework that integrates tree-search-based textual navigation for linguistic alignment and symbolic code execution for precise verification. Experiments on complex table benchmarks demonstrate that our method achieves state-of-the-art (SOTA) performance.

Figures & tables

Figure 1: Key desiderata for robust table serialization and their instantiation in AdaSTR.

Method	Explicit Hierarchy	Semantic Context	Representation Alignment	Schema Flexibility	Symbolic Compatibility
Textual Serialization	$\blacktriangle$	✗	✗	$\blacktriangle$	✗
(Html/MarkDown)
Triples	✗	✗	✗	✓	$\blacktriangle$
(GraphOTTER)
Relational	$\blacktriangle$	✓	$\blacktriangle$	✗	✓
(TabFormer)

Table 1: Comparison of serialization methods ( ✓ Support;

\blacktriangle

Partial; ✗ No Support).

Figure 2: Overview of the Adaptive Semantic Tree Reconstruction process.

Figure 3: Overview of the Dual-Mode Tree Reasoning process.

Model	AIT-QA	SSTQA	HiTab
(1) Foundation Models
DeepSeek-V3	78.5	63.2	82.0
GPT-4o	80.6	66.4	78.6
o3	89.1	78.2	85.3
(2) Prompting/Tool-augmented Methods
E5	87.1	70.2	85.1

Table 2: Accuracy (%) on AIT-QA, SSTQA, and HiTab. Bold denotes best, underlined denotes second best.

\dagger

indicates results cited from prior literature. Oracle represents the theoretical upper bound via ideal selection between Textual and Symbolic reasoning.

Tree Construction (DeepSeek-V3)	Coverage Rate		Struct Acc
Tree Construction (DeepSeek-V3)	Avg	Min	Avg	Min
AdaSTR	0.929	0.738	0.792	0.654
w/o Evaluator-Guided	0.745	0.473	0.698	0.143
w/o Synthesis Strategies	0.795	0.153	0.643	0.457

Table 3: Ablation of AdaSTR . We report Average (Avg) and Minimum (Min) Coverage Rate and Structural Accuracy to evaluate robustness across diverse tables.

Configuration	Acc (%)	$\Delta$
Adaptive Tree Navigation	79.84	-
w/o Embedding Model	71.34	-8.50
w/o Dynamic Switching	-	-
Force Root-to-Leaf	77.23	-2.61
Force Leaf-to-Root	75.65	-4.19
Symbolic Tree Manipulation	75.26	-

Table 4: Ablation analysis of DuTR (DeepSeek-V3) . We report Accuracy (%) and performance change (

\Delta

) vs. full configuration per mode. Bottom evaluates representational benefits of the tree structure.

Method	AIT-QA		HiTab		SSTQA
Method	Tree	QA	Tree	QA	Tree	QA
ST-Raptor	55.73	31.18	139.61	26.61	233.19	41.36
GraphOTTER	-	19.54	-	22.29	-	21.83
Ours	29.18	7.80	43.42	6.19	93.71	11.62

Table 5: Comparison of time efficiency (in seconds) across different datasets. We record the latency for both the Tree Construction phase (Tree) and the Question Answering phase (QA). “-” denotes the method does not involve a tree construction phase.

Figure 4: Performance breakdown by question type and difficulty for DuTR and baselines.

Panel of Figure 5 — Figure 5: A representative case study involving sibling branches and irregular children. ASTRA utilizes precise dictionary traversal to correctly enumerate all items.

Appendix figures & tables12 assets

Supplementary material from the paper’s appendix.

Appendix

Dataset	# Tables	# QAs	Domain
HiTab	538	1,584	Open domain
AIT-QA	80	367	Airline industry
SSTQA	102	764	Open domain

Appendix

Table 6: Dataset Statistics. Details of the test sets used in our experiments. SSTQA specifically targets real-world semi-structured tables.

Figure 6: Visualization of the Operating Expenses Analysis table.

Figure 13

Figure 9: Relationship between evaluation metric scores (information coverage and structure integrity) and downstream QA accuracy across score bins.

Method	Accuracy	Latency	Training
Baseline (Direct)	70.55%	$\sim$ 0.5s	No
Strategy I (CoT)	72.39%	$\sim$ 13.0s	No
Strategy II (SFT)	76.68%	$\sim$ 0.5s	Yes
Strategy III (Debias)	73.61%	$\sim$ 0.6s	No

Appendix

Table 7: Performance comparison of optimization strategies on the conflicting subset (

N=163

Error Type	Definition	Count	%
Structural Misalignment	The generated code assumes a rigid schema (e.g., specific depth, key-value placement) that does not match the heterogeneous tree structure, leading to execution failures.	22	36.7%
Annotation Error	The model output is factually correct given the table content, but the gold label is incorrect due to annotation errors, typos, or calculation mistakes in the dataset.	16	26.7%
Arithmetic Hallucination	Textual reasoning fails at precise operations: arithmetic aggregation, numerical comparison (especially negative numbers/decimals).	12	20.0%
Retrieval Bias	The model exhibits semantic short-circuiting , selecting high-level summary nodes (e.g., "Total") that match keywords but lack the required categorical granularity, failing to drill down to specific leaf details.	10	16.7%

Appendix

Table 8: Distribution of error types across

N=60

sampled failure cases.

Figure 10: Statistics of error categories by reasoning failure mode.

Structure Representation	Reasoning Method	EM (%)
Baselines
TabFormer Dong et al. (2025a)	Chain-of-Table Wang et al. (2024b)	57.4
	E5 Zhang et al. (2024c)	56.9
	ReactTable Zhang et al. (2023)	54.3
RelationalCoder Dong et al. (2025b)	Chain-of-Table Wang et al. (2024b)	66.7
AdaSTR (Ours)	DuTR(textual reasoning)	64.1

Appendix

Table 9: Supplementary comparison with relational transformation methods. We evaluate different structure representations coupled with various reasoning methods.

Method	Qwen2.5-7B	Llama3.1-8B	Qwen3-8B
Method	Qwen2.5-7B	Llama3.1-8B	no thinking	thinking
Direct Prompt (Raw Table)	46.60	35.99	52.75	54.97
Direct Prompt (Semantic Tree)	49.74	37.43	60.86	64.92
ASTRA (Textual Reasoning)	50.14	40.45	60.60	65.45
ASTRA (Symbolic Reasoning)	36.39	10.47	58.64	62.70
ASTRA (Adaptive Selection)	53.01	41.49	65.31	70.02

Appendix

Table 10: Performance of Open-Source Models on the SSTQA Dataset. The best results are highlighted in bold , and the second-best results are underlined . Note that the “Direct Prompt” method follows the same workflow as the Foundation model approach used in the main experiments.

Configuration	Acc (%)	$\Delta$
Adaptive Tree Navigation	60.60	-
w/o Embedding Model	56.68	-3.92
w/o Dynamic Switching	-	-
Force Root-to-Leaf	55.76	-4.84
Force Leaf-to-Root	58.64	-1.96
Symbolic Tree Manipulation	58.64	-

Appendix

Table 11: Ablation analysis of DuTR (Qwen3-8B) . We report the Accuracy (%) and the performance change (

\Delta

) compared to the full configuration within each mode.

Question	How many expense records have an empty summary?
Gold Answer	26
GraphOTTER	Output: 4 Evidence: The dense retriever only located 4 isolated empty cells out of 26: [(5, 6, ‘’), (13, 6, ‘’), (16, 6, ‘’), (19, 6, ‘’)] Failure Analysis: The vector-based retriever struggled to match the query "empty summary" with actual empty strings, resulting in extremely low recall.
ST-Raptor	Output: 46 Process: Decomposed the query and generated the operation chain: [MATH] + [Summary] + [CNT] . Failure Analysis: While it correctly identified the column and the counting task, the execution module failed to apply the "is empty" filter, effectively counting all 46 rows in the table instead of the specific subset.
EEDP	Output: 29 Process: Attempted a manual row-by-row inspection in the CoT: "The following rows have null… 004, 012, 015, 017…" Failure Analysis: The model hallucinated the existence of empty values in non-empty rows during the text generation process, leading to an arithmetic error (counting 29 instead of 26).
Ours	Output: 26 Logic: synthesized a programmatic constraint to filter data accurately: if not record['Summary'].strip(): count += 1 Result: The symbolic execution over the structured tree yielded the exact count (26) without hallucination.

Appendix

Table 12: Case Study on Null Value Aggregation. Comparison of failure modes: GraphOTTER suffers from retrieval miss on empty values (poor Representation Alignment ); ST-Raptor correctly plans but fails in execution (returning total count); EEDP suffers from hallucination during manual enumeration. Our method ensures correctness via symbolic code generation.

Question	What is the average standard error of product sales from month 1 to month 18?
Gold Answer	3685.4505
GraphOTTER	Output: 3439.61 Evidence: The model correctly identified all 14 relevant cells (Months 5–18) and recognized the operation as "Average". Failure Analysis: Arithmetic Hallucination . Despite correct retrieval, the LLM failed to sum the sequence of 14 floating-point numbers accurately during text generation, resulting in an incorrect sum ( $48,154$ instead of $\approx 51,596$ ) and final average.
ST-Raptor	Output: 4287.34 Process: Decomposed into [COND] (Month 1-18) -> [MATH] + [AVR] . Failure Analysis: Execution Error . While the retrieval and plan were semantically correct, the mathematical primitive likely mishandled the ‘None‘ values present in Months 1–4 or failed to compute the weighted mean of the float values correctly.
EEDP	Output: 3399.74 Process: The CoT explicitly listed the 14 values to sum: "3355.12 + 3220.81 + …" Failure Analysis: Calculation Error . Similar to GraphOTTER, the Chain-of-Thought process suffered from calculation drift. The model calculated the sum as $47,596.35$ , significantly deviating from the true sum, leading to an underestimated average.
Ours	Output: 3685.4505 Logic: Generated a symbolic program to iterate and aggregate valid data: if error is not None : total += error; count += 1 Result: By offloading the computation to a Python execution environment, our method achieved exact numerical precision, correctly handling null filtering and floating-point arithmetic.

Appendix

Table 13: Case Study on Arithmetic Aggregation. Comparison of failure modes on long-sequence numerical queries. Baselines correctly retrieve data but suffer from arithmetic hallucination or primitive execution errors , proving the inadequacy of textual processing. Our method ensures verifiable precision via code execution, fulfilling Symbolic Compatibility .

Table QA

Table question answering studies how AI systems retrieve, interpret, and reason over structured data to answer natural-language questions.

See all 66 papers

H2Table: Hierarchical Hypergraph-Enhanced Large Language Models for Complex Table Reasoning
Sep 1, 2026Jia Ling, Yangfan Wang, Chen Tang +4Table QA Hierarchical Representation Learning
Harbin Institute of Technology · AI Research Center, Midea Group (Shanghai) Co., Ltd. · Changchun University of Science and Technology +1
Orthogonal Hierarchical Decomposition for Structure-Aware Table Understanding with Large Language Models
Feb 2, 2026Bin Cao, Huixian Lu, Chenwen Ma +3Table QA Table Structure Recognition
Zhejiang University of Technology, China · Zhejiang Key Laboratory of Visual Information Intelligent Processing, China · University of Aberdeen, UK +1
DeepTable: Structural Attention Biases and Tree Path Encoding for Hierarchical Table Understanding
Sep 7, 2026Jyun-Ying Yen, Cheng-Kuan Lin, Yu-Chee TsengTable QA Table Structure Recognition
Department of Computer Science National Yang Ming Chiao Tung University, Taiwan

Sep 1, 2026J/K move · Enter open · S save

H2Table: Hierarchical Hypergraph-Enhanced Large Language Models for Complex Table Reasoning

Jia Ling, Yangfan Wang, Chen Tang, Haoming Tan+3

Harbin Institute of Technology · AI Research Center, Midea Group (Shanghai) Co., Ltd. · Changchun University of Science and Technology+1

Table QA Hierarchical Representation Learning Hypergraph Neural Networks Tabular Representation Learning

Open paper AskPDF arXiv

Tables are ubiquitous across diverse domains, yet reasoning over them remains a significant challenge for modern large language models (LLMs). Current approaches typically linearize tables into sequences, inherently overlooking their intrinsic two-dimensional and hierarchical structure. To address this, we propose H2Table (Hierarchical Hypergraph-Enhanced Table Reasoning), a novel framework that represents complex tables as hierarchical nested hypergraphs. To process this representation, we design a tailored hypergraph encoder to facilitate message passing between hyperedges (headers) and nodes (cells), thereby perceiving the semantic entailment relationships between them within complex tables. Furthermore, we introduce a set of learnable query vectors acting as a lightweight bridge to extract representative structural embeddings from the encoder into the LLM. Experimental results demonstrate that our approach effectively handles complex table question answering tasks with hierarchical nested headers. Notably, on the HiTab dataset, H2Table achieves an average improvement of 22.88% over state-of-the-art baselines on highly complex tables with a nesting depth of four. Our code is available at: https://github.com/lila120/h2table.

Abstract

Table QA

Explore similar work

H2Table: Hierarchical Hypergraph-Enhanced Large Language Models for Complex Table Reasoning

Orthogonal Hierarchical Decomposition for Structure-Aware Table Understanding with Large Language Models

DeepTable: Structural Attention Biases and Tree Path Encoding for Hierarchical Table Understanding