Encoder-Free Knowledge-Graph Reasoning with LLMs via Hyperdimensional Path Retrieval

Recent progress in large language models (LLMs) has made knowledge-grounded reasoning increasingly practical, yet KG-based QA systems often pay a steep price in efficiency and transparency. In typical pipelines, symbolic paths are scored by neural encoders or repeatedly re-ranked by multiple LLM calls, which inflates latency and GPU cost and makes the decision process hard to audit. We introduce PathHD, an encoder-free framework for knowledge-graph reasoning that couples hyperdimensional computing (HDC) with a single LLM call per query. Given a query, PathHD represents relation paths as block-diagonal GHRR hypervectors, retrieves candidate paths using a calibrated blockwise cosine similarity with Top-K pruning, and then performs a one-shot LLM adjudication that outputs the final answer together with supporting, citeable paths. The design is enabled by three technical components: (i) an order-sensitive, non-commutative binding operator for composing multi-hop paths, (ii) a robust similarity calibration that stabilizes hypervector retrieval, and (iii) an adjudication stage that preserves interpretability while avoiding per-path LLM scoring. Across WebQSP, CWQ, and GrailQA, PathHD matches or improves Hits@1 compared to strong neural baselines while using only one LLM call per query, reduces end-to-end latency by $40-60%$, and lowers GPU memory by $3-5\times$ due to encoder-free retrieval. Overall, the results suggest that carefully engineered HDC path representations can serve as an effective substrate for efficient and faithful KG-LLM reasoning, achieving a strong accuracy-efficiency-interpretability trade-off.

💡 Research Summary

PathHD tackles two persistent bottlenecks in knowledge‑graph question answering (KG‑QA) that rely on large language models (LLMs): (1) a mismatch between the query’s relational intent and the way candidate paths are encoded, and (2) the high latency and token cost of scoring each candidate path with a separate LLM call. The authors propose an encoder‑free framework that leverages hyperdimensional computing (HDC) to represent relation paths as fixed‑size hypervectors and to retrieve the most promising paths with a single similarity computation, followed by a one‑shot LLM adjudication.

The core representation is a Generalized Holographic Reduced Representation (GHRR) hypervector. Each atomic relation r is assigned a d‑dimensional vector composed of D blocks, each block being an m × m unitary matrix (often a diagonal matrix of complex phases). A path z = (r₁,…,rℓ) is encoded by left‑to‑right block‑wise matrix multiplication (⊛), a non‑commutative binding operation that preserves order and direction. Because the blocks are unitary and randomly sampled, the resulting hypervectors are nearly orthogonal; the authors prove a Bernstein‑type tail bound (Proposition 1) showing that the cosine similarity between a query path and any unrelated distractor decays exponentially with dimensionality.

A query can be encoded in two ways. The primary “plan‑based” method selects a relation schema (a sequence of relations) that matches the question and encodes it with the same GHRR binding. An alternative “text‑projection” method embeds the natural‑language question with a sentence encoder (e.g., SBERT), projects it into the HDC space via a fixed random linear map, and normalizes it. In all main experiments the plan‑based encoding is used.

Candidate paths are generated symbolically from a schema graph or via a constrained breadth‑first search on the KG, yielding a set Z of size N. Each candidate is bound into a hypervector v_z, and the query hypervector v_q is compared to all candidates using a block‑wise cosine similarity:

sim(v_q, v_z) = (1/D) Σ_j Re⟨v_q^j, v_z^j⟩ / (‖v_q^j‖‖v_z^j‖).

Optionally a calibrated score s(z) = sim(v_q, v_z) + α·IDF(z) – β·λ·|z| is applied, where IDF down‑weights frequent schemas and λ penalizes long paths. All scores are computed in parallel with O(N·d) time and linear memory, eliminating any learned encoder parameters.

After scoring, the top‑K paths (typically 10–20) are linearized into concise natural‑language statements and fed to an LLM in a single prompt that also contains the original question. The prompt asks the model to output (i) the final answer, (ii) the index(es) of supporting path(s), and (iii) a short rationale. This “one‑shot adjudication” forces the LLM to ground its answer on the retrieved evidence, reduces token usage dramatically, and yields explicit citations for interpretability.

Empirical evaluation on three standard KG‑QA benchmarks—WebQSP, ComplexWebQuestions (CWQ), and GrailQA—shows that PathHD matches or slightly exceeds state‑of‑the‑art neural baselines (e.g., StructGPT, KG‑Agent) in Hits@1 and F1. More importantly, because only one LLM call is made, end‑to‑end latency drops by 40–60 % and GPU memory consumption falls by a factor of 3–5 compared with encoder‑based pipelines. Ablation studies confirm that (a) the non‑commutative GHRR binding outperforms commutative alternatives such as element‑wise multiplication or circular convolution, (b) the IDF/length calibration improves the precision‑recall trade‑off, and (c) varying K reveals a smooth accuracy‑efficiency curve.

The paper’s contributions are threefold: (1) a fast, order‑aware hyperdimensional retriever that requires no learned parameters, (2) an efficient one‑shot reasoning stage that decouples retrieval from generation while preserving interpretability, and (3) extensive analysis demonstrating that carefully engineered HDC representations can serve as a practical substrate for KG‑LLM integration. The authors suggest future directions including dynamic schema generation, entity‑level binding, and multimodal KG extensions, positioning PathHD as a promising blueprint for scalable, transparent, and cost‑effective knowledge‑grounded AI.