Paper deep dive
QORH: Learning Query-Specific Ordered Rule Hypergraphs for Inductive Knowledge Graph Link Prediction
Naixing Xu
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Knowledge graph link prediction involving unseen entities and relations requires learning transferable reasoning patterns from observed graph structure. Existing methods based on relation graphs primarily capture pairwise dependencies, limiting their ability to preserve the compositional semantics, relation ordering, and role information of complete path rules. To address this limitation, we propose QORH (Query-specific Ordered Rule Hypergraph), which jointly encodes rule heads and ordered rule bodies as hyperedges conditioned on the query relation, explicitly modeling joint dependencies among multiple relations. QORH performs learnable rule selection using statistical evidence, such as rule confidence and coverage, and enhances relation representations through role-aware hypergraph message passing to guide entity-level reasoning. The model's shared parameters are independent of specific entity or relation identifiers, enabling inductive prediction for unseen entities and relations. Extensive experiments on entity-inductive and fully inductive benchmarks demonstrate that QORH significantly outperforms the state-of-the-art baselines included in our evaluation, validating the effectiveness of rule hypergraph modeling for inductive link prediction.
Tags
Links
- Source: https://arxiv.org/abs/2610.18198v1
- Canonical: https://arxiv.org/abs/2610.18198v1
Trouble viewing inline? Open PDF directly →
Full Text
88,243 characters extracted from source content.
Expand or collapse full text
QORH: Learning Query-Specific Ordered Rule Hypergraphs for Inductive Knowledge Graph Link Prediction Naixing Xu Affiliation: School of Software, Shandong University, Jinan, China E-mail naixingxu@mail.sdu.edu.com Abstract Knowledge graph link prediction involving unseen entities and relations requires learning transferable reasoning patterns from observed graph structure. Existing methods based on relation graphs primarily capture pairwise dependencies, limiting their ability to preserve the compositional semantics, relation ordering, and role information of complete path rules. To address this limitation, we propose QORH (Query-specific Ordered Rule Hypergraph), which jointly encodes rule heads and ordered rule bodies as hyperedges conditioned on the query relation, explicitly modeling joint dependencies among multiple relations. QORH performs learnable rule selection using statistical evidence, such as rule confidence and coverage, and enhances relation representations through role-aware hypergraph message passing to guide entity-level reasoning. The model’s shared parameters are independent of specific entity or relation identifiers, enabling inductive prediction for unseen entities and relations. Extensive experiments on entity-inductive and fully inductive benchmarks demonstrate that QORH significantly outperforms the state-of-the-art baselines included in our evaluation, validating the effectiveness of rule hypergraph modeling for inductive link prediction. Keywords: Knowledge graph link prediction Inductive reasoning Ordered rule hypergraphs Higher-order relational modeling Graph neural networks. 1 Introduction Figure 1: Spurious composition of binary edges in relation-level auxiliary graphs. The two KGs induce identical binary relation graphs, yet only KG A contains a continuous path with the relation sequence (r1,r2,r3)(r_1,r_2,r_3). Knowledge graphs (KGs) represent entities and their semantic relationships as structured triples (h,r,t)(h,r,t), where h, t, and r denote the head entity, tail entity, and their relation, respectively. Owing to their rich semantics and structured representation capabilities, KGs have been widely applied to recommender systems [32, 33], question answering [3, 39], biomedicine [2, 18], and other domains [41, 21]. However, KGs are typically incomplete because of the high cost of knowledge acquisition and the continuous evolution of real-world knowledge. Knowledge graph link prediction aims to infer missing facts from observed ones and has become a central task in KG research. Although conventional embedding methods such as TransE [4], DistMult [36], ComplEx [30], and RotatE [27] have achieved notable progress, they generally follow the transductive setting, assuming that all entities and relations encountered during inference have been observed during training. Consequently, they struggle to generalize to unseen entities and relations. To handle unseen entities, entity-inductive methods such as GraIL [28], TACT [5], MorsE [6], and Content Pooling [26] learn transferable local structures and relational patterns without relying on entity-specific representations. Nevertheless, these methods typically assume a shared relation set between the training and test graphs, limiting their applicability to open-world scenarios in which both entities and relations continuously emerge. Accordingly, fully inductive KG link prediction requires models to generalize simultaneously to unseen entities and relations. Methods such as RMPI [16], InGram [19], and TARGI [9] enable fully inductive reasoning by learning transferable relational structures. KG foundation models such as ULTRA [15] and GraphOracle [10] further learn general reasoning patterns independent of specific entity and relation vocabularies through pretraining across multiple KGs, achieving strong performance on various inductive benchmarks with limited fine-tuning on target KGs. Despite the progress made by fully inductive KG link prediction methods such as InGram [19], ULTRA [15], TARGI [9], and GraphOracle [10], their relation modeling is generally limited to pairwise dependencies induced by shared entities, making it difficult to preserve the compositional semantics, relation roles, and overall reliability of ordered multi-relation rules. As illustrated in Figure 1, given a KG =(,ℛ,ℱ)G=(V,R,F), GraphOracle [10] establishes a directed edge in its relation-level auxiliary graph whenever two relations are sequentially connected through an intermediate entity: (ri,rj)∈ℰR⇔∃u,x,v∈:(u,ri,x)∈ℱ∧(x,rj,v)∈ℱ,(r_i,r_j) _R ∃\,u,x,v :(u,r_i,x) (x,r_j,v) , where V, ℛR, and ℱF denote the entity set, relation set, and factual triple set, respectively, and ℰRE_R is the directed edge set of the relation-level auxiliary graph. This construction retains only local adjacency between relations and cannot determine whether multiple pairwise dependencies originate from the same complete path. For example, both knowledge graph A and knowledge graph B contain r1→r2r_1→ r_2 and r2→r3r_2→ r_3, whereas only knowledge graph A contains the complete sequence r1→r2→r3r_1→ r_2→ r_3. In knowledge graph B, the two relation pairs arise from different paths and therefore cannot form a valid reasoning chain. We refer to this limitation as the “spurious composition of binary edges,” indicating that pairwise dependencies alone are insufficient to recover higher-order joint structures among multiple relations. Moreover, as discussed in GraphOracle, the performance of existing KG foundation models often depends substantially on fine-tuning over target datasets [10]. Our data analysis in Section 4.2 further reveals overlaps between some pretraining data and inductive test sets, exposing models to information that should remain unseen during evaluation and thereby causing data leakage. Consequently, the resulting performance may conflate pretraining memorization with inductive generalization, making it difficult to assess the models’ true capabilities under strict inductive protocols. Therefore, achieving reliable link prediction for unseen entities and even unseen relations under strict inductive evaluation protocols remains an important open problem. To address these limitations, we propose a query-specific rule hypergraph enhancement method that represents ordered path rules as hyperedges connecting rule-head and rule-body relations, thereby preserving their compositional semantics, ordering, and role information. A lightweight multilayer perceptron jointly considers rule statistics, such as confidence and coverage, to select high-quality hyperedges, while role-aware relation–hyperedge–relation message passing enhances relation representations for entity-level reasoning and link prediction. Following the entity-inductive protocol of GraIL [28] and the fully inductive protocol of InGram [19], our method achieves state-of-the-art performance in both inductive settings. The main contributions of this work are summarized as follows: • We propose a query-specific rule hypergraph enhancement method that explicitly models ordered multi-relation rules through learnable rule selection and role-aware hypergraph propagation. • We identify the loss of multi-relation rule information and the spurious composition of binary edges caused by binary relation-level auxiliary graphs, and analyze this limitation from the perspective of higher-order relational modeling. • We conduct systematic experiments on 12 entity-inductive and 12 fully inductive datasets. The proposed method consistently outperforms existing state-of-the-art approaches on the major evaluation metrics, demonstrating strong inductive generalization and robustness. 2 Related Work This section systematically reviews recent advances in entity-inductive and fully-inductive knowledge graph link prediction and surveys related work on hypergraphs for knowledge graph representation learning and link prediction. Figure 2: Illustration of knowledge graph link prediction settings. (a) Transductive: seen entities and relations. (b) Entity-inductive: unseen entities with seen relations. (c) Fully-inductive: unseen entities with partially or entirely unseen relations. 2.1 Entity-Inductive Knowledge Graph Link Prediction As illustrated in Figure 2, let trV_tr and infV_inf denote the entity sets of the training and inference graphs, respectively, and let ℛtrR_tr and ℛinfR_inf denote their corresponding relation sets. Under the transductive setting, all entities and relations involved at inference time have already appeared during training; that is, inf⊆trV_inf _tr and ℛinf⊆ℛtrR_inf _tr. In contrast, the entity-inductive setting requires tr∩inf=∅V_tr _inf= while retaining a shared relation vocabulary, thereby evaluating the model’s ability to generalize to unseen entities. Logical rules are inherently independent of specific entities and therefore constituted an important early approach to entity-inductive reasoning. Neural LP [37] represents relation compositions as differentiable matrix operations; DRUM [25] improves the efficiency of learning long rules through recurrent rule modeling; and RNNLogic [24] treats logical rules as latent variables and jointly optimizes rule generation and reasoning. More recently, graph neural networks have further advanced this field. GraIL [28] encodes the local enclosing subgraph surrounding each candidate triple to learn entity-independent structural patterns. CoMPILE [30] strengthens the interactions between entities and relations within directed subgraphs, thereby improving the modeling of asymmetric relations. TACT [5] captures topological correlations between relation pairs to enrich the relational information contained in local subgraphs. MorsE [6] employs meta-learning to generate representations of unseen entities from their observed neighborhoods. Among path-based reasoning methods, NBFNet [42] formulates link prediction as a learnable generalized Bellman–Ford process; RED-GNN [40] improves reasoning efficiency by sharing overlapping paths among candidate entities; and the recently proposed Context Pooling [26] selects logically relevant neighbors conditioned on a given query to suppress structural noise. Although these methods can generalize to unseen entities, they typically assume that the training and inference graphs share the same relational semantics, allowing learned relation-specific parameters or rule templates to be reused during inference. Consequently, they have difficulty adapting to open knowledge graphs in which new relations continually emerge. 2.2 Fully-Inductive Knowledge Graph Link Prediction As illustrated in Figure 2(c), the fully-inductive setting further allows the inference graph to contain relations unseen during training, i.e., ℛinf⊈ℛtrR_inf _tr. Under the strictest setting, ℛtr∩ℛinf=∅R_tr _inf= also holds. Therefore, the model must derive representations of both unseen entities and unseen relations from the structure of the inference graph. Existing methods primarily employ relation-level auxiliary graphs to learn transferable representations. RMPI [16] performs relational message passing within local subgraphs; InGram [19] constructs a weighted relation graph based on relation affinities and successively aggregates relation-level and entity-level information; and TARGI [9] exploits global topological interactions to alleviate the biases introduced by local structures and relation frequencies. In recent years, knowledge graph foundation models have demonstrated strong reasoning performance and generalization capabilities in inductive link prediction. ULTRA [15] learns transferable relative relation representations by categorizing the ways in which relations share entities into four interaction types: head-to-head, head-to-tail, tail-to-head, and tail-to-tail. The recently proposed GraphOracle [10] constructs a sparse directed relation-dependency graph and generates relation representations through query-conditioned attention. However, the relation-level auxiliary graphs employed by these methods are still predominantly composed of pairwise edges. Although such graphs can represent co-occurrence, topological, or logical dependencies between relations, they cannot reliably determine whether multiple pairwise dependencies originate from the same complete path. Consequently, the overall semantics of a rule, the positions of relations along the path, and their respective roles may be weakened. Furthermore, knowledge graph foundation models such as ULTRA [15] and GraphOracle [10] require lengthy pretraining on multiple datasets, including WN18R [8] and FB15k-237 [29], whereas existing mainstream inductive link prediction benchmarks [28, 19] are constructed by partitioning WN18R [8] and FB15k-237 [29]. Therefore, even when inductive evaluation is conducted in a zero-shot setting, i.e., without fine-tuning on the target knowledge graph, overlaps may still exist between the training data and the inductive test data (see Section 4.2). As a result, the reported performance may not faithfully reflect the models’ generalization capabilities under strict inductive evaluation protocols. Unlike the aforementioned methods, our approach strictly follows the inductive evaluation protocols introduced by GraIL [28] and InGram [19]. For each query relation, it mines complete ordered path rules and represents each rule as a hyperedge connecting the rule head and multiple rule-body relations, thereby explicitly modeling multi-relation joint dependencies that cannot be fully captured by binary relation graphs. 2.3 Hypergraphs for Knowledge Graph Representation and Link Prediction A hypergraph allows a single hyperedge to connect more than two nodes, enabling it to represent higher-order dependencies that ordinary graphs cannot fully capture. HGNN [12] learns higher-order data correlations through message passing and provides a general framework for subsequent research on hypergraph neural networks. Several studies have extended hypergraph modeling to more complex knowledge representation and knowledge graph link prediction scenarios. StarE [14] develops a message-passing mechanism for hyper-relational knowledge graphs with qualifiers, jointly encoding a primary triple and its auxiliary information. LHP [38] represents logical conjunctions using directed hyperedges and treats logical dependencies among multiple nodes as an integrated structure for hyperlink prediction. ReAlE [11] further improves the expressiveness of knowledge hypergraph representations from the perspective of relational algebra. Nevertheless, existing methods primarily focus on representing and completing native n-ary facts or qualified facts, and most operate under transductive settings in which the training and test stages share entity or relation vocabularies. By contrast, the application of hypergraphs to inductive knowledge graph link prediction remains at an early stage. In particular, how to construct transferable relation-level reasoning structures using hypergraphs in traditional knowledge graphs, where binary relations are represented as triples (h,r,t)(h,r,t), remains insufficiently explored. 3 Methodology This section details the proposed Query-specific Ordered Rule Hypergraph (QORH) method, whose overall framework is illustrated in Figure 3. Figure 3: Overview of QORH: query-specific ordered rule hypergraphs for inductive knowledge graph link prediction. 3.1 Problem Formulation and Framework Overview Following the entity-inductive and fully inductive settings defined in Section 2, let obs=(,ℛ,ℱobs)G_obs=(V,R,F_obs) denote the observed knowledge graph at the current stage, where V, ℛR, and ℱobsF_obs are the sets of entities, relations, and observed facts available for reasoning, respectively. Given a head entity h and a query relation q, the model ranks candidate tail entities t∈t for the query (h,q,?)(h,q,?) using the scoring function sθ(h,q,t∣obs)s_θ(h,q,t _obs), where θ denotes the learnable parameters. To unify head and tail entity prediction, we augment each observed fact (u,r,v)(u,r,v) with its inverse fact (v,r−1,u)(v,r^-1,u), yielding the fact set ℱ±F_± and the relation set ℛ±=ℛ∪ℛ−1R_±=R ^-1, where ℛ−1R^-1 is the set of inverse relations.We further add a self-loop (v,rself,v)(v,r_self,v) to each entity, yielding the fact set ℱ~ F and the relation set ℛ¯=ℛ±∪rself R=R_±∪r_self for entity-level message passing. Rules are mined exclusively from ℱ±F_±, excluding the artificially added entity self-loops. QORH first generates query-conditioned base relation representations r|q∈ℝdz_r q ^d on the relation dependency graph, then obtains enhanced representations ~r|q z_r q through the rule hypergraph, and finally uses these enhanced representations to perform entity-level message passing from the head entity h and score candidate tail entities. Here, d is the hidden dimension, and the subscript r|qr q indicates that the representation of relation r is conditioned on the query relation q. 3.2 Query-Conditioned Relation Encoding As shown in Figure 3(a), QORH first extracts local relational context from the observed graph to obtain base representations for the subsequent encoding of complete rules. The base relation encoder follows the relation graph modeling approaches used in prior work [19, 15, 10], treating relation types as nodes and converting local connectivity patterns in the knowledge graph into structural links between relations. Specifically, we construct a directed relation graph based on whether two entity-level edges form a head-to-tail path through an intermediate entity: ℰR→=(r,s)∈ℛ±2|∃u,x,v∈:(u,r,x)∈ℱ±∧(x,s,v)∈ℱ±.E_R^→= \(r,s) _±^2\; |\;∃ u,x,v :(u,r,x) _± (x,s,v) _± \. (1) Here, r and s are the relations of the first and second edges along the path, respectively, and x is the intermediate entity connecting the two edges. To enable information exchange between adjacent relations, we augment this dependency set with reverse propagation edges and add a self-loop to each relation node, yielding the relation graph R=(ℛ¯,ℰR)G_R=( R,E_R), where ℰR=ℰR→∪(s,r)∣(r,s)∈ℰR→∪(r,r)∣r∈ℛ¯.E_R=E_R^→∪ \(s,r) (r,s) _R^→ \∪ \(r,r) r∈ R \. (2) These reverse propagation edges connect relation nodes and are distinct from the inverse relations that represent inverse facts in the entity graph. Inspired by the query-conditioned relation dependency graph modeling approach in GraphOracl [10]e, QORH initializes relation nodes with query indicators for a given query relation q: r|q(0)=d,r=q,d,r≠q,r∈ℛ¯,z_r q^(0)= cases1_d,&r=q,\\ 0_d,&r≠ q, cases r∈ R, (3) where d1_d and d0_d are the d-dimensional all-ones and zero vectors, respectively. This initialization provides an initial signal at the query relation for structural propagation, allowing different query relations to obtain their own contextual representations. Let R(s)=r∣(r,s)∈ℰRN_R(s)=\r (r,s) _R\ denote the set of incoming neighbors of relation node s, including s itself. At propagation layer k, the attention score and normalized weight for edge (r,s)(r,s) are given by er,s|q(k) e_r,s q^(k) =(R(k))⊤[A(k)r|q(k−1)∥A(k)s|q(k−1)], = (a_R^(k) ) [W_A^(k)z_r q^(k-1)\;\|\;W_A^(k)z_s q^(k-1) ], (4) αr,s|q(k) _r,s q^(k) =exp(er,s|q(k))∑u∈R(s)exp(eu,s|q(k)). = \! (e_r,s q^(k) ) _u _R(s) \! (e_u,s q^(k) ). Here, ∥\| denotes vector concatenation, A(k)∈ℝd×dW_A^(k) ^d× d is the attention projection matrix, and R(k)∈ℝ2da_R^(k) ^2d is a learnable attention vector. Normalization is performed over the incoming edges of the receiving relation s for a fixed query q. The relation representation is updated as s|q(k)=ReLU(O(k)[N(k)∑r∈R(s)αr,s|q(k)r|q(k−1)+S(k)αs,s|q(k)s|q(k−1)]).z_s q^(k)=ReLU\! (W_O^(k) [W_N^(k) _r _R(s) _r,s q^(k)z_r q^(k-1)+W_S^(k) _s,s q^(k)z_s q^(k-1) ] ). (5) Here, N(k)W_N^(k), S(k)W_S^(k), and O(k)W_O^(k) are learnable d×d× d matrices for neighborhood aggregation, transformation of the node’s own information, and output mapping, respectively; ReLUReLU is an element-wise activation function. Neighborhood aggregation includes self-loop messages, while a separate transformation of the node’s own information preserves its query-dependent state. After LRL_R propagation layers, we set r|q=r|q(LR)z_r q=z_r q^(L_R), where LRL_R is the depth of the relation encoder. The resulting representation captures the local structural context of relation r relative to query q and serves as the input to the subsequent rule hypergraph encoder. 3.3 Query-Specific Rule Hypergraph Construction The relation graph provides QORH with query-dependent local context, but its pairwise edges do not explicitly indicate whether multiple dependencies originate from the same complete path. To address this limitation, QORH further mines ordered path rules from the observed graph and represents each selected rule in its entirety as a hyperedge. Figure 3(b) illustrates the process from rule mining to learnable selection. Mining Ordered Path Rules To associate complete paths with their conclusion relations, QORH mines ordered path rules of the following form from the observed facts: ρ:r1(x0,x1)∧r2(x1,x2)∧⋯∧rℓρ(xℓρ−1,xℓρ)⇒q(x0,xℓρ).ρ: r_1(x_0,x_1) r_2(x_1,x_2) ·s r_ _ρ(x_ _ρ-1,x_ _ρ) q(x_0,x_ _ρ). (6) Here, ρ denotes a rule, q is its head relation, (r1,…,rℓρ)(r_1,…,r_ _ρ) is its ordered body, and ℓρ _ρ is its body length, satisfying 1≤ℓρ≤Lmax1≤ _ρ≤ L_ ; LmaxL_ is a configurable maximum rule length. The variables x0,…,xℓρx_0,…,x_ _ρ denote entities along the path, and adjacent relations in the rule body are linked through shared variables. Thus, a rule specifies not only which relations co-occur but also their composition order and the correspondence between their endpoints. Specifically, we enumerate simple directed paths over ℱ±F_± that do not revisit any entity and group paths with identical relation sequences into the same rule body pattern. A relation type may occur at multiple positions along a path. To control computational cost, we cap the number of outgoing edges retained per entity and the number of paths enumerated per starting entity at each depth, with default limits of 64 and 1024, respectively. Let P denote the set of enumerated paths; for a rule ρ, we define the set of endpoint entity pairs associated with its body and the set of head facts as ℬρ _ρ =(v0,vℓρ)|(v0,r1,v1,…,rℓρ,vℓρ)∈, = \(v_0,v_ _ρ)\; |\;(v_0,r_1,v_1,…,r_ _ρ,v_ _ρ) \, (7) ℋq _q =(u,v)∣(u,q,v)∈ℱ±. = \(u,v) (u,q,v) _± \. Here, v0,…,vℓρv_0,…,v_ _ρ are the entities in a concrete path; ℬρB_ρ contains the distinct entity pairs connected by the enumerated rule body paths, and ℋqH_q contains the distinct entity pairs directly connected by relation q. Computing statistics over sets of entity pairs ensures that each endpoint pair is counted only once, even when multiple paths instantiate the same rule body between the two endpoints. The support, confidence, and coverage of a rule are defined as sρ=|ℬρ∩ℋq|,confρ=sρ|ℬρ|,covρ=sρ|ℋq|.s_ρ=|B_ρ _q|, _ρ= s_ρ|B_ρ|, _ρ= s_ρ|H_q|. (8) Here, sρs_ρ counts the endpoint entity pairs that satisfy both the rule body and the rule head, quantifying the observed support for the rule; confρconf_ρ measures the proportion of entity pairs connected by the rule body that also have the corresponding head fact; covρcov_ρ measures the proportion of observed head facts that can be explained by the rule body. These statistics characterize the amount of supporting evidence, conditional reliability, and coverage of observed facts, respectively. We retain only candidate rules whose support is at least the threshold smins_ and exclude tautological identity rules of the form q(x,y)⇒q(x,y)q(x,y) q(x,y). Let qC_q denote the resulting set of candidate rules with head relation q. For example, support for r1(x,z)∧r2(z,y)⇒q(x,y)r_1(x,z) r_2(z,y) q(x,y) requires observing both the complete two-hop path and relation q for the same endpoint pair (x,y)(x,y). This unit of statistical analysis jointly retains the complete path and its conclusion relation, enabling subsequent modeling to exploit joint information that is absent from independent relation pairs. Learnable Rule Selection The mining procedure yields candidate rules with observed support, but these rules still vary in the amount of support, coverage, and path length.To align rule use with the link prediction objective, QORH introduces a learnable selector before hyperedge encoding. Specifically, we construct a four-dimensional feature vector for each candidate rule: ϕρ=[sρ+1|ℬρ|+2,sρ+1|ℋq|+2,ℓρLmax,log(1+sρ)log(1+smax)]⊤∈ℝ4. φ_ρ= [ s_ρ+1|B_ρ|+2, s_ρ+1|H_q|+2, _ρL_ , (1+s_ρ) (1+s_ ) ] ^4. (9) Here, smaxs_ is the maximum support among all candidate rules in the current observed graph, taken over the union of all nonempty candidate sets qC_q. The first two components are the confidence and coverage with add-one smoothing, respectively, which mitigates extreme estimates arising from limited observations; the last two components normalize rule length and support, respectively, with the logarithmic transformation reducing numerical differences across support scales. The rule selection score is computed by a shared multilayer perceptron (MLP): ωρ=σ(s2⊤SiLU(s1ϕρ+s1)+bs2). _ρ=σ\! (w_s2 SiLU (W_s1 φ_ρ+b_s1 )+b_s2 ). (10) Here, s1∈ℝds×4W_s1 ^d_s× 4, s1∈ℝdsb_s1 ^d_s, s2∈ℝdsw_s2 ^d_s, and bs2∈ℝb_s2 are learnable parameters, and dsd_s is the hidden dimension of the selector; σ is the sigmoid function, and SiLU(x)=xσ(x)SiLU(x)=xσ(x) is the hidden-layer activation function; ωρ∈(0,1) _ρ∈(0,1) denotes the rule selection score. For query relation q, we select up to K rules with the highest scores from qC_q: kq=min(K,|q|),q=TopKkq(q;ωρ).k_q= (K,|C_q|), _q=TopK_k_q (C_q; _ρ ). (11) Here, K is a configurable upper bound on the number of selected rules, kqk_q is the actual number selected, and qS_q is the selected rule set; TopKTopK selects rules in descending order of ωρ _ρ. If qC_q is empty, we set q=∅S_q= . Rule selection precedes hyperedge encoding, restricting the more computationally expensive sequence encoding and hypergraph propagation to the selected rules. The selection score ωρ _ρ also contributes to hyperedge feature encoding and message attention, linking rule filtering and the use of rule information through the same score. Order- and Role-Preserving Hyperedge Representation After selecting the rules, QORH converts these discrete rules into hyperedge representations suitable for neural message passing. For each ρ∈qρ _q, we construct a hyperedge connecting the rule head and body relations. Recording only the relations contained in a hyperedge is insufficient to distinguish different ordered rules, so we also preserve each relation’s position and role within the rule. We define r(ρ,j)=q,j=0,rj,1≤j≤ℓρ,ℐq=(r(ρ,j),ρ,j)|ρ∈q, 0≤j≤ℓρ.r(ρ,j)= casesq,&j=0,\\ r_j,&1≤ j≤ _ρ, cases _q= \ (r(ρ,j),ρ,j )\; |\;ρ _q,\ 0≤ j≤ _ρ \. (12) Here, j=0j=0 denotes the rule head role, while j≥1j≥ 1 denotes position j in the rule body; r(ρ,j)r(ρ,j) returns the relation node associated with that role; ℐqI_q is the set of role-labeled relation-hyperedge incidences. The rule hypergraph for the query relation is denoted by H,q=(ℛ¯,q,ℐq)G_H,q=( R,S_q,I_q), with relation types as nodes and a one-to-one correspondence between hyperedges and selected rules. Even when the same relation occurs at multiple positions in a rule body, the incidence set retains each position separately, preserving the distinctions between roles within the rule. Figure 3(c) illustrates the construction of hyperedge representations, in which the rule body branch first encodes the ordered composition of relations. For the relation at body position j of rule ρ, we construct a position-dependent input and sequentially update the hidden state using a gated recurrent unit (GRU): ρ,j _ρ,j =Brj|q+j, =W_Bz_r_j q+p_j, (13) ρ,j _ρ,j =GRUB(ρ,j,ρ,j−1),ρ,0=d, =GRU_B (x_ρ,j,b_ρ,j-1 ), _ρ,0=0_d, ρ _ρ =ρ,ℓρ. =b_ρ, _ρ. Here, B∈ℝd×dW_B ^d× d is a projection matrix, j∈ℝdp_j ^d is the learnable embedding for body position j, and ρ,j∈ℝdx_ρ,j ^d is the input feature at that position; GRUBGRU_B is a sequence encoder shared across all rules, ρ,jb_ρ,j is its hidden state after processing the first j relations, and ρb_ρ is the representation of the complete rule body. Encoding is applied only to valid positions within each rule. Positional embeddings identify each relation’s position along the path, while recurrent updates compose relation information in path order. We then encode the rule statistics and selection score into a statistical representation and fuse it with the head and body representations: ρ _ρ =MLPstat([ϕρ∥ωρ]), =MLP_stat ([ φ_ρ\| _ρ] ), (14) ρ _ρ =LNe(MLPedge([q|q‖ρ‖ρ])). =LN_e (MLP_edge ([z_q q\|b_ρ\|c_ρ] ) ). Here, MLPstat:ℝ5→ℝdMLP_stat:R^5 ^d maps the four statistical features and the selection score to ρ∈ℝdc_ρ ^d; MLPedge:ℝ3d→ℝdMLP_edge:R^3d ^d fuses the three types of input, with both MLPs implemented as two-layer perceptrons with GELU activation and hidden dimension d; LNeLN_e denotes layer normalization; ρ∈ℝde_ρ ^d is the resulting hyperedge representation. The three components provide the query relation targeted by the rule, the ordered composition pattern of its body, and the statistical evidence for the rule, respectively. QORH thus encodes each rule into a unified representation incorporating its head, body, and statistical evidence. For example, the representation of rule r1(x,z)∧r2(z,y)⇒q(x,y)r_1(x,z) r_2(z,y) q(x,y) preserves the role of q as the conclusion, the relative positions of r1r_1 and r2r_2, and the statistics of their joint support. The hyperedge representation specifies how a complete rule is encoded; the next step is to determine how this information contributes to relation nodes serving different roles. 3.4 Role-Aware Hypergraph Message Passing To propagate complete rule information back to the relation level, QORH performs hyperedge-to-relation message passing along role-labeled incidences, which, together with the relation-to-hyperedge encoding in the preceding section, constitutes the relation enhancement process. As shown in Figure 3(d), this process first generates messages according to rule roles, then aggregates them using incidence compatibility and rule selection scores, and finally updates relation representations through gated residual connections. Role-Specific Messages and Rule-Quality Attention The head and body relations of a rule serve different functions in the reasoning structure, and different positions within the body correspond to different stages of relation composition. QORH therefore uses role-specific transformations to map the same hyperedge representation to messages for different participating relations. For a relation-hyperedge incidence (r(ρ,j),ρ,j)(r(ρ,j),ρ,j), we define ρ,j=jmsgρ,jmsg=head,j=0,body,j,1≤j≤Lmax. μ_ρ,j=W_j^msge_ρ, _j^msg= casesW_head,&j=0,\\ W_body,j,&1≤ j≤ L_ . cases (15) Here, ρ,j∈ℝd μ_ρ,j ^d is the message sent by rule ρ to the relation in role j; head∈ℝd×dW_head ^d× d is the message transformation for the rule head, and body,j∈ℝd×dW_body,j ^d× d is the message transformation for body position j. A relation may participate in multiple rules, so its incoming messages should account for rule content, the state of the receiving relation, and rule quality. To this end, we combine relation-hyperedge incidence compatibility with the selection score to compute attention: ξρ,j|q=H⊤tanh(Hrr(ρ,j)|q+Heρ+j)+ηlog(max(ωρ,ε)). _ρ,j q=w_H \! (W_Hrz_r(ρ,j) q+W_Hee_ρ+u_j )+η \! ( ( _ρ, ) ). (16) Here, ξρ,j|q _ρ,j q denotes the unnormalized attention score, conditioned on query relation q, for the relation–hyperedge incidence indexed by (ρ,j)(ρ,j). The matrices Hr,He∈ℝd×dW_Hr,W_He ^d× d map the representation of the receiving relation node and the rule hyperedge representation, respectively, into a shared attention feature space. The symbol ρ denotes the rule associated with the incidence, and j denotes the role index, with j=0j=0 corresponding to the rule head and j≥1j≥ 1 to the j-th position in the rule body. The notation r(ρ,j)r(ρ,j) identifies the relation node associated with that role, and r(ρ,j)|q∈ℝdz_r(ρ,j) q ^d denotes its base representation conditioned on query relation q, before hypergraph enhancement. The vector ρ∈ℝde_ρ ^d represents the hyperedge corresponding to rule ρ, while j∈ℝdu_j ^d is a role embedding used to distinguish a relation’s position and function within the rule when computing compatibility. The vector H∈ℝdw_H ^d is the attention scoring vector, and tanh denotes the element-wise hyperbolic tangent function. The rule-selection score ωρ∈(0,1) _ρ∈(0,1) is produced by the rule selector, η≥0η≥ 0 controls its strength as an attention prior, and ε=10−8 =10^-8 ensures numerical stability in the logarithm computation. This logarithmic prior allows rule-selection scores to further modulate the relative contributions of incidence messages beyond content compatibility. For a given query relation q and receiving relation node r, let ℐq(r)=(ρ,j)∣(r,ρ,j)∈ℐqI_q(r)=\(ρ,j) (r,ρ,j) _q\ denote the set of rule-role pairs incident to that node. If ℐq(r)I_q(r) is nonempty, we apply softmax normalization to the attention scores of these incidences and aggregate the corresponding role-specific messages using the resulting weights: βρ,j|q _ρ,j q =exp(ξρ,j|q)∑(ρ′,j′)∈ℐq(r)exp(ξρ′,j′|q),(ρ,j)∈ℐq(r), = ( _ρ,j q) _(ρ ,j ) _q(r) ( _ρ ,j q), (ρ,j) _q(r), (17) r|q _r q =∑(ρ,j)∈ℐq(r)βρ,j|qρ,j. = _(ρ,j) _q(r) _ρ,j q μ_ρ,j. Here, βρ,j|q _ρ,j q is the normalized attention weight for incidence (ρ,j)(ρ,j), satisfying ∑(ρ,j)∈ℐq(r)βρ,j|q=1 _(ρ,j) _q(r) _ρ,j q=1 at each receiving relation node; ρ′ρ and j′j index the rules and their roles, respectively, in the normalization sum; ρ,j∈ℝd μ_ρ,j ^d is the message generated by rule ρ for role j; r|q∈ℝdm_r q ^d is the aggregated rule message for relation node r conditioned on query relation q. Normalization is performed over all rule-role pairs incident to the same receiving relation node under the same query relation. When a relation occurs at multiple positions within a rule, each occurrence is treated as a separate incidence during attention normalization and message aggregation, preserving the contributions of different roles to the relation update. Both head and body relations receive rule information through their respective role-labeled incidences. Gated Relation Update The aggregated message provides complementary information from complete rules for the current relation, while the base relation representation retains its local structural context. To combine these two sources of information, we introduce an element-wise update gate: r|q _r q =σ(g[r|q∥r|q]+g),ℐq(r)≠∅, =σ\! (W_g[z_r q\|m_r q]+b_g ), _q(r)≠ , (18) ~r|q z_r q =LNu(r|q+r|q⊙r|q),ℐq(r)≠∅,r|q,ℐq(r)=∅. = casesLN_u (z_r q+g_r q _r q ),&I_q(r)≠ ,\\ z_r q,&I_q(r)= . cases Here, g∈ℝd×2dW_g ^d× 2d and g∈ℝdb_g ^d are the gating parameters, r|q∈(0,1)dg_r q∈(0,1)^d controls the extent to which rule messages are incorporated into each feature dimension, ⊙ denotes element-wise multiplication, LNuLN_u is the layer normalization used in the relation update, and ~r|q z_r q is the final enhanced relation representation. The residual term preserves the context provided by the base relation graph, while the gated term introduces complete rule information relevant to the current relation. Relations that do not participate in any selected rule retain their original representations; when q=∅S_q= , all relations retain the outputs of the base relation encoder. The resulting representations ~r|q z_r q serve as both edge relation and query relation representations in entity reasoning, allowing relation-level rule information to influence message passing between individual entities. 3.5 Rule-Enhanced Entity-Level Reasoning As shown in Figure 3(d), given a query (h,q,?)(h,q,?), QORH uses the enhanced relation representations to perform LEL_E layers of message passing over ℱ~ F, starting from the head entity h. Let (ℓ)A^( ) denote the set of active entities at layer ℓ , defined as (0)=h,(ℓ)=v∈|∃u∈(ℓ−1),r∈ℛ¯:(u,r,v)∈ℱ~.A^(0)=\h\, ^( )= \v \; |\;∃ u ^( -1),\ r∈ R:(u,r,v)∈ F \. (19) Here, ℓ=1,…,LE =1,…,L_E, and entity self-loops ensure that previously active nodes continue to participate in message passing. Let v(ℓ)∈ℝdh_v^( ) ^d denote the hidden state of entity v at layer ℓ ; we omit its conditioning subscript (h,q)(h,q) for brevity and set h(0)=dh_h^(0)=0_d. For each edge (u,r,v)(u,r,v) with u∈(ℓ−1)u ^( -1), we compute its message and query-conditioned propagation weight from the source entity state and the enhanced relation representations: u,r,v(ℓ) _u,r,v^( ) =u(ℓ−1)+~r|q, =h_u^( -1)+ z_r q, (20) u,r|q(ℓ) _u,r q^( ) =ReLU(s(ℓ)u(ℓ−1)+r(ℓ)~r|q+q(ℓ)~q|q+a(ℓ)), =ReLU\! (W_s^( )h_u^( -1)+W_r^( ) z_r q+W_q^( ) z_q q+b_a^( ) ), γu,r,v(ℓ) _u,r,v^( ) =σ((α(ℓ))⊤u,r|q(ℓ)+bα(ℓ)). =σ\! ( (w_α^( ) ) a_u,r q^( )+b_α^( ) ). Here, u,r,v(ℓ)∈ℝdm_u,r,v^( ) ^d is the message on an entity-level edge, u,r|q(ℓ)∈ℝdaa_u,r q^( ) ^d_a is the query-conditioned attention feature, and γu,r,v(ℓ)∈(0,1) _u,r,v^( )∈(0,1) is the propagation weight of that edge; the matrices s(ℓ),r(ℓ),q(ℓ)∈ℝda×dW_s^( ),W_r^( ),W_q^( ) ^d_a× d map the source entity state, edge relation representation, and query relation representation, respectively, a(ℓ),α(ℓ)∈ℝdab_a^( ),w_α^( ) ^d_a and bα(ℓ)∈ℝb_α^( ) are bias and output parameters, and dad_a is the hidden dimension of attention over entity-level edges; the edge weights γu,r,v(ℓ)∈(0,1) _u,r,v^( )∈(0,1) are computed independently using the sigmoid function, allowing multiple query-relevant edges to transmit information simultaneously. The target entity then aggregates messages from nodes active at the preceding layer and updates its state using a GRU operating across layers: ¯v(ℓ)=φ(h(ℓ)∑u∈(ℓ−1)(u,r,v)∈ℱ~γu,r,v(ℓ)u,r,v(ℓ)), h_v^( )= \! (W_h^( ) _ subarraycu ^( -1)\\ (u,r,v)∈ F subarray _u,r,v^( )m_u,r,v^( ) ), (21) v(ℓ)=GRUE(Dropout(¯v(ℓ)),^v(ℓ−1)).h_v^( )=GRU_E (Dropout ( h_v^( ) ), h_v^( -1) ). (22) Here, h(ℓ)∈ℝd×dW_h^( ) ^d× d is a learnable transformation, and φ is an element-wise activation function. For previously active entities, ^v(ℓ−1) h_v^( -1) is their hidden state from the preceding layer, whereas it is the zero vector for entities newly activated at the current layer; GRUEGRU_E shares parameters across entity reasoning layers and is parameterized independently of the rule body encoder GRUBGRU_B, while DropoutDropout provides regularization during training. After LEL_E propagation layers, a shared learnable scoring vector o∈ℝdw_o ^d is used to compute candidate tail entity scores: sθ(h,q,t∣obs)=o⊤t(LE),t∈(LE),0,t∉(LE).s_θ(h,q,t _obs)= casesw_o h_t^(L_E),&t ^(L_E),\\ 0,&t ^(L_E). cases (23) 3.6 Optimization and Inductive Inference The entity-inductive and fully inductive experiments for QORH follow the data splits and evaluation protocols of GraIL [28] and InGram [19], respectively. During training, we partition the training facts into message-passing facts and supervision queries and update the relation dependency graph and rule base as the observed facts change. Model parameters are optimized exclusively on training data, with the validation set used for model selection and the test set reserved for final evaluation. Given a batch of supervision triples bD_b, we apply softmax normalization to the scores over the set of training candidate entities trV_tr and minimize the negative log-likelihood loss: pθ(t∣h,q,obs) p_θ(t h,q,G_obs) =exp(sθ(h,q,t∣obs))∑v∈trexp(sθ(h,q,v∣obs)), = \! (s_θ(h,q,t _obs) ) _v _tr \! (s_θ(h,q,v _obs) ), (24) ℒ(θ) (θ) =−∑(h,q,t)∈blogpθ(t∣h,q,obs). =- _(h,q,t) _b p_θ(t h,q,G_obs). Here, pθp_θ is the conditional predictive probability of a candidate tail entity, t is the correct tail entity, v ranges over all training candidate entities, and ℒL is the batch loss. All candidate entities are included in the normalization, eliminating the need for additional negative sampling. During inductive inference, with the parameters θ fixed, we reconstruct the relation graph, mine rules, and compute their statistics from the observed facts in the inference graph before scoring the candidate entities in infV_inf. Because the shared parameters are independent of specific entity or relation IDs, the model can generate representations for unseen entities and relations from the structure of a new graph. To avoid redundant computation, queries with the same query relation within a batch share the relation encoding and hypergraph enhancement results; candidate rules and their statistics can also be reused when the observed graph remains unchanged. For each query relation, at most K rules with body length no greater than LmaxL_ are selected, and the total number of incidences satisfies |ℐq|=∑ρ∈q(ℓρ+1)≤K(Lmax+1)|I_q|= _ρ _q( _ρ+1)≤ K(L_ +1), bounding the scale of hypergraph propagation through the limits on rule count and length. 4 Experiments This section evaluates QORH on entity-inductive and fully inductive knowledge graph link prediction tasks, covering 12 datasets in each setting. Using mean reciprocal rank (MRR) as the primary evaluation metric, QORH achieves the best performance among the compared methods on 11 of the 12 entity-inductive datasets and all 12 fully inductive datasets, demonstrating its strong link prediction performance in both inductive settings. 4.1 Datasets and Evaluation Metrics Entity-Inductive Datasets We adopt the entity-inductive link prediction benchmarks introduced by GraIL [28]. These benchmarks comprise three dataset families derived from WN18R [8], FB15k-237 [29], and NELL-995 [34], each containing four versions, v1 through v4, yielding 12 datasets in total. Each version consists of a training graph and a corresponding inductive inference graph, enabling evaluation of generalization across different graph sizes and relational structures. Under the benchmark protocol, the training and inference graphs must have disjoint entity sets, while inference uses the relation vocabulary available during training, i.e., tr∩inf=∅,ℛinf⊆ℛtr.V_tr _inf= , _inf _tr. Fully Inductive Datasets We further adopt the benchmarks introduced by InGram [19], which comprise three dataset families, FB, NL, and WK, derived from FB15k-237 [29], NELL-995 [34], and Wikidata68K [17], respectively. Each family includes four settings, 25, 50, 75, and 100, yielding 12 datasets in total. These numbers specify the nominal proportions of triples involving unseen relations during dataset construction, rather than the proportions of unseen relation types; the actual proportions in the data files may deviate from these nominal values. In the first three settings, the inference graphs contain both seen and unseen relations, whereas the 100 setting enforces completely disjoint relation sets between the training and inference graphs. Following the task definition in Section 3.1, we collectively refer to these settings that allow unseen relations as fully inductive settings. Each dataset contains train.txt, msg.txt, valid.txt, and test.txt. The train.txt file is used for model training. The remaining three files belong to an inference graph whose entities are disjoint from those on the training side and provide observed facts, validation queries, and test queries, respectively. Evaluation Metrics We evaluate link prediction performance using mean reciprocal rank (MRR), Hits@1, and Hits@10. For each test triple, we perform both head and tail entity prediction. Head prediction is converted into tail prediction using inverse relations, consistent with the inference formulation in Section 3. Let N denote the total number of prediction instances evaluated in both directions, and let rankirank_i denote the rank of the target entity for the i-th instance. The metrics are defined as follows: MRR=1N∑i=1N1ranki,MRR= 1N _i=1^N 1rank_i, (25) Hits@k=1N∑i=1N(ranki≤k),k∈1,10,Hits@k= 1N _i=1^NI\! (rank_i≤ k ), k∈\1,10\, (26) where (⋅)I(·) is the indicator function. MRR measures the ranking positions of correct answers and is particularly sensitive to changes near the top of the candidate list. Hits@1 and Hits@10 measure the proportions of correct answers ranked first and within the top ten, respectively. Higher values indicate better performance for all three metrics. To comprehensively evaluate ranking performance over the candidate entity space, we use filtered evaluation with all entities as candidates. For a query (h,q,?)(h,q,?), all entities in the current message-passing graph are considered as candidates and ranked according to sθ(h,q,t∣obs)s_θ(h,q,t _obs). When computing the target entity’s rank, we filter out other candidate entities that form known true triples with the query, preventing valid alternative answers from being counted as incorrect predictions. Accordingly, no negative sampling is performed during evaluation. Compared with the original experimental settings of GraIL [28], MorsE [6], and related methods, which rank each test triple against 50 randomly sampled negative triples, all-entity ranking covers the complete candidate space and avoids the randomness introduced by candidate sampling. All MRR, Hits@1, and Hits@10 scores reported for QORH are computed under this all-entity evaluation setting. 4.2 Baselines and Experimental Setup To systematically evaluate QORH on entity-inductive and fully inductive link prediction tasks, we select 20 representative baseline methods spanning five methodological categories: logical rule learning, entity-graph reasoning, structural representation learning, semantic feature utilization, and relational structure transfer. (1) Logical rule learning methods: RuleN [23], Neural LP [37], and DRUM [25]. These methods learn logical composition patterns among relations and predict missing facts through rule instantiation. (2) Entity-graph structure and path propagation methods: GraIL [28], CoMPILE [22], SNRI [35], INDIGO [20], NBFNet [42], RED-GNN [40], and Context Pooling [26]. These methods extract structural evidence from entity neighborhoods, local subgraphs, or multi-hop paths to learn transferable link prediction patterns. (3) Representation methods based on structural encoding and meta-learning: CompGCN [31], NodePiece [13], and MorsE [6]. These methods learn representations for link prediction through compositional encoding of entities and relations, shared representation units, or transferable mechanisms for generating embeddings. (4) Methods using semantic and auxiliary features: BLP [7], QBLP [1], and RAILD [17]. These methods incorporate textual descriptions, entity features, or fact qualifiers to provide additional semantic evidence for inductive prediction. (5) Relational structure transfer methods: RMPI [16], InGram [19], TARGI [9], and GraphOracle [10]. These methods explicitly model structural connections among relations and use relation-level message passing to support generalization to new entities and relations. Experiments are conducted on a server running Ubuntu 20.04 with an NVIDIA Tesla V100 GPU equipped with 32 GB of memory. QORH is implemented in PyTorch and uses torch_scatter for sparse message aggregation. We use the Adam optimizer and set the random seed to 42. The hidden representation dimension is selected from 16,32,48,64\16,32,48,64\, the number of entity-level message-passing layers from 3,5, and the batch size from 10,20,24,100. The initial learning rate, L2L_2 regularization coefficient, and dropout rate range over 1.6×10−4,9.2×10−31.6× 10^-4,9.2× 10^-3, 1.8×10−5,4.0×10−41.8× 10^-5,4.0× 10^-4, and 0.02,0.300.02,0.30, respectively. For the ordered rule hypergraph module, the maximum rule length is selected from 2,3\2,3\, the minimum rule support is set to 2, and the number of rules selected for each query relation is chosen from 1,2,3,4,5,6,7\1,2,3,4,5,6,7\. QORH is trained for a maximum of 200 epochs, with validation MRR used for model selection and early stopping. Training terminates when validation MRR fails to improve for 10 consecutive epochs, and the model with the highest validation MRR is used for final testing. As discussed in Sections 2.2 and 4.2, the pretraining data of existing knowledge graph foundation models overlap with inductive test data, which is inconsistent with the inductive evaluation protocol. As shown in Table 1, the official pretraining pipeline of GraphOracle [10] includes source knowledge graphs such as FB15k-237 [29] and WN18R [8], from which some inductive benchmarks are also constructed. Consequently, even under zero-shot evaluation on the target dataset, a substantial fraction of the test entities and relations have already been encountered by the pretrained model. Table 1: Overlap between GraphOracle’s pretraining data and selected inductive test sets (%). Inductive setting Dataset Entity overlap Relation overlap Entity-inductive FB15k-237-v1 100.00 — FB15k-237-v2 96.98 — FB15k-237-v3 98.57 — FB15k-237-v4 98.88 — WN18R-v1 83.92 — WN18R-v2 81.41 — WN18R-v3 71.18 — WN18R-v4 82.03 — Fully inductive FB-25 97.34 97.45 FB-50 98.25 97.66 FB-75 95.45 97.35 FB-100 95.78 100.00 Note: Entity and relation overlap indicate the percentages of distinct entities and relations in the inductive test set that appear in GraphOracle’s pretraining data. GraphOracle’s released data loader constructs training facts from train.txt without reading facts.txt, so overlap may be below 100%. “—” denotes unreported relation overlap in the entity-inductive setting, which uses the training relation vocabulary. To eliminate the effects of this data overlap, we strictly follow the official GraphOracle [10] implementation(https://github.com/EnjunDu/GraphOracle) and adapt its data loading, training, and testing procedures to the entity-inductive protocol introduced by GraIL [28] and the fully inductive protocol introduced by InGram [19]. Specifically, consistent with the other baselines, GraphOracle [10] is trained independently on the designated training graph of each benchmark, with model selection based on the corresponding validation set. During testing, model parameters are fixed, observed facts in the corresponding inference graph are used for message passing, and prediction metrics are computed according to the evaluation procedure in Section 4.1. 4.3 Main Results Metric Models WN18R FB15k-237 NELL-995 V1 V2 V3 V4 V1 V2 V3 V4 V1 V2 V3 V4 MRR RuleN* 0.668 0.645 0.368 0.624 0.363 0.433 0.439 0.429 0.615 0.385 0.381 0.333 Neural LP* 0.649 0.635 0.361 0.628 0.325 0.389 0.400 0.396 0.610 0.361 0.367 0.261 DRUM* 0.666 0.646 0.380 0.627 0.333 0.395 0.402 0.410 0.628 0.365 0.375 0.273 GraIL* 0.627 0.625 0.323 0.553 0.279 0.276 0.251 0.227 0.481 0.297 0.322 0.262 CoMPILE* 0.577 0.578 0.308 0.548 0.287 0.276 0.262 0.213 0.330 0.248 0.319 0.229 NBFNet* 0.684 0.652 0.425 0.604 0.307 0.369 0.331 0.305 0.584 0.410 0.425 0.287 MorsE# 0.429 0.389 0.229 0.324 0.228 0.298 0.265 0.232 0.334 0.111 0.099 0.046 RED-GNN* 0.701 0.690 0.427 0.651 0.369 0.469 0.445 0.442 0.637 0.419 0.436 0.363 InGram# 0.279 0.235 0.114 0.230 0.192 0.223 0.188 0.162 0.672 0.219 0.278 0.203 Context Pooling* 0.708 0.694 0.425 0.648 0.383 0.463 0.447 0.427 0.634 0.430 0.426 0.382 GraphOracle 0.656 0.634 0.393 0.490 0.362 0.307 0.407 0.219 0.504 0.360 0.404 0.262 QORH 0.793 0.725 0.490 0.679 0.466 0.533 0.517 0.497 0.649 0.611 0.567 0.535 Hits@1 RuleN* 0.635 0.611 0.347 0.592 0.309 0.347 0.345 0.338 0.545 0.304 0.303 0.248 Neural LP* 0.592 0.575 0.304 0.583 0.243 0.286 0.309 0.289 0.500 0.249 0.267 0.137 DRUM* 0.613 0.595 0.330 0.586 0.247 0.284 0.308 0.309 0.500 0.271 0.262 0.163 GraIL* 0.554 0.542 0.278 0.443 0.205 0.202 0.165 0.143 0.425 0.199 0.224 0.153 CoMPILE* 0.473 0.485 0.258 0.473 0.208 0.178 0.166 0.134 0.105 0.156 0.226 0.159 NBFNet* 0.592 0.575 0.304 0.574 0.190 0.229 0.206 0.185 0.500 0.271 0.262 0.233 MorsE# 0.343 0.320 0.179 0.244 0.117 0.168 0.146 0.128 0.235 0.046 0.040 0.014 RED-GNN* 0.653 0.633 0.368 0.606 0.302 0.381 0.351 0.340 0.525 0.319 0.345 0.259 InGram# 0.146 0.125 0.056 0.100 0.093 0.127 0.106 0.087 0.570 0.113 0.189 0.125 Context Pooling* 0.660 0.637 0.365 0.603 0.316 0.368 0.358 0.330 0.517 0.329 0.324 0.278 GraphOracle 0.516 0.535 0.326 0.289 0.273 0.189 0.293 0.116 0.455 0.228 0.326 0.131 QORH 0.753 0.678 0.423 0.638 0.381 0.443 0.425 0.399 0.550 0.507 0.466 0.415 Hits@10 RuleN* 0.730 0.694 0.407 0.681 0.446 0.599 0.600 0.605 0.760 0.514 0.531 0.484 Neural LP* 0.772 0.749 0.476 0.706 0.468 0.586 0.571 0.593 0.871 0.564 0.576 0.539 DRUM* 0.777 0.747 0.477 0.702 0.474 0.595 0.571 0.593 0.873 0.540 0.577 0.531 GraIL* 0.760 0.776 0.409 0.687 0.429 0.424 0.424 0.389 0.565 0.496 0.518 0.506 CoMPILE* 0.747 0.743 0.406 0.670 0.439 0.457 0.449 0.358 0.575 0.446 0.515 0.421 NBFNet* 0.827 0.799 0.563 0.702 0.517 0.639 0.588 0.559 0.795 0.635 0.606 0.591 MorsE# 0.588 0.523 0.307 0.469 0.471 0.582 0.504 0.454 0.485 0.241 0.213 0.096 RED-GNN* 0.799 0.780 0.524 0.721 0.483 0.629 0.603 0.621 0.866 0.601 0.594 0.556 InGram# 0.524 0.449 0.225 0.456 0.373 0.426 0.340 0.311 0.845 0.423 0.464 0.365 Context Pooling# 0.790 0.785 0.527 0.723 0.473 0.640 0.589 0.592 0.866 0.636 0.619 0.564 GraphOracle 0.798 0.783 0.523 0.700 0.517 0.536 0.611 0.428 0.535 0.616 0.541 0.563 QORH 0.878 0.801 0.603 0.752 0.600 0.694 0.677 0.676 0.950 0.792 0.745 0.741 * Results taken directly from [26] or [10]. # Results reproduced using the code released in the respective official repositories, following the training and testing protocols for the entity-inductive setting. Results reproduced by adapting the code released in the respective official repositories to the entity-inductive training and testing protocols, with modifications to the data loading, training, and evaluation procedures. See the Baselines and Experiment Setup section for details. Table 2: Entity-inductive link prediction results on WN18R, FB15k-237, and NELL-995. Bold and underlined values indicate the best and second-best results, respectively. Model FB-100 FB-75 FB-50 FB-25 MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 CompGCN* 0.015 0.008 0.025 0.013 0.000 0.026 0.004 0.002 0.006 0.003 0.000 0.004 NodePiece* 0.006 0.001 0.009 0.016 0.007 0.029 0.021 0.006 0.048 0.044 0.011 0.114 NeuralLP* 0.026 0.007 0.057 0.056 0.030 0.099 0.088 0.043 0.184 0.164 0.098 0.309 DRUM* 0.034 0.011 0.077 0.065 0.034 0.121 0.101 0.061 0.191 0.175 0.109 0.320 BLP* 0.017 0.004 0.035 0.047 0.024 0.085 0.078 0.037 0.156 0.107 0.053 0.212 QBLP* 0.013 0.003 0.026 0.041 0.017 0.084 0.071 0.030 0.147 0.104 0.043 0.226 NBFNet* 0.072 0.026 0.154 0.089 0.048 0.166 0.130 0.071 0.259 0.224 0.137 0.410 RED-GNN* 0.121 0.053 0.263 0.107 0.057 0.201 0.129 0.072 0.251 0.145 0.077 0.284 RAILD* 0.031 0.016 0.048 – – – – – – – – – INGRAM* 0.223 0.146 0.371 0.189 0.119 0.325 0.117 0.067 0.218 0.133 0.067 0.271 Context Pooling# 0.146 0.056 0.323 0.128 0.074 0.242 0.144 0.069 0.307 0.235 0.142 0.425 TARGI* 0.253 0.172 0.429 – – – 0.159 0.088 0.307 – – – GraphOracle 0.377 0.277 0.573 0.315 0.215 0.510 0.190 0.107 0.365 0.276 0.164 0.513 QORH 0.456 0.358 0.651 0.401 0.295 0.597 0.322 0.224 0.522 0.376 0.255 0.625 * Results are taken directly from [19], [10], or [9]. # Results are reproduced using the official code under the training and evaluation protocols for the fully inductive setting. – The corresponding result is not available. Results are reproduced using the official code, with the data loading, training, and evaluation procedures adapted to the fully inductive training and evaluation protocols. See the Baselines and Experiment Setup section for details. Table 3: Performance comparison on FB-100, FB-75, FB-50, and FB-25 under the fully inductive setting. The best and second-best results are highlighted in bold and underlined, respectively. Model NL-100 NL-75 NL-50 NL-25 MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 GraIL* 0.135 0.114 0.173 0.096 0.056 0.205 0.162 0.104 0.288 0.216 0.160 0.366 CoMPILE* 0.123 0.071 0.209 0.178 0.093 0.361 0.194 0.125 0.330 0.189 0.115 0.324 SNRI* 0.042 0.029 0.064 0.088 0.040 0.177 0.130 0.095 0.187 0.190 0.140 0.270 INDIGO* 0.160 0.109 0.247 0.121 0.098 0.156 0.167 0.134 0.217 0.166 0.134 0.206 RMPI* 0.220 0.136 0.376 0.138 0.061 0.275 0.185 0.109 0.307 0.213 0.130 0.329 CompGCN* 0.008 0.001 0.014 0.014 0.003 0.025 0.003 0.000 0.005 0.006 0.000 0.010 NodePiece* 0.012 0.004 0.018 0.042 0.020 0.081 0.037 0.013 0.079 0.098 0.057 0.166 NeuralLP* 0.084 0.035 0.181 0.117 0.048 0.273 0.101 0.064 0.190 0.148 0.101 0.271 DRUM* 0.076 0.044 0.138 0.152 0.072 0.313 0.107 0.070 0.193 0.161 0.119 0.264 BLP* 0.019 0.006 0.037 0.051 0.012 0.120 0.041 0.011 0.093 0.049 0.024 0.095 QBLP* 0.004 0.000 0.003 0.040 0.007 0.095 0.048 0.020 0.097 0.073 0.027 0.151 NBFNet* 0.096 0.032 0.199 0.137 0.077 0.255 0.225 0.161 0.346 0.283 0.224 0.417 RED-GNN* 0.212 0.114 0.385 0.203 0.129 0.353 0.179 0.115 0.280 0.214 0.166 0.266 RAILD* 0.018 0.005 0.037 – – – – – – – – – INGRAM* 0.309 0.212 0.506 0.261 0.167 0.464 0.281 0.193 0.453 0.334 0.241 0.501 Context Pooling# 0.219 0.138 0.370 0.180 0.099 0.336 0.226 0.146 0.363 0.231 0.170 0.307 TARGI* 0.314 0.230 0.489 – – – 0.314 0.207 0.533 – – – GraphOracle 0.247 0.149 0.435 0.244 0.155 0.424 0.255 0.169 0.420 0.261 0.173 0.400 QORH 0.462 0.363 0.644 0.336 0.245 0.536 0.380 0.303 0.519 0.365 0.294 0.475 * Results are taken directly from [19], [10], or [9]. # Results are reproduced using the official code under the training and evaluation protocols for the fully inductive setting. – The corresponding result is not available. Results are reproduced using the official code, with the data loading, training, and evaluation procedures adapted to the fully inductive training and evaluation protocols. See the Baselines and Experiment Setup section for details. Table 4: Performance comparison on NELL-100, NELL-75, NELL-50, and NELL-25 under the fully inductive setting. The best and second-best results are highlighted in bold and underlined, respectively. Model WK-100 WK-75 WK-50 WK-25 MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 CompGCN* 0.003 0.000 0.009 0.015 0.003 0.028 0.003 0.001 0.002 0.009 0.000 0.020 NodePiece* 0.007 0.002 0.018 0.021 0.003 0.052 0.008 0.002 0.013 0.053 0.019 0.122 NeuralLP* 0.009 0.005 0.016 0.020 0.004 0.054 0.025 0.007 0.054 0.068 0.046 0.104 DRUM* 0.010 0.004 0.019 0.020 0.007 0.043 0.017 0.002 0.046 0.064 0.035 0.116 BLP* 0.012 0.003 0.025 0.043 0.016 0.089 0.041 0.013 0.092 0.125 0.055 0.283 QBLP* 0.012 0.003 0.025 0.044 0.016 0.091 0.035 0.011 0.080 0.116 0.042 0.294 NBFNet* 0.014 0.005 0.026 0.072 0.028 0.172 0.062 0.036 0.105 0.154 0.092 0.301 RED-GNN* 0.096 0.070 0.136 0.172 0.110 0.290 0.058 0.033 0.093 0.170 0.111 0.263 RAILD* 0.026 0.010 0.052 – – – – – – – – – INGRAM* 0.107 0.072 0.169 0.247 0.179 0.362 0.068 0.034 0.135 0.186 0.124 0.309 Context Pooling# 0.117 0.082 0.185 0.181 0.100 0.322 0.032 0.011 0.065 0.151 0.078 0.282 GraphOracle 0.139 0.097 0.231 0.204 0.123 0.371 0.057 0.036 0.096 0.132 0.050 0.278 QORH 0.181 0.128 0.282 0.375 0.291 0.513 0.135 0.080 0.243 0.276 0.195 0.429 * Results are taken directly from [19] or [10]. # Results are reproduced using the official code under the training and evaluation protocols for the fully inductive setting. – The corresponding result is not available. Results are reproduced using the official code, with the data loading, training, and evaluation procedures adapted to the fully inductive training and evaluation protocols. See the Baselines and Experiment Setup section for details. Table 5: Performance comparison on WK-100, WK-75, WK-50, and WK-25 under the fully inductive setting. The best and second-best results are highlighted in bold and underlined, respectively. Tables 2, 3, 4, and 5 report the comparative results of QORH and the baselines on entity-inductive and fully inductive link prediction tasks. As shown in Table 2, QORH achieves the highest MRR and Hits@1 on 11 of the 12 entity-inductive datasets and the highest Hits@10 on all 12 datasets. For example, on FB15k-237-v1, QORH improves MRR from 0.383, achieved by Context Pooling [26], to 0.466, corresponding to a relative improvement of 21.67%. This result demonstrates its performance advantage over existing query-aware graph reasoning methods. Tables 3, 4, 5 present the fully inductive results for the FB, NL, and WK families, respectively. QORH achieves the highest MRR and Hits@1 on all 12 fully inductive datasets and the highest Hits@10 on 10 of them. In particular, on FB-100, NL-100, and WK-100, both the entity sets and the relation sets are completely disjoint between the training and inference graphs. This entity- and relation-disjoint setting requires the model to generalize simultaneously to unseen entities and relations, making it more challenging. On these three datasets, QORH achieves MRR scores of 0.456, 0.462, and 0.181, respectively, outperforming the best baseline on each dataset by 20.95%, 47.13%, and 30.22%. These results demonstrate that QORH can effectively exploit structural information in the inference graph to predict missing links even when no entities or relations are shared between training and inference, further supporting its inductive generalization capability under simultaneous changes in entities and relations. 4.4 Ablation Studies Dataset Version QORH w/o RHE w/o RS MRR H@1 H@10 MRR H@1 H@10 MRR H@1 H@10 WN18R v1 0.793 0.753 0.878 0.737 0.681 0.843 0.738 0.665 0.859 v2 0.725 0.678 0.801 0.676 0.602 0.793 0.693 0.629 0.801 v3 0.490 0.423 0.603 0.453 0.385 0.569 0.454 0.395 0.564 v4 0.679 0.638 0.752 0.128 0.057 0.280 0.627 0.560 0.735 FB15k-237 v1 0.466 0.381 0.600 0.454 0.373 0.573 0.454 0.378 0.571 v2 0.533 0.443 0.694 0.508 0.409 0.686 0.499 0.384 0.694 v3 0.517 0.425 0.677 0.495 0.395 0.663 0.500 0.402 0.660 v4 0.497 0.399 0.676 0.260 0.154 0.483 0.478 0.375 0.670 NELL-995 v1 0.649 0.550 0.950 0.573 0.505 0.780 0.679 0.535 0.945 v2 0.611 0.507 0.792 0.489 0.374 0.704 0.597 0.498 0.766 v3 0.567 0.466 0.745 0.546 0.453 0.712 0.549 0.454 0.706 v4 0.535 0.415 0.741 0.243 0.186 0.350 0.358 0.266 0.546 Macro-average 0.588 0.506 0.742 0.463 0.381 0.620 0.552 0.462 0.710 • Notes. w/o RHE and w/o RS denote QORH variants without rule hypergraph enhancement and learnable rule selection, respectively. H@1 and H@10 denote Hits@1 and Hits@10. Macro-average is the unweighted mean over the 12 dataset splits. For each split and metric, the best result across the three variants is shown in bold. Table 6: Ablation results on the v1–v4 splits of WN18R, FB15k-237, and NELL-995 under the entity-inductive setting. The best results are highlighted in bold. To investigate the contributions of ordered rule hypergraph enhancement and rule selection, we conduct ablation studies on the 12 entity-inductive datasets using two variants. QORH w/o RHE removes the entire rule hypergraph enhancement module while retaining the base relation encoding and entity-level reasoning. QORH w/o RS removes the rule selection module and uses all candidate rules for hypergraph enhancement while retaining ordered rule encoding and hypergraph message passing. Detailed results are reported in Table 6, where the averages are computed as the unweighted means across the 12 dataset variants. Removing rule hypergraph enhancement degrades all three metrics on all 12 datasets. Average MRR, Hits@1, and Hits@10 decrease from 0.5885, 0.5064, and 0.7423 to 0.4634, 0.3812, and 0.6195, respectively, with average MRR dropping by 21.25% relative to the full model. These results demonstrate the effectiveness of rule hypergraph enhancement for inductive reasoning. The base relation graph captures pairwise dependencies but omits higher-order joint information involving multiple relations. Removing rule selection reduces average MRR, Hits@1, and Hits@10 to 0.5521, 0.4617, and 0.7095, corresponding to relative decreases of 6.17%, 8.83%, and 4.41% compared with the full model. These results indicate that directly incorporating all candidate rules does not yield consistent performance gains. This trend is consistent with the rationale for selecting rules based on confidence, coverage, rule length, and support, indicating that rule selection improves the usefulness of the incorporated evidence. The ablation results show that rule hypergraph enhancement and rule selection serve distinct roles: the ordered rule hypergraph provides information complementary to the base relation encoding, while rule selection further improves the utilization of this evidence. 4.5 Hyperparameter Sensitivity Analysis To assess the sensitivity of the ordered rule hypergraph module to its key hyperparameters, we examine the maximum number of rules per query relation K and the maximum rule-body length LmaxL_ in both entity-inductive and fully inductive settings. With K∈1,2,3,4,5,6,7K∈\1,2,3,4,5,6,7\ and Lmax∈2,3L_ ∈\2,3\, we compare 14 parameter combinations on each dataset. Figure 4: MRR of hyperparameter combination across entity-inductive datasets. Figure 5: Hyperparameter sensitivity summary on entity-inductive Datasets. Figure 6: MRR of hyperparameter combination across fully inductive datasets. Figure 7: Hyperparameter sensitivity summary on fully inductive Datasets. The effect of rule length varies across datasets. As shown in Figure 6, in the fully inductive setting, Lmax=3L_ =3 yields modest improvements over Lmax=2L_ =2 on FB-25, FB-50, and WK-100, with a more pronounced improvement on NL-100. As shown in Figure 4, in the entity-inductive setting, Lmax=3L_ =3 provides slight gains on WN18R-v3 and FB15k-237-v2 and a more substantial gain on NELL-995-v4. Accordingly, we use Lmax=3L_ =3 for these datasets and Lmax=2L_ =2 for the remaining datasets. As shown in Figures 5 and 7, performance varies only slightly across different values of K in the fully inductive setting, indicating that the model is relatively insensitive to this hyperparameter. Across both inductive settings, K=4K=4 provides consistently robust performance across datasets. We therefore set K=4K=4 for all datasets. All QORH results reported in Section 4.3 use these hyperparameter configurations. 5 Conclusin We propose QORH, a query-specific ordered rule hypergraph method, to address the difficulty of preserving complete rule composition information through pairwise relational dependencies in inductive knowledge graph link prediction. Conditioned on the query relation, QORH jointly encodes rule heads, ordered rule bodies, and statistical evidence as hyperedges. Through learnable rule selection and role-aware relation–hyperedge–relation propagation, it incorporates joint dependencies among multiple relations into relation representations, which subsequently guide entity-level reasoning. Extensive experiments in both entity-inductive and fully inductive settings show that QORH substantially outperforms existing state-of-the-art baselines, demonstrating its effectiveness and robustness. In future work, we will explore joint modeling of rule structures and textual semantics, investigate rule generation and selection assisted by large language models, and extend ordered rule hypergraphs to a broader range of structured reasoning tasks. References [1] M. Ali, M. Berrendorf, M. Galkin, V. Thost, T. Ma, V. Tresp, and J. Lehmann (2021) Improving Inductive Link Prediction Using Hyper-relational Facts. In The Semantic Web – ISWC 2021, A. Hotho, E. Blomqvist, S. Dietze, A. Fokoue, Y. Ding, P. Barnaghi, A. Haller, M. Dragoni, and H. Alani (Eds.), Cham, p. 74–92. External Links: Document, ISBN 978-3-030-88361-4 Cited by: item 4. [2] F. Belleau, M. Nolin, N. Tourigny, P. Rigault, and J. Morissette (2008) Bio2RDF: Towards a mashup to build bioinformatics knowledge systems. Journal of Biomedical Informatics 41 (5), p. 706–716. External Links: ISSN 1532-0464, Document Cited by: §1. [3] A. Bordes, S. Chopra, and J. Weston (2014) Question Answering with Subgraph Embeddings. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), A. Moschitti, B. Pang, and W. Daelemans (Eds.), Doha, Qatar, p. 615–620. External Links: Document Cited by: §1. [4] A. Bordes, N. Usunier, A. Garcia-Duran, J. Weston, and O. Yakhnenko (2013) Translating Embeddings for Modeling Multi-relational Data. In Advances in Neural Information Processing Systems, Vol. 26. Cited by: §1. [5] J. Chen, H. He, F. Wu, and J. Wang (2021) Topology-Aware Correlations Between Relations for Inductive Link Prediction in Knowledge Graphs. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 35, p. 6271–6278. External Links: Document Cited by: §1, §2.1. [6] M. Chen, W. Zhang, Y. Zhu, H. Zhou, Z. Yuan, C. Xu, and H. Chen (2022) Meta-Knowledge Transfer for Inductive Knowledge Graph Embedding. In Proceedings of the 45th International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR ’22, New York, NY, USA, p. 927–937. External Links: Document, ISBN 978-1-4503-8732-3 Cited by: §1, §2.1, item 3, §4.1. [7] D. Daza, M. Cochez, and P. Groth (2021) Inductive Entity Representations from Text via Link Prediction. In Proceedings of the Web Conference 2021, W ’21, New York, NY, USA, p. 798–808. External Links: Document, ISBN 978-1-4503-8312-7 Cited by: item 4. [8] T. Dettmers, P. Minervini, P. Stenetorp, and S. Riedel (2018) Convolutional 2D knowledge graph embeddings. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence and Thirtieth Innovative Applications of Artificial Intelligence Conference and Eighth AAAI Symposium on Educational Advances in Artificial Intelligence, AAAI’18/IAAI’18/EAAI’18, New Orleans, Louisiana, USA, p. 1811–1818. External Links: ISBN 978-1-57735-800-8 Cited by: §2.2, §4.1, §4.2. [9] L. Ding, L. Huang, Z. Yu, D. Jin, and D. He (2025) Towards Global-Topology Relation Graph for Inductive Knowledge Graph Completion. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 39, p. 11581–11589. External Links: Document Cited by: §1, §1, §2.2, item 5, item *, item *. [10] E. Du, S. Liu, and Y. Zhang (2026) GraphOracle: Efficient Fully-Inductive Knowledge Graph Reasoning via Relation-Dependency Graphs. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 40, p. 19055–19063. External Links: ISSN 2374-3468, 2159-5399, Document Cited by: §1, §1, §1, §2.2, §2.2, §3.2, §3.2, item 5, item *, item *, item *, item *, §4.2, §4.2. [11] B. Fatemi, P. Taslakian, D. Vazquez, and D. Poole (2021) Knowledge Hypergraph Embedding Meets Relational Algebra. arXiv. External Links: 2102.09557, Document Cited by: §2.3. [12] Y. Feng, H. You, Z. Zhang, R. Ji, and Y. Gao (2019) Hypergraph Neural Networks. arXiv. External Links: 1809.09401, Document Cited by: §2.3. [13] M. Galkin, E. Denis, J. Wu, and W. L. Hamilton (2021) NodePiece: Compositional and Parameter-Efficient Representations of Large Knowledge Graphs. In International Conference on Learning Representations, Cited by: item 3. [14] M. Galkin, P. Trivedi, G. Maheshwari, R. Usbeck, and J. Lehmann (2020) Message Passing for Hyper-Relational Knowledge Graphs. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP), B. Webber, T. Cohn, Y. He, and Y. Liu (Eds.), Online, p. 7346–7359. External Links: Document Cited by: §2.3. [15] M. Galkin, X. Yuan, H. Mostafa, J. Tang, and Z. Zhu (2024) Towards Foundation Models for Knowledge Graph Reasoning. International Conference on Learning Representations 2024, p. 31598–31619. Cited by: §1, §1, §2.2, §2.2, §3.2. [16] Y. Geng, J. Chen, J. Z. Pan, M. Chen, S. Jiang, W. Zhang, and H. Chen (2023) Relational Message Passing for Fully Inductive Knowledge Graph Completion. In 2023 IEEE 39th International Conference on Data Engineering (ICDE), p. 1221–1233. External Links: ISSN 2375-026X, Document Cited by: §1, §2.2, item 5. [17] G. A. Gesese, https://orcid.org/0000-0003-3807-7145, View Profile, H. Sack, https://orcid.org/0000-0001-7069-9804, View Profile, M. Alam, https://orcid.org/0000-0002-7867-6612, and View Profile (2022) RAILD: Towards Leveraging Relation Features for Inductive Link Prediction In Knowledge Graphs. In Proceedings of the 11th International Joint Conference on Knowledge Graphs, ACM Other Conferences, p. 82–90. External Links: Document, ISBN 978-1-4503-9987-6 Cited by: item 4, §4.1. [18] D. S. Himmelstein, A. Lizee, C. Hessler, L. Brueggeman, S. L. Chen, D. Hadley, A. Green, P. Khankhanian, and S. E. Baranzini (2017) Systematic integration of biomedical knowledge prioritizes drugs for repurposing. eLife 6, p. e26726. External Links: ISSN 2050-084X, Document Cited by: §1. [19] J. Lee, C. Chung, and J. J. Whang (2023) INGRAM: inductive knowledge graph embedding via relation graphs. In Proceedings of the 40th International Conference on Machine Learning, ICML’23, Vol. 202, Honolulu, Hawaii, USA, p. 18796–18809. Cited by: §1, §1, §1, §2.2, §2.2, §2.2, §3.2, §3.6, item 5, item *, item *, item *, §4.1, §4.2. [20] S. Liu, B. Grau, I. Horrocks, and E. Kostylev (2021) INDIGO: GNN-Based Inductive Knowledge Graph Completion Using Pair-Wise Encoding. In Advances in Neural Information Processing Systems, Vol. 34, p. 2034–2045. Cited by: item 2. [21] W. Liu, P. Zhou, Z. Zhao, Z. Wang, Q. Ju, H. Deng, and P. Wang (2020) K-BERT: Enabling Language Representation with Knowledge Graph. Proceedings of the AAAI Conference on Artificial Intelligence 34 (03), p. 2901–2908. External Links: ISSN 2374-3468, Document Cited by: §1. [22] S. Mai, S. Zheng, Y. Yang, and H. Hu (2021) Communicative Message Passing for Inductive Relation Reasoning. Proceedings of the AAAI Conference on Artificial Intelligence 35 (5), p. 4294–4302. External Links: ISSN 2374-3468, Document Cited by: item 2. [23] C. Meilicke, M. Fink, Y. Wang, D. Ruffinelli, R. Gemulla, and H. Stuckenschmidt (2018) Fine-Grained Evaluation of Rule- and Embedding-Based Systems for Knowledge Graph Completion. In The Semantic Web – ISWC 2018, D. Vrandečić, K. Bontcheva, M. C. Suárez-Figueroa, V. Presutti, I. Celino, M. Sabou, L. Kaffee, and E. Simperl (Eds.), Cham, p. 3–20. External Links: Document, ISBN 978-3-030-00671-6 Cited by: item 1. [24] M. Qu, J. Chen, L. Xhonneux, Y. Bengio, and J. Tang (2021) RNNLogic: Learning Logic Rules for Reasoning on Knowledge Graphs. In International Conference on Learning Representations, Cited by: §2.1. [25] A. Sadeghian, M. Armandpour, P. Ding, and D. Z. Wang (2019) DRUM: End-To-End Differentiable Rule Mining On Knowledge Graphs. arXiv. External Links: 1911.00055, Document Cited by: §2.1, item 1. [26] Z. Su, D. Wang, and C. Miao (2025) Context Pooling: Query-specific Graph Pooling for Generic Inductive Link Prediction in Knowledge Graphs. In Proceedings of the 31st ACM SIGKDD Conference on Knowledge Discovery and Data Mining V.2, KDD ’25, New York, NY, USA, p. 2680–2689. External Links: Document, ISBN 979-8-4007-1454-2 Cited by: §1, §2.1, item 2, item *, §4.3. [27] Z. Sun, Z. Deng, J. Nie, and J. Tang (2018) RotatE: Knowledge Graph Embedding by Relational Rotation in Complex Space. In International Conference on Learning Representations, Cited by: §1. [28] K. K. Teru, E. G. Denis, and W. L. Hamilton (2020) Inductive relation prediction by subgraph reasoning. In Proceedings of the 37th International Conference on Machine Learning, ICML’20, Vol. 119, p. 9448–9457. Cited by: §1, §1, §2.1, §2.2, §2.2, §3.6, item 2, §4.1, §4.1, §4.2. [29] K. Toutanova and D. Chen (2015) Observed versus latent features for knowledge base and text inference. In Proceedings of the 3rd Workshop on Continuous Vector Space Models and Their Compositionality, A. Allauzen, E. Grefenstette, K. M. Hermann, H. Larochelle, and S. W. Yih (Eds.), Beijing, China, p. 57–66. External Links: Document Cited by: §2.2, §4.1, §4.1, §4.2. [30] T. Trouillon, J. Welbl, S. Riedel, E. Gaussier, and G. Bouchard (2016) Complex Embeddings for Simple Link Prediction. In Proceedings of The 33rd International Conference on Machine Learning, p. 2071–2080. External Links: ISSN 1938-7228 Cited by: §1, §2.1. [31] S. Vashishth, S. Sanyal, V. Nitin, and P. Talukdar (2020) Composition-based Multi-Relational Graph Convolutional Networks. In Eighth International Conference on Learning Representations, Cited by: item 3. [32] H. Wang, F. Zhang, J. Wang, M. Zhao, W. Li, X. Xie, and M. Guo (2018) RippleNet: Propagating User Preferences on the Knowledge Graph for Recommender Systems. In Proceedings of the 27th ACM International Conference on Information and Knowledge Management, CIKM ’18, New York, NY, USA, p. 417–426. External Links: Document, ISBN 978-1-4503-6014-2 Cited by: §1. [33] X. Wang, X. He, Y. Cao, M. Liu, and T. Chua (2019) KGAT: Knowledge Graph Attention Network for Recommendation. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD ’19, New York, NY, USA, p. 950–958. External Links: Document, ISBN 978-1-4503-6201-6 Cited by: §1. [34] W. Xiong, T. Hoang, and W. Y. Wang (2017) DeepPath: A Reinforcement Learning Method for Knowledge Graph Reasoning. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, M. Palmer, R. Hwa, and S. Riedel (Eds.), Copenhagen, Denmark, p. 564–573. External Links: Document Cited by: §4.1, §4.1. [35] X. Xu, P. Zhang, Y. He, C. Chao, and C. Yan (2022) Subgraph Neighboring Relations Infomax for Inductive Link Prediction on Knowledge Graphs. In Thirty-First International Joint Conference on Artificial Intelligence, Vol. 3, p. 2341–2347. External Links: ISSN 1045-0823, Document Cited by: item 2. [36] B. Yang, W. Yih, X. He, J. Gao, and L. Deng (2014) Embedding Entities and Relations for Learning and Inference in Knowledge Bases. In International Conference on Learning Representations, Cited by: §1. [37] F. Yang, Z. Yang, and W. W. Cohen (2017) Differentiable Learning of Logical Rules for Knowledge Base Reasoning. In Advances in Neural Information Processing Systems, Vol. 30. Cited by: §2.1, item 1. [38] Y. Yang, X. Li, Y. Guan, H. Wang, C. Kong, and J. Jiang (2023) LHP: Logical hypergraph link prediction. Expert Systems with Applications 222, p. 119842. External Links: ISSN 0957-4174, Document Cited by: §2.3. [39] W. Yih, M. Chang, X. He, and J. Gao (2015) Semantic Parsing via Staged Query Graph Generation: Question Answering with Knowledge Base. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), C. Zong and M. Strube (Eds.), Beijing, China, p. 1321–1331. External Links: Document Cited by: §1. [40] Y. Zhang and Q. Yao (2022) Knowledge Graph Reasoning with Relational Digraph. In Proceedings of the ACM Web Conference 2022, W ’22, New York, NY, USA, p. 912–924. External Links: Document, ISBN 978-1-4503-9096-5 Cited by: §2.1, item 2. [41] Z. Zhang, X. Han, Z. Liu, X. Jiang, M. Sun, and Q. Liu (2019) ERNIE: Enhanced Language Representation with Informative Entities. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, A. Korhonen, D. Traum, and L. Màrquez (Eds.), Florence, Italy, p. 1441–1451. External Links: Document Cited by: §1. [42] Z. Zhu, Z. Zhang, L. Xhonneux, and J. Tang (2021) Neural bellman-ford networks: a general graph neural network framework for link prediction. In Proceedings of the 35th International Conference on Neural Information Processing Systems, NIPS ’21, Red Hook, NY, USA, p. 29476–29490. External Links: ISBN 978-1-7138-4539-3 Cited by: §2.1, item 2.