Hybrid Relational Algebra (HRA)

• Hybrid Relational Algebra (HRA) is a framework that integrates traditional relational operations with embedding-based computation over knowledge hypergraphs.
• It implements core RA operators—renaming, projection, selection, union, and difference—as deterministic transformations in the embedding space.
• HRA bridges relational, linear, and graph-traversal methods to offer controlled compositional query semantics and expressive modeling of complex data.

Searching arXiv for the specified paper and closely related HRA formulations to ground the article. Hybrid Relational Algebra (HRA) denotes a class of algebraic formalisms that combine classical relational operations with additional computational structure while preserving compositional query semantics. In the literature represented here, HRA appears in several distinct but related senses: as embedding-space execution of primitive relational algebra on knowledge hypergraphs via ReAlE (Fatemi et al., 2021); as a unification of relational algebra and linear algebra through associative tables and three primitive operators in Lara (Hutchison et al., 2017); as a traversal algebra combining relational, path, and tensor operations for multi-relational graphs (Rodriguez et al., 2010); and as a hybrid RA–LA query model optimized under integrity constraints in HADAD (Alotaibi et al., 2021). A common theme is that symbolic operators remain explicit, but are extended into settings involving $n$-ary relations, matrices, paths, tensors, or learned representations.

1. Conceptual scope and definitions

The formulation most directly associated with the term in the supplied corpus is the one introduced through ReAlE in “Knowledge Hypergraph Embedding Meets Relational Algebra,” where HRA is realized as an embedding model that “scores $n$-ary hyperedges for link prediction” and “parameterizes the primitive operators of relational algebra (RA) directly in the embedding space” (Fatemi et al., 2021). In that setting, symbolic reasoning steps—renaming, projection, selection, union, and set difference—are executed by deterministic transformations of trainable embeddings, thereby coupling operator-level structure with sub-symbolic learning (Fatemi et al., 2021).

The underlying data structure is a knowledge hypergraph. Let $\mathcal{E}$ be a finite set of entities and $\mathcal{F}$ a finite set of relations, each relation $r \in \mathcal{F}$ having a fixed arity $|r| \in \mathbb{N}$. A tuple is a directed labeled hyperedge of the form $r(x_1,\ldots,x_n)$ with $n = |r|$ and $x_i \in \mathcal{E}$. A knowledge hypergraph consists of a subset $\tau' \subseteq \tau$ of observed true tuples, while ordinary knowledge graphs arise as the special case in which all arities equal $n$0 (Fatemi et al., 2021).

Within this HRA, the relational algebra fragment is deliberately restricted. The primitive operators studied are renaming $n$1, projection $n$2, selection $n$3, set union $n$4, and set difference $n$5 (Fatemi et al., 2021). By contrast, join $n$6, Cartesian product $n$7, and division $n$8 are explicitly outside the scope of the theoretical guarantees in that work (Fatemi et al., 2021). This bounded scope is central: the hybridization is not a full replacement for general relational algebra, but a controlled embedding of selected symbolic operators into a learnable model.

Other papers broaden the meaning of HRA. Lara proposes a common algebra for relational algebra and linear algebra, centered on associative tables and the operators Union, Join, and Ext, with Map, Agg, and Rename as derived forms (Hutchison et al., 2017). The multi-relational graph framework of Rodriguez defines an algebra “based on an $n$9-ary relational algebra, a concatenative single-relational path algebra, and a tensor-based multi-relational algebra,” thereby hybridizing relational selection/projection/join with path concatenation and regular-language constraints (Rodriguez et al., 2010). HADAD, in turn, treats hybrid RA–LA queries as expressions that freely mix relational operators and linear-algebra operators, then optimizes them through a relational model endowed with integrity constraints (Alotaibi et al., 2021). These variants suggest that “Hybrid Relational Algebra” is not a single canonical formalism, but a family of designs that extend RA while preserving an algebraic core.

2. ReAlE as an HRA over knowledge hypergraphs

ReAlE parameterizes relations and entities so that operator semantics can be compiled into embedding-space transformations. Each entity $\mathcal{E}$0 is embedded as a non-negative vector $\mathcal{E}$1. Each relation $\mathcal{E}$2 of arity $\mathcal{E}$3 is embedded as a matrix $\mathcal{E}$4, with one row per argument position; thus role semantics are encoded directly in row indices (Fatemi et al., 2021). The embedding dimension is partitioned into $\mathcal{E}$5 windows of size $\mathcal{E}$6, and each relation has a per-window bias $\mathcal{E}$7 (Fatemi et al., 2021).

The score of a tuple $\mathcal{E}$8 is

$\mathcal{E}$9

Within each window, the model sums position-specific entity–relation interactions, adds a relation-specific bias, applies a monotone, almost-everywhere differentiable nonlinearity $\mathcal{F}$0, and averages across windows (Fatemi et al., 2021). The paper’s interpretation is that the “rows-as-roles” representation distinguishes argument order, while windowing creates structured interactions beyond elementwise products and improves information flow (Fatemi et al., 2021).

This architecture underwrites the hybrid character of the model. Relational operators are not delegated to an external symbolic reasoner, nor are they merely approximated by downstream inference. Instead, they are realized as closed-form manipulations of the trainable parameters themselves. In this sense, the model operationalizes RA inside the representation space. A plausible implication is that ReAlE treats algebraic structure as an inductive bias over hypergraph completion rather than as a post hoc explanatory layer.

Variable arity is native to this formulation because relation matrices have $\mathcal{F}$1 rows. The same scoring scheme therefore applies to heterogeneous arities without reducing everything to the binary case (Fatemi et al., 2021). This is a major distinction from binary knowledge-graph embeddings: the algebraic constructions in ReAlE are defined directly for $\mathcal{F}$2-ary tuples.

3. Relational-algebra operators in embedding space

The defining contribution of the ReAlE-based HRA is that several primitive RA operations admit explicit embedding-space constructions (Fatemi et al., 2021). These constructions do not all yield exact logical equivalence: some produce equalities, whereas others guarantee only lower or upper bounds.

Operator mappings in ReAlE

Operator	Embedding-space construction	Guarantee
Renaming $\mathcal{F}$3	Row permutation with bias copy	Equality
Projection $\mathcal{F}$4	Copy retained rows, inflate bias	Inequality
Selection $\mathcal{F}$5	Row fusion or constant-dependent bias	Equality
Union $\mathcal{F}$6	Elementwise max of rows and biases	Lower bound
Difference $\mathcal{F}$7	Elementwise min with complemented parameters	Upper bound

Renaming is the cleanest case. Because argument positions correspond to explicit rows in the relation matrix, a role permutation is implemented by re-indexing rows. For a permutation $\mathcal{F}$8, the construction sets $\mathcal{F}$9 and $r \in \mathcal{F}$0, yielding

$r \in \mathcal{F}$1

This is an exact equality theorem (Fatemi et al., 2021).

Projection lowers arity by existentially quantifying away arguments. ReAlE cannot in general guarantee equality because multiple source tuples may project to the same target tuple. The construction copies the retained rows and increases the bias to upper-bound the unknown contribution of marginalized variables: $r \in \mathcal{F}$2 Under monotonicity of $r \in \mathcal{F}$3 and non-negativity of entity embeddings, this yields

$r \in \mathcal{F}$4

The semantics are therefore approximate in the direction appropriate for existential elimination (Fatemi et al., 2021).

Selection is treated in two equality-preserving forms. For attribute equality $r \in \mathcal{F}$5, the construction merges two rows by setting

$r \in \mathcal{F}$6

while copying the remaining rows and keeping the same biases, so that

$r \in \mathcal{F}$7

For equality to a constant $r \in \mathcal{F}$8, the model copies the first $r \in \mathcal{F}$9 rows and absorbs the fixed contribution of $|r| \in \mathbb{N}$0 into the per-window bias: $|r| \in \mathbb{N}$1 This again yields exact equality (Fatemi et al., 2021).

Set union is represented by elementwise maxima: $|r| \in \mathbb{N}$2 which guarantees

$|r| \in \mathbb{N}$3

Exact equality is not guaranteed in general because it depends on unknown dependence between the input relations (Fatemi et al., 2021).

Set difference is handled through a linear complement operator $|r| \in \mathbb{N}$4 such that $|r| \in \mathbb{N}$5. For sigmoid or tanh, $|r| \in \mathbb{N}$6 and the construction chooses

$|r| \in \mathbb{N}$7

which yields

$|r| \in \mathbb{N}$8

The direction of the bound reflects safe exclusion rather than exact extensional set semantics (Fatemi et al., 2021).

These results define the operational content of HRA in the ReAlE paper. Symbolic operators are “executed in the embedding space without external templates or logic engines,” while learning remains end-to-end (Fatemi et al., 2021).

4. Expressivity, guarantees, and limitations

A central theoretical result is that ReAlE is fully expressive. A model with parameters $|r| \in \mathbb{N}$9 and score $r(x_1,\ldots,x_n)$0 is fully expressive if, for any assignment of truth values to all tuples, there exists $r(x_1,\ldots,x_n)$1 separating true and false tuples (Fatemi et al., 2021). The constructive theorem states that if $r(x_1,\ldots,x_n)$2 is the number of true tuples and $r(x_1,\ldots,x_n)$3 is the maximum arity, then there exists a ReAlE model with $r(x_1,\ldots,x_n)$4 windows, window size $r(x_1,\ldots,x_n)$5, embedding dimension $r(x_1,\ldots,x_n)$6, and sigmoid nonlinearity such that $r(x_1,\ldots,x_n)$7 for all true tuples and $r(x_1,\ldots,x_n)$8 for all false tuples, with $r(x_1,\ldots,x_n)$9 (Fatemi et al., 2021).

The construction places non-overlapping blocks in entity and relation embeddings aligned to one true tuple per window, then uses biases to force separation through $n = |r|$0 (Fatemi et al., 2021). In the fuller proof sketch, the true-tuple window contributes $n = |r|$1, while all other windows contribute less than $n = |r|$2, so averaging separates true and false tuples cleanly (Fatemi et al., 2021). This is not merely an existence theorem about hypergraph completion; it is also the algebraic foundation for the HRA claim, because the representability of RA operators is meaningful only if the base model can already realize arbitrary tuple truth assignments.

The paper also establishes contrastive expressivity results. It proves that m-TransH, RAE, and NaLP are not fully expressive, whereas GETD is fully expressive but its memory/time grows exponentially with arity (Fatemi et al., 2021). HypE is fully expressive overall, but the paper proves that it cannot, in general, represent selection while retaining full expressivity; in particular, no parameterization exists ensuring

$n = |r|$3

for arbitrary entity embeddings (Fatemi et al., 2021). This comparison sharpens the specific role of ReAlE: it is not simply another hypergraph embedding, but one whose parameterization is compatible with a nontrivial RA fragment.

The limitations are equally explicit. The theoretical results cover renaming, projection, two forms of selection, union as a lower bound, and difference as an upper bound (Fatemi et al., 2021). Join, Cartesian product, and division are not addressed (Fatemi et al., 2021). Union and difference are not exact in the general case because they reflect unknown dependence between input relations (Fatemi et al., 2021). This means that the hybrid algebra is strongest for unary relational transformations and constrained binary set operations, but not yet a full algebra of multi-relation composition. A plausible implication is that extending HRA from per-tuple scoring to full RA programs would require mechanisms that synchronize variables across multiple tuples, especially for join-like operators.

5. Training, inference, and empirical behavior

ReAlE is trained with a softmax cross-entropy objective over a positive tuple and a set of negatives generated by corrupting one position at a time: $n = |r|$4 The implementation uses PyTorch with Adagrad optimizer and dropout, early stopping on validation MRR, embedding dimension $n = |r|$5, batch size $n = |r|$6, negative ratio $n = |r|$7, at most $n = |r|$8 epochs, learning rate in $n = |r|$9, and window size $x_i \in \mathcal{E}$0 (Fatemi et al., 2021). The nonlinearity $x_i \in \mathcal{E}$1 is chosen from $x_i \in \mathcal{E}$2; sigmoid performed best on JF17K and was used elsewhere (Fatemi et al., 2021).

For link prediction, the evaluation uses standard filtered ranking. A test tuple $x_i \in \mathcal{E}$3 is ranked against tuples formed by replacing one position at a time with all other entities, and Mean Reciprocal Rank (MRR) and Hits@$x_i \in \mathcal{E}$4 are reported (Fatemi et al., 2021). The RA operator evaluation is integrated into link prediction by constructing synthetic relations known to be RA compositions and measuring ranking accuracy on their tuples (Fatemi et al., 2021).

On real hypergraph datasets, ReAlE outperformed the baselines reported in the paper (Fatemi et al., 2021).

Dataset	ReAlE result	Baseline comparison
JF17K	MRR 0.530, Hits@10 0.677	HypE 0.494, G-MPNN 0.501, HSimplE 0.472, m-TransH 0.444
FB-AUTO	MRR 0.861, Hits@10 0.908	HypE 0.804, HSimplE 0.798, m-DistMult 0.784
m-FB15K	MRR 0.801, Hits@10 0.901	HypE 0.777, G-MPNN 0.779

To test RA-style compositionality, the paper introduces SYNTH-KHG, a synthetic knowledge hypergraph generated procedurally by an Erdős–Rényi-style process and then expanded recursively through RA primitives (Fatemi et al., 2021). For a relation with arity $x_i \in \mathcal{E}$5 and inclusion probability $x_i \in \mathcal{E}$6, the expected number of directed $x_i \in \mathcal{E}$7-ary hyperedges is

$x_i \in \mathcal{E}$8

and edges are sampled uniformly without replacement (Fatemi et al., 2021). RA compositions are then generated by repeatedly sampling an operator from $x_i \in \mathcal{E}$9renaming, projection, selection, union, difference$\tau' \subseteq \tau$0, applying it to one or two input tuples, and assigning a depth equal to one plus the maximum depth of the inputs (Fatemi et al., 2021).

On SYNTH-KHG, ReAlE achieved overall MRR $\tau' \subseteq \tau$1, compared with $\tau' \subseteq \tau$2 for HypE and $\tau' \subseteq \tau$3 for m-TransH (Fatemi et al., 2021). By last operation, the reported ReAlE MRRs were $\tau' \subseteq \tau$4 for renaming, $\tau' \subseteq \tau$5 for projection, $\tau' \subseteq \tau$6 for union, and $\tau' \subseteq \tau$7 for set difference; selection produced too few test tuples under the random split to report (Fatemi et al., 2021). By depth, the reported MRRs at depths $\tau' \subseteq \tau$8 were $\tau' \subseteq \tau$9, which the authors interpret as strong compositional generalization (Fatemi et al., 2021).

An ablation on window size found that, on JF17K with $n$00, the best MRR was obtained for $n$01, while too-small or too-large windows reduced performance (Fatemi et al., 2021). This suggests that the window decomposition is not merely a proof device, but an empirically relevant structural prior.

6. Broader HRA formulations and related lines of work

Although ReAlE provides the clearest instance of HRA as symbolic reasoning in embedding space, several other arXiv papers instantiate the broader idea of hybridizing relational algebra with additional computational regimes.

Lara and LaraDB define a minimalist algebra over associative tables with three operators—Union, Join, and Ext—sufficient to encode standard RA and standard LA in a uniform typed framework (Hutchison et al., 2017). The paper states that Lara is “more explicit than MapReduce but more general than RA or LA” (Hutchison et al., 2017). In this formulation, relational operators such as $n$02, $n$03, $n$04, $n$05, and aggregation are mapped into combinations of Union, Join, and Ext, while linear-algebra operators such as transpose, scalar multiplication, matrix–vector multiplication, and matrix–matrix multiplication are encoded in the same algebra (Hutchison et al., 2017). The HRA character here lies in semantic unification of discrete and numerical operations rather than in embeddings.

Rodriguez’s path algebra for multi-relational graphs hybridizes $n$06-ary relational algebra, concatenative path algebra, and tensor-based multi-relational algebra (Rodriguez et al., 2010). The core object is a multi-relational graph $n$07 with $n$08, and the algebra operates on path sets $n$09 using path concatenation, set union, concatenative join, selection and projection over edges, and regular-language closure (Rodriguez et al., 2010). The paper explicitly frames the algebra as combining relational operations with path-sensitive and tensorized graph reasoning.

HADAD treats hybrid queries as expressions mixing RA subexpressions, represented as conjunctive queries, with LA subexpressions, represented as uninterpreted relational predicates such as $n$10, $n$11, $n$12, and decomposition relations, all constrained by EGDs and TGDs encoding algebraic laws (Alotaibi et al., 2021). This common relational model allows pure RA rewrites, pure LA rewrites, cross-domain rewrites, and view-based rewriting over mixed workloads (Alotaibi et al., 2021). In that line, HRA is less an execution formalism than a semantic optimization framework.

These strands indicate at least three recurring interpretations of HRA:

• Embedding-centric HRA: symbolic RA operators compiled into learned representation space, as in ReAlE (Fatemi et al., 2021).
• RA–LA unification: one algebraic kernel covering relations, matrices, and associative tables, as in Lara (Hutchison et al., 2017).
• Relational-plus-structure algebras: RA fused with path, tensor, or graph-traversal semantics, as in the multi-relational path algebra (Rodriguez et al., 2010).

This plurality is not a contradiction. Rather, it suggests that HRA is best understood as an architectural principle: preserving algebraic composition while extending the universe of admissible objects and operators.

7. Significance, misconceptions, and open problems

A common misconception is that HRA is synonymous with “relational algebra plus machine learning.” The ReAlE case shows that this is too narrow: what makes the construction hybrid is not the presence of embeddings alone, but the fact that renaming, projection, selection, union, and difference are represented by deterministic operator-level transformations with formal guarantees (Fatemi et al., 2021). Conversely, the Lara and HADAD formulations show that HRA may involve no learned components at all, instead unifying RA with LA through typed associative tables or integrity-constrained relational encodings (Hutchison et al., 2017, Alotaibi et al., 2021).

Another misconception is that a hybrid algebra automatically subsumes full RA. In the ReAlE setting this is explicitly false: join, Cartesian product, and division remain outside the theoretical guarantees (Fatemi et al., 2021). In broader RA–LA frameworks, the challenge is different: although a wide range of operators can be encoded, optimization and execution may depend on side conditions such as identities, annihilators, finite support, monotonicity, or shape compatibility (Hutchison et al., 2017, Alotaibi et al., 2021).

The open problems are therefore structural rather than cosmetic. For ReAlE-style HRA, extending guarantees to joins and richer RA programs is unresolved (Fatemi et al., 2021). The paper notes that joins would require multi-relation composition and alignment of shared variables across tuples, beyond per-tuple scoring (Fatemi et al., 2021). For RA–LA unification frameworks, cost-based optimization across both domains remains an active issue; Lara identifies a full optimizer as future work, and HADAD addresses this partly through chase/backchase reasoning and sparsity-aware cost models (Hutchison et al., 2017, Alotaibi et al., 2021). More generally, exact semantics for operators like union and difference in learned settings remain incomplete when dependence between inputs is unknown (Fatemi et al., 2021).

In sum, Hybrid Relational Algebra is not a single settled calculus but a research direction that extends relational algebra into settings involving hypergraphs, matrices, paths, tensors, or learned representations without abandoning algebraic compositionality. ReAlE offers a particularly concrete and formal example: a fully expressive hypergraph embedding model in which a substantial subset of primitive RA is compiled into embedding-space operations with proofs and empirical validation (Fatemi et al., 2021). The broader literature shows that the same hybrid impulse also motivates unified algebras for RA and LA (Hutchison et al., 2017), relational-path-tensor graph reasoning (Rodriguez et al., 2010), and semantic optimization of mixed analytical workloads (Alotaibi et al., 2021).