Neural Structural Reasoner: A Brain-inspired Architecture for Reasoning over Structured Knowledge

Conference: NeurIPS2026 (Accepted according to the supplied list)
arXiv: 2609.36620
Area: Graph Learning
Keywords: knowledge graph reasoning, structured connectivity, relation composition, Hebbian learning, interpretable paths

TL;DR

NSR binds entities, relations, and relation chains to readable network units and connections, performing link prediction through relation-association retrieval and explicit graph traversal; it achieves an MRR of 0.8142 on Nations, but its advantages are dataset-dependent, and the efficiency of its accelerated static implementation should not be equated with that of its online brain-inspired dynamics.

Background & Motivation

Knowledge graph link prediction asks which tail entity best fits a given head entity and relation. The challenge extends beyond entity similarity to reusable relational operations: traversing parent–child links backward, discovering relations that frequently reach the same object, or composing two relations into a more abstract one. Embedding methods such as ConvE and RotatE score continuous representations without directly exposing the graph paths supporting an answer. Rule learners and path-based systems expose chains, but must handle combinatorial search and insufficient evidence in incomplete graphs.

This paper instead places relational structure directly in network connectivity, rather than compressing it into entity vectors and expecting a model to reconstruct it. Its biological inspirations are stable entity representations, hippocampal–entorhinal path integration, and hierarchical relational organization. However, its input is an already symbolized, discrete knowledge graph—not neural recordings or a model that recognizes entities from images or text. The objective is to demonstrate an interpretable computational approach to structural reasoning, not to establish that these mechanisms implement human reasoning in the brain.

Core idea: store observed triples as connections between entity–relation binding units, store reusable relation equivalences and compositions as associative weights, and let queries produce inspectable candidate paths and ranking scores through those connections.

Method

Overall Architecture

The inputs are a training knowledge graph and a query of the form (h, r, ?); the outputs are a tail-entity ranking and supporting grounded paths. NSR contains an Entity Layer L_E, a Relational Reasoning Layer L_Z, a Relations Layer L_R, and a Relation Composition Layer L_C. Their physical connectivity forms the bidirectional hierarchy L_E ↔ L_Z ↔ L_R ↔ L_C, not a feed-forward pipeline that processes each of four layers once in sequence.

The Entity Layer supplies stable identities, while the Relational Reasoning Layer moves between entities under particular relations. The Relations Layer supplies alternative relations, and the Relation Composition Layer supplies ordered chains. During learning, co-activation or closed-loop evidence from encoded triples updates associative connectivity. During inference, the query retrieves relations and chains separately, invokes the same entity–relation binding mechanism for graph traversal, and aggregates support at each tail entity.

The diagram groups the Entity Layer and Relational Reasoning Layer under “Structured Binding.” Bidirectional solid edges indicate structural coupling; dotted edges distinguish learning feedback from query-time traversal calls. Relation Association and Relation Composition therefore are not two inference stages that must be executed serially.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    T["Training triples"] --> A["Structured Binding<br/>Entity and Relational Reasoning Layers"]
    A <-->|Structural coupling| B["Relation Association<br/>Relations Layer"]
    B <-->|Structural coupling| C["Relation Composition<br/>Composition Layer"]
    A -.->|Learning: shared-endpoint co-occurrence| B
    A -.->|Learning: ordered-chain closure| C
    Q["Query relation and head entity"] --> B
    Q --> C
    B -.->|Inference: alternative-relation traversal| A
    C -.->|Inference: ordered-chain traversal| A
    A -->|Retain grounded paths| D["Path-Support Aggregation"]
    D --> O["Tail ranking and traces"]

Key Designs

1. Structured Binding: store relations in connectivity rather than similarity alone

The Entity Layer assigns a unit to each entity. The Relations Layer provides forward and inverse units for each relation, doubling the number of original relation types. The Relational Reasoning Layer can allocate a binding unit for every entity–extended-relation pair. This unit represents a transition starting from that entity under that relation, rather than an arbitrarily rotatable dense entity embedding.

At initialization, each entity unit is bidirectionally connected to its binding units with fixed weight 1. For a training triple (h, r, t), the head's forward binding unit is bidirectionally connected to the tail's inverse binding unit; the two endpoints are also connected to the forward and inverse relation units, respectively. These encoding connections are set to 1, while other plastic weights start at 0. An inverse relation initially serves as a traversal operation; it does not imply that another semantic relation has already been identified as equivalent to it.

A query activates the head entity and relation together. The entity input specifies where the transition starts, while the relation input specifies which edge type to follow. Gating requires these inputs to converge, preventing an entity or relation alone from triggering unrelated transitions. Recurrent connectivity within the Relational Reasoning Layer then propagates activation to the matching tail-side binding unit, which reads out the tail entity. Gating also controls projections to the Relations and Composition Layers during learning, giving co-activation a concrete structural meaning.

Single-step reasoning can thus be reconstructed as an entity identity, a relation condition, an encoded edge, and a tail entity. This is not direct lookup of the missing query triple: the test answer is absent from the training encoding. The model must retrieve alternative relations or composed chains and reach candidate tails through other observed edges.

2. Relation Association: learn reusable relational operations from shared-endpoint evidence

If two relations connect the same head to the same tail, their tail-side binding units reinforce one another through the shared entity unit, causing the associated relation units to co-activate. A symmetric Oja-style update with decay accumulates these associations. The relation-layer update below captures the mechanism: the product of relation activations strengthens a connection, while squared activity terms decay its existing weight.

\[ \Delta w_{ij}^{RR}=\delta_{RR}(r_i r_j)-\mu_{RR}(r_i^2+r_j^2)w_{ij}^{RR}. \]

The same mechanism can associate forward relations, inverse relations, and a relation with its own inverse, supporting the discovery of associations, inversions, and symmetry. “Equivalence” is the paper's term for alternative-relation retrieval: shared endpoints support a statistical association, not a proof that two relations are logically equivalent for every entity, and not a causal conclusion.

At query time, the original relation is activated and the Relations Layer is updated once. Alternative relations whose activations exceed T_thresh are retained, and each activation becomes a path-support score. Holding these relations and the original head active then produces one-hop traversals through the encoded graph and a first set of candidate tails. The threshold controls retrieval scope; it does not turn an association into a strict logical rule.

3. Relation Composition: associate an abstract relation with ordered-chain closure evidence

Shared-endpoint one-hop associations cannot answer queries requiring several edges. NSR therefore checks whether an ordered two-hop chain and a direct relation connect the same head and tail. Starting from the tail of an observed first hop, it explores a second hop and checks whether the inverse of a target relation can return to the original head. Because triples are encoded bidirectionally, this closure corresponds to an observed target relation with the same endpoints. Immediate traversal of the first edge's inverse is excluded to avoid treating simple backtracking as meaningful composition.

Sequence-selective units in the Composition Layer represent relation order rather than merely recording simultaneous occurrence. The appendix describes direct input converging with delayed input through an intermediate unit, making a detector responsive to a particular activation order. Once a chain and target relation are jointly supported, an Oja-style associative update strengthens their connection. The resulting structure can be reused across entities rather than learned anew as an entity-specific rule for every query.

Static-graph experiments use a cheaper offline implementation. An adjacency matrix is constructed for each forward or inverse relation, and multiplying two such matrices counts grounded instances of an ordered two-hop chain. The diagonal is set to zero. The inner product between the target-relation adjacency matrix and the chain-count matrix, divided by the total chain count, gives an empirical association weight.

\[ S_{ij}=A_{\tilde r_i}A_{\tilde r_j},\qquad w_{k-ij}^{CC}=\frac{\langle A_{r_k},S_{ij}\rangle_F}{\sum_{h\neq t}S_{ij}[h,t]}. \]

Matrix multiplication retains multiple groundings through different intermediate entities rather than reducing reachability to a Boolean value. Both numerator and denominator use the chain counts with the diagonal removed. tau_s requires sufficient chain evidence, while tau_c requires sufficient association weight. These are inference readout gates, not operations that remove training facts.

The paper calls this empirical mean an exact closed-form result of online updating. However, the derivation uses a running-mean learning rate, whereas the main-text Oja equation includes separate strengthening and decay terms. This note does not treat equivalence between arbitrary Oja settings and the statistical expression as established. The online mechanism, the appendix's particular averaging interpretation, and the actual accelerated static evaluation should remain distinct.

4. Path-Support Aggregation: retain grounded paths before combining evidence by tail

Composition retrieval is separate from one-hop association retrieval. After resetting the network, the query relation propagates activity to the Composition Layer, which retains the most active TopK chains. Each selected chain activates relation units in order, with entities reached at the current hop becoming starting states for the next. Chains are executed separately, and each chain can have multiple groundings. Parallel candidate reasoning therefore does not mean advancing every chain within one undifferentiated state trajectory.

Each one-hop path inherits its alternative relation's activation score; each compositional path inherits its composition unit's score. Paths through different intermediate entities remain distinct even when they instantiate the same relation chain. For all paths reaching a tail entity, the model uses either the maximum support or the sum of supports, choosing the aggregation mode on validation data.

\[ \mathrm{Score}_a(t)= \begin{cases} \max_{p\in\mathcal P(t)}s(p), & a=\mathrm{max},\\ \sum_{p\in\mathcal P(t)}s(p), & a=\mathrm{sum}. \end{cases} \]

Maximum aggregation trusts the strongest evidence and can be dominated by a high-scoring spurious path. Sum aggregation exploits multiple groundings but can double-count correlated support. These scores are not calibrated probabilities, and sums can be much larger than 1. Interpretability means that each score contribution can be traced to an executed graph path, not that the score guarantees factual truth or logical validity.

A Worked Example

The appendix presents the Kinship query (person80, term16, ?). The target person25 has no direct evidence and must receive support from retrieved associations or compositions; person32 is a competing entity. Maximum aggregation assigns 0.662 to the competitor and 0.641 to the target, so the target ranks lower.

Retaining groundings through different intermediate entities gives the target 132 paths with total support 46.23, versus 3 paths totaling 1.55 for the competitor. Sum aggregation makes the target the unique top-ranked answer. This example changes evidence aggregation, not the encoding of test facts, and 46.23 is not a probability. Whether sum aggregation should be used more broadly still requires validation rather than a decision based on one successful example.

Loss & Training

NSR's main mechanism is not an end-to-end back-propagation objective for link prediction. It first encodes training triples, then learns associations through co-activation and compositional closure. The accelerated static variant replaces iterative Oja updates with one-pass counting. Its delta_theta is an effective learning rate for the simplified implementation, not a complete description of the full dynamical model's parameters.

The six public benchmarks use their supplied train/validation/test splits. The training graph supplies encoded connectivity, while thresholds and aggregation are chosen on validation data. The constructed Kinship1990_EXTENDED dataset uses a 70%/10%/20% split, with all base genealogical edges required for consistency retained in training and test triples drawn mainly from extended composition relations. This is a controlled test of compositional reuse, not inductive generalization to unseen entities or entirely unseen families.

The appendix lists T_thresh=0.22, tau_s=23, tau_c=0.20, and delta_theta=0.52 for Nations. Countries S3 sets the relation-association threshold to infinity, emphasizing compositional paths rather than relation-similarity retrieval. The paper states that Optuna selects hyperparameters, but lists a tau_c search range of 0.05–0.5 while reporting 1.00 for Countries, without explaining that exception.

Key Experimental Results

Main Results

The main tables use filtered tail link prediction. MRR averages the reciprocal rank of the correct tail, while Hits@1/3 measure the proportion of correct entities within the top 1/3 positions. Hits values below are percentages. The selected baselines illustrate the main comparisons without presenting NSR as the best method on every dataset.

Dataset	Method	MRR	Hits@1 (%)	Hits@3 (%)	Main-table training time
Nations	NSR	0.8142	71.64	88.16	3 s
Nations	AMIE	0.8559	77.11	92.54	0.6 h
Kinship	NSR	0.6515	54.21	70.67	11 s
Kinship	ConvE	0.7927	68.11	88.45	64 s
YAGO3-10	NSR	0.5893	52.80	64.32	0.3 h
YAGO3-10	ConvE	0.6365	59.03	71.28	10.3 h
FB15k-237	NSR	0.3649	28.45	39.74	0.6 h
FB15k-237	NBFNet	0.5114	41.64	55.95	10.4 h

Local evaluations share splits and the filtered-tail protocol, but some AnyBURL and NCRL values come from prior papers or official releases, and NBFNet timings use official training profiles. Differences in hardware, stopping criteria, and implementation make these timings indicative rather than grounds for strict multiplicative speedup claims.

Appendix Table 11 reports NSR training/full-test-set inference times of 1142 s/107 s on YAGO3-10 and 2019 s/55 s on FB15k-237. The main table expresses training times approximately in hours. These results do not imply that inference is always faster: NSR takes 3.3 s/32 s on WN18RR, while NBFNet's full-test-set inference takes 12 s.

On additional composition tests, NSR obtains MRR 1.0000 and Hits@1 100.00% on Countries S3. On Kinship1990_EXTENDED, its MRR is 0.9533 and Hits@1 is 94.33%, but its Hits@3 of 96.47% is below DistMult's 97.75%. These results support an advantage on particular compositional structures, not a universal replacement for embeddings.

Ablation Study

The following results use the full dynamical model, not only the static statistical variant. Each configuration uses five paired seeds and reports mean MRR with population standard deviation. Parentheses preserve the paired differences from the original Table 12; they should not be replaced by subtraction of the displayed rounded means.

Config	Nations MRR	Kinship MRR	Kinship1990_EXTENDED MRR
Full model	0.81 ± 0.03	0.65 ± 0.01	0.95 ± 0.00
w/o inverse encoding	0.66 ± 0.03 (−0.15)	0.05 ± 0.00 (−0.60)	0.10 ± 0.00 (−0.85)
w/o relation-association retrieval	0.61 ± 0.01 (−0.20)	0.42 ± 0.00 (−0.24)	0.82 ± 0.00 (−0.12)
w/o compositional inference	0.79 ± 0.03 (−0.03)	0.48 ± 0.01 (−0.17)	0.46 ± 0.00 (−0.48)
w/o Hebbian learning	0.36 ± 0.01 (−0.45)	0.05 ± 0.00 (−0.60)	0.02 ± 0.00 (−0.93)

Removing inverse encoding requires retraining from scratch. Removing association retrieval or compositional inference only disables a query-time branch and reuses the trained network. Removing Hebbian learning preserves triple encoding but leaves both associative weight systems at 0. These are different interventions, not four equivalent-size module removals.

Key Findings

• Removing compositional inference costs 0.48 MRR on the extended genealogy but only 0.03 on Nations, consistent with the datasets' different construction.
• Without Hebbian learning, candidate scores degenerate. Residual MRR can arise from random tie-breaking rather than meaningful latent reasoning.
• NSR's WN18RR MRR is 0.472, below AnyBURL's 0.5658 and NBFNet's 0.5976. Its Hits@1 of 0.463 leads only among entries that report that metric.
• Nations yields an association weight of 0.93 for exportbooks + releconomicaid → embassy. This is training-graph path support, not a causal law of diplomacy.

Highlights & Insights

• The computation supplies the explanation: traces identify an incorrectly retrieved relation or a wrong edge traversal, rather than showing only a final similarity heatmap. Inspecting units and paths does not require a separately trained explainer.
• Relation reuse is separated from entity traversal: the model first identifies chains that can substitute for a query relation, then executes them in the entity graph. Structured retrieval systems could adopt this approach, provided they retain source edges and path-deduplication information.
• Statistical acceleration has explicit conditions: static graphs permit batched counting, whereas sequential experience introduces ordering and learning-rate considerations. Reporting them separately is more precise than labeling both with one brain-inspired network training time.

Limitations & Future Work

• Entities and relations must already be symbolized. Temporal, hyper-relational, event-based graphs, and structures extracted from raw inputs remain untested. Larger-scale composition discovery requires sparse activation or approximate proposal mechanisms.
• Path evidence depends on training-graph completeness. Missing or contradictory facts and correlated paths can undermine association weights and sum aggregation. Future evaluations should control noise, missing edges, and path correlation.
• The relationship between online Oja updates and offline empirical means needs a stricter derivation and matched experiments. Existing ablations validate useful computational components, not biological realism.
• Dataset construction starts from two families with 24 people, yet the final specification lists 480 entities and 14 relations. Retention, replacement, and expansion of the original 12 relations plus sibling and five chain labels are not fully explained; a note cannot invent the missing generation procedure.
• Paired ablation differences do not always match subtraction of displayed means, potentially because of undisplayed precision. The main-text AMIE/Nations time of 0.6 h and appendix value of 2246 s also lack an explicit conversion convention. Their original values should be retained rather than silently reconciled.

Related Work & Insights

• vs ConvE / RotatE: these methods place compatibility in vector scores, whereas NSR executes alternative relations and compositions in explicit connectivity. NSR exposes readable traces, but does not lead on Kinship or some larger graphs.
• vs AMIE / AnyBURL / RNNLogic: all exploit rules or paths. NSR stores associations in network weights and interprets retrieval and traversal through dynamics. Its static adjacency statistics resemble traditional rule-support counting, so matched implementations are needed to isolate architectural contributions.
• vs NBFNet: NBFNet learns path aggregation over graphs, while NSR's intermediate states directly correspond to symbolic entities and relations. More direct interpretability does not guarantee better accuracy or lower inference cost.
• vs TEM / Vector–HaSH: NSR borrows path-integration and associative-memory ideas but extends them to typed discrete relation graphs. Its state trajectories are computational analogies, not new neural recordings or evidence establishing human cognitive mechanisms.

Rating

• Novelty: 4/5. Entity–relation binding and compositional associations form a unified traceable architecture, although the static variant's distinction from existing path statistics needs clarification.
• Experimental Thoroughness: 4/5. Diverse baselines and paired ablations offer broad coverage, but timing conventions, dataset construction, and online–offline equivalence remain unclear.
• Writing Quality: 4/5. Mechanisms and reasoning traces are understandable, while some algorithm directions, statistical derivations, and numerical presentations are inconsistent.
• Value: 4/5. Useful for studying inspectable knowledge graph reasoning, without supporting general logical guarantees or validation of brain mechanisms.