Hierarchical Orthogonal Tree (HO-Tree)

• Hierarchical Orthogonal Tree (HO-Tree) is a data structure that recursively decomposes complex, multidimensional data into orthogonal hierarchies, clearly separating vertical and horizontal attributes.
• Its construction algorithms, such as HAPOD and binary emulation, enable efficient local SVD computations and dynamic spatial partitioning with controlled error bounds.
• HO-Tree is applied in model reduction, spatial analysis, and table understanding, offering scalable performance and rigorous error guarantees for challenging data tasks.

The Hierarchical Orthogonal Tree (HO-Tree) is a class of tree-based hierarchical data structures and computational frameworks that decompose complex, multidimensional, and often semi-structured data into interpretable orthogonal hierarchies. HO-Tree models are utilized for diverse tasks such as approximate linear algebraic decomposition, hierarchical table understanding for LLMs, multidimensional spatial modeling, and interpretable question answering over tabular data. Despite variations in technical implementation, all HO-Tree frameworks encode two key principles: recursive, axis-aligned (orthogonal) subdivision, and the separation of hierarchical ("vertical") structure from orthogonal ("horizontal") or attribute coupling.

1. Formal Structure and Mathematical Definition

HO-Tree architectures appear in at least three principal forms:

• Hierarchical Orthogonal Trees for Approximate Decomposition: In the context of model reduction and data compression, an HO-Tree is a rooted acyclic tree $T=(\mathcal{N}_T, \mathrm{child}, \rho_T)$ combined with a distribution of data (e.g., vectors $S\subset V$ in a Hilbert space) to leaves, which enables recursive local computations, aggregation via orthogonalization (e.g., SVD/POD), and globally controlled approximation error (Himpe et al., 2016).
• Binary-Emulated $2^k$-trees: For spatial or pattern-structure modeling, an HO-Tree emulates a $2^k$-ary spatial decomposition (e.g., quadtree/octree) using a strictly binary tree of depth $k\cdot r$, where $k$ is the dimension and $r$ the precision level. Each recursive step alternates axes cyclically, resulting in a fully orthogonal, regular partitioning of $[0,1)^k$ (Guye, 2016).
• HO-Trees for Tabular and Semi-Structured Table Modeling: In table QA and LLM table understanding, an HO-Tree consists of two distinct rooted trees—a meta/header hierarchy (MTree) and an orthogonal cell-body tree (BTree)—linked by an explicit pointer $\rho$ from leaf headers to corresponding value levels, providing faithful structure-preserving representation of complex, non-canonical tabular data (Cao et al., 2 Feb 2026, Tang et al., 25 Aug 2025).

A unifying abstraction is to define the HO-Tree as a tuple $(N, E^v, E^h)$, where $E^v$ encodes hierarchical ("vertical") containment and $E^h$ encodes orthogonal ("horizontal" or attribute-driven) groupings, with additional application-specific node annotations.

2. Construction Algorithms

HO-Tree construction is governed by recursive decomposition rules dictated by the problem domain:

• Hierarchical Approximate POD (HAPOD): Data vectors ("snapshots") are partitioned to leaf nodes; each node computes a local truncated SVD with prescribed tolerance. At internal nodes, modes from children are concatenated and the process is repeated recursively, propagating orthogonal basis vectors upwards. Only vertical communication along tree edges is required; the topology can be balanced, star-shaped, or chain-like for different parallelization and memory requirements (Himpe et al., 2016).
• Binary Emulation of $2^k$-trees: Insertion of a data point at precision $r$ requires $O(k r)$ operations, walking from root to leaf with axis cycling. Inductive extensions permit dynamic bounding box expansion and merging. Transformations (affine, homographic) are executed by mapping corresponding cubes via parallel recursive traversals (Guye, 2016).
• Table Structure Induction (OHD/HO-Tree): Structure-aware induction is elaborated via the Orthogonal Tree Induction (OTI) algorithm, which builds independent row and column trees by minimizing a spatial–semantic objective. The spatial component enforces grid locality/containment; the semantic component, typically computed by an LLM, ensures attributes are grouped only if logically subsumed. Data anchoring attaches terminal value cells to header skeletons. Complexity is $O(|H|^2 + |D|\,|H|)$ but practically linear for real-world tables (Cao et al., 2 Feb 2026, Tang et al., 25 Aug 2025).

3. Error Guarantees and Theoretical Properties

For applications in model reduction, HO-Tree frameworks provide explicit global error control. Let $\varepsilon(\alpha)$ denote the local SVD truncation error at node $\alpha$. For the subtree rooted at $\alpha$, the mean-square error obeys

$$\sum_{s \in S_{\alpha}} \|s - P_\alpha(s)\|^2 \leq \sum_{\gamma \in \mathcal{N}_T(\alpha)} \varepsilon(\gamma)^2,$$

with $P_\alpha$ the orthogonal projection onto the current node's basis (Himpe et al., 2016). This enables precise selection of local tolerances to match a desired global mean-square error, a property critical for distributed and memory-bounded computation.

In tabular modeling, the HO-Tree's construction guarantees that any table with hierarchical headers and orthogonal subtables (layouts L1–L4) admits a unique, lossless decomposition. The hierarchy constraint enforces nested header containment; the orthogonality constraint ensures all value groupings correspond to true table rows/columns. The mapping $\rho$ maintains data alignment under complex merging and nesting (Tang et al., 25 Aug 2025).

4. Key Operations and Algorithmic Complexity

Commonly supported operations and their complexities—application-specific—include:

Operation	Complexity	Context
Insertion	$O(kr)$ per point	$2^k$-tree (Guye, 2016)
Local SVD/POD	$O(d\,|S_\alpha|^2)$ or better	HAPOD (Himpe et al., 2016)
Boolean set ops	$O(\min(|S|,|T|))$	$2^k$-tree
Affine transform	$O(|S|\cdot|P|)$	$2^k$-tree
Table induction (OTI)	$O(|H|^2 + |D|\,|H|)$	OHD/QA (Cao et al., 2 Feb 2026)
Table QA tree ops	$O(|\mathrm{match}|)$ per op	ST-Raptor (Tang et al., 25 Aug 2025)

In all contexts, the recursive and orthogonal structure yields nearly linear or subquadratic performance, depending on dimension, sparsity, and the decay of singular values or header nesting complexity. For distributed matrix decomposition, hierarchical merging, and treewise SVD allow efficient parallelization with very limited communication and memory overhead.

5. Applications: Model Reduction, Spatial Analysis, and Table QA

• HAPOD Model Reduction: The HO-Tree enables scalable, parallelizable POD approximation for large-scale scientific computing problems, supporting arbitrary snapshot distributions and tree topologies. It provides rigorous error bounds and adapts naturally to memory and compute constraints encountered in distributed systems (Himpe et al., 2016).
• Spatial/Pattern Recognition: The $2^k$-tree HO-Tree supports dynamic modeling, search, Boolean set operations, affine transformations, and fully hierarchical attribute extraction (moments, Eigen-trees) for multidimensional data—enabling applications in image analysis, robotics, CAD, and indexing (Guye, 2016).
• Structure-Aware Table Understanding: In both Orthogonal Hierarchical Decomposition (OHD) (Cao et al., 2 Feb 2026) and ST-Raptor (Tang et al., 25 Aug 2025), the HO-Tree mediates a lossless, interpretable structured representation of complex tables, supporting dual-pathway semantic association and modular pipelines of tree operations (children, ancestors, value cross, condition, calculation, comparison, etc.). This decouples layout parsing from semantic reasoning, allowing flexible and robust LLM-driven question answering.

6. Dual-Tree and Orthogonality Principles

A defining property of HO-Tree applications in table and multidimensional data modeling is explicit orthogonalization: one tree axis encodes hierarchical structure (e.g., nested headers, recursive spatial partition), and the other encodes orthogonal (cross-attribute or orthogonal direction) groupings. For tabular data, this results in separate row and column trees, each inducing distinct hierarchical paths to every cell; dual-path reconstruction or association protocols then combine both perspectives, allowing for complete semantic context assembly (Cao et al., 2 Feb 2026). In high-dimensional geometry, strict alternation/cycling of split axes ensures full orthogonality and isotropic treatment of all spatial dimensions (Guye, 2016).

7. Role of Machine Learning, LLMs, and Future Directions

Recent developments leverage HO-Tree structure as an intermediate representation for LLMs, both for parsing (e.g., header subsumption via LLM semantic predicates) and for post-processing (arbitration between table serializations and answer formatting) (Cao et al., 2 Feb 2026, Tang et al., 25 Aug 2025). In the ST-Raptor pipeline, atomic tree operations serve as primitives for programmatic QA pipelines, with both forward and backward verification for reliability.

A plausible implication is further generalization of HO-Tree frameworks to arbitrary semi-structured or graph-based data, as well as tighter integration with neural architectures that benefit from explicit, interpretable hierarchical and orthogonal structure.

---

Selected References:

• Hierarchical Approximate Proper Orthogonal Decomposition (Himpe et al., 2016)
• Hierarchical Modeling of Multidimensional Data in Regularly Decomposed Spaces: Main Principles (Guye, 2016)
• Orthogonal Hierarchical Decomposition for Structure-Aware Table Understanding with LLMs (Cao et al., 2 Feb 2026)
• ST-Raptor: LLM-Powered Semi-Structured Table Question Answering (Tang et al., 25 Aug 2025)