Neural-Symbolic Reasoning over Knowledge Graphs: A Survey from a Query Perspective

In plain words

A knowledge graph stores facts as triples, such as "Canberra is located in Australia". Asking it questions is easy when the answer is one fact away, and hard when the answer needs several steps or a logical condition such as "a country that is not X and borders Y". Two families of tools exist. Symbolic tools follow explicit rules and are precise, but they break on missing or noisy facts. Neural tools learn patterns from vectors and cope with gaps, but they are hard to explain. Neural-symbolic tools mix the two.

This survey sorts the literature by the kind of question being asked: one missing fact, a logical combination of conditions, a question in English, or a conversation. For each kind it groups the methods into symbolic, neural and mixed families, and it ends with how large language models can be combined with knowledge graphs. It is a reading map, not a benchmark. It reports no new experiments and no numbers to compare methods against.

TL;DR

• A taxonomy of knowledge graph reasoning by query type: single-hop, complex logical, natural-language single-turn and multi-turn, and LLM combinations §1 §2.8.
• For single-hop queries it names symbolic rules, rule mining, path methods, embeddings, and neural-symbolic variants of each §3.1 §3.2.
• For complex logical queries it separates tree-form and EFO-1 query families and describes embedding-space and search-based solvers §4.1 §4.2 §4.3.
• It proposes no method, so the card contains no hyperparameters or results. Use the cited methods' own papers for numbers.

Problem

• The survey addresses knowledge graph reasoning: answering queries by traversing and reasoning over a graph §2.1. It frames the difficulty as incomplete and noisy graphs, which hurt symbolic reasoning, and the lack of interpretability in neural reasoning §1.
• It notes that LLMs hallucinate and lack structured knowledge, and that the combination with knowledge graphs is under-explored §1 §6.
• Scope limit: it covers reasoning on a single knowledge graph and leaves multi-modal and cross-lingual graphs to future work §7.2.

Method

This is a survey, so the "method" section below restates the taxonomy and the mechanism each family relies on. Nothing here is the authors' own algorithm.

Definitions. A knowledge graph is a triple set over entities V, relations and triples. Single-hop completion predicts the tail given head and relation, the head given tail and relation, or the relation given head and tail §2.1 §3 intro.

Single-hop, symbolic §3.1.

• Hard rules. Rule-based expert systems apply rules until no new fact follows (forward chaining), or match a goal backwards (backward chaining). Prolog, Datalog and OWL are cited as symbolic tools §3.1.1.
• Soft rules. Markov logic networks give each first-order formula a weight; the authors note that infinite weight recovers hard rules §3.1.2.
• TensorLog. Each entity is a one-hot vector and each relation a matrix; a rule body becomes a product of matrices, and the output vector scores answers §3.1.2.
• Path methods. The Path Ranking Algorithm uses random-walk path features and logistic regression §3.1.3. ProPPR adds embedding similarity to edge traversal §3.1.3.
• Rule mining. AMIE and AMIE+ grow and prune Horn rules with support and confidence; RLvLR and RuLES use embeddings to prune or score rules §3.1.4.

Single-hop, neural-symbolic §3.2.

• Embeddings. Entities and relations become vectors and a score function ranks triples. The survey groups TransE, DistMult, ComplEx, RotatE, TransH, TransR, RESCAL, QuatE and HolE, plus region-based (boxes, spheres) and Gaussian embeddings §3.2.1.
• Neural rule learning. Neural LP learns a chain of relation combinations with an RNN, derived from TensorLog's ordering of operations. RNNLogic treats rules as latent variables and trains them with EM §3.2.2.
• Neural path methods. PathCon combines relational context with path attention. DeepPath frames path search as a Markov decision process solved with reinforcement learning §3.2.3.
• Neural subgraph rules. GraIL extracts the subgraph around a candidate triple, labels nodes by distance to the target pair, and applies a relation- aware GNN §3.2.4. Companion card: GraIL.

Complex logical queries §4.

Definitions are numbered in order of appearance in the source. See the pitfall below. Preliminary Definitions 1 and 2 are the graph and reasoning definitions §2.1.

• EFO formula (Definition 3 §4.1): atomic formulas and their negations, closed under conjunction, disjunction and existential quantification. Negation applies only to atoms.
• EFO-1 query (Definition 4 §4.1): a disjunction of conjunctive queries over one free variable y, with existentially quantified variables x_1 to x_k.
• Conjunctive query (Definition 5 §4.1): an existential conjunction of atoms or negated atoms.
• Tree-form query (Definition 6 §4.1): built recursively from a projection of an entity, complement, intersection, union and projection. Set operations map to logical connectives.
• The two families overlap but neither contains the other §4.1.

Neural solvers for tree-form queries (§4.2.1) embed each term and implement projection, intersection, union and complement as differentiable operations, then search for nearest answers. GQE is the first example. Query2Box uses boxes, where intersection is a box intersection and union needs a DNF rewrite. NewLook re-learns the box at each projection and adds set difference. Other spaces named are cones, Beta and GammaE distributions, fuzzy vectors and Wasserstein-based embeddings §4.2.1.

Neural solvers for EFO-1 queries (§4.2.2) treat the query as a graph: LMPNN passes logical constraints as messages, and transformer variants operate on the query graph or on messages §4.2.2.

Neural-symbolic solvers (§4.3) treat answering as a search for variable assignments that satisfy the query. A link predictor turns each triple into a fuzzy truth value in [0, 1]. Beam search covers acyclic query graphs (CQD); backtracking search covers acyclic queries (QTO); FIT covers cyclic and multi-edge graphs. EMQL stores candidate sets in a count-min sketch. CQD-CO relaxes the search into embedding space for gradient-based optimisation; CQD-A adapts the embeddings from training feedback; GNN-QE learns the link predictor from search feedback §4.3.

# Forward chaining over a rule base  [§3.1.1]
# Input:  facts (set of triples), rules (list of Horn rules)
# Output: facts closed under the rules

def forward_chain(facts, rules):
    # 1. Repeat until a full pass adds no new fact  [§3.1.1]
    changed = True
    while changed:
        changed = False
        # 2. Try each rule against the current facts  [§3.1.1]
        for rule in rules:
            for new_fact in apply(rule, facts):
                if new_fact not in facts:
                    facts.add(new_fact)
                    changed = True
    return facts

Natural-language queries §5.

• Single-turn (§5.1). PullNet retrieves a subgraph around candidate answers. KV-Mem and EmbedKGQA embed the question and rank answers by similarity. PrefNet re-ranks candidates. RnG-KBQA ranks candidate query graphs and generates the true one, iterating between the two. BINET trains question answering and completion jointly. RL agents walk the graph to find answer paths §5.1.
• Multi-turn (§5.2). ConQuer treats user reformulations as implicit feedback for RL agents on the graph. PRALINE ranks graph paths with contrastive learning, marking paths that reach the correct answer as positives. CornNet adds language-model reformulations. Other work uses reformulation-based rewriting, logical-form generation, and question rewriting in the style of CANARD §5.2.

LLMs and knowledge graphs §6.

• Knowledge graphs help LLMs (§6.1). QA-GNN scores knowledge-graph nodes by relevance to the question with a pretrained LM, joins the question and subgraph into one graph, and runs a GNN over it. GreaseLM fuses LM and GNN layers. Retrieval-augmented generation is described with KG-GPT (decompose a question into triple-sized sub-sentences, retrieve evidence subgraphs, then infer), REPLUG (a black-box LM with plug-in retrieval and an ensemble over retrieved documents, plus a REPLUG LSR retriever training variant), and GraphRAG (an entity graph with community summaries). Companion cards: QA-GNN, GreaseLM §6.1.
• LLMs help knowledge-graph reasoning (§6.2). The LLM acts as an agent that walks the graph from topic entities, scoring neighbours and moving on when the current node lacks the answer (Think-on-Graph) §6.2.
• Mutual benefit (§6.3). KEPLER trains one encoder with a knowledge-graph embedding loss and a masked-language-modelling loss. JAKET uses a graph attention network over text-initialised entity and relation embeddings, then feeds them to the language model §6.3.

Hyperparameters

Results

Author-reported. The survey reports no experiments and no numeric results §1–§7. Its comparative statements are qualitative. QA-GNN is said to improve over earlier systems on CommonsenseQA and OpenBookQA, with no numbers in the survey §6.1. Consult the cited method papers for their own results.

Paper vs code

No official code.

The survey has no code link in its LaTeX source, its abstract or its arXiv metadata. Searches on GitHub for "neural-symbolic knowledge graph reasoning survey" and "neural-symbolic query knowledge graph" returned no repositories.

Pitfalls

• Survey, not a method. Nothing here can be implemented as an algorithm from this paper alone. Each method family points to the original paper.
• Compiled version. main.tex includes sections §1 to §7 from the files 001intro, 002preliminary, 003single, 005complex, 004language, 006other and 008conclusion. The LLM section in the source is 006other, not 007llm. 007llm is an older draft that main.tex does not include. The appendix 009appendix is commented out and not part of the compiled paper. Claims that appear only in those files are not part of this card.
• Notation clash. The preliminary defines E as the relations, V as the entities and R as the triples §2.1. Section §4.1 uses E for entities in the tree-form definition, and R for relations there. The paper does not reconcile this.
• Duplicate definition. Definitions 1 and 2 in §2.1 are identical text.
• Definition numbers are inferred. I numbered the logic definitions 3 to 6 by their order in the source (they are not labelled in the source). Check them against the compiled PDF before citing them by number.
• Informal reasoning types. Deductive, inductive and abductive reasoning are described with examples but no formal definitions §2.5 to §2.7. The examples are illustrations and are not drawn from data.
• Figures. Several figures are credited to third parties in their captions ("Sourced from" other papers), and the LLM overview figure cites the Markov logic network paper as its source. None is reproduced here, and figures are not supported on this site.
• Unquantified claims. The survey often says a method "achieves improvements" or "state of the art" without a table. Treat these as unverified until the cited paper is checked.
• LLM section is thin. The LLM part describes three ways to combine the two and cites one example per way §6. It does not compare them.

Lineage

• Builds on: earlier surveys on logical query answering are cited for the formal definitions §4 §4.1. The source gives no arXiv id for them, so they are not linked.
• Compared against: none. It is a survey and reports no comparisons.
• Superseded by: not known from this wiki.