Set-Theoretic Foundations of Relational Data Model

• Set-Theoretic Foundations of the Relational Data Model is a framework that represents database tables as sets of attribute-indexed functions, enabling non-positional, many-sorted data structures.
• It defines relational algebra operations—such as selection, projection, and join—as standard set-theoretic operations, ensuring closure and logical consistency.
• Extensions incorporating bags, nulls, and formal verification illustrate the practical applicability of set theory to modern SQL semantics and schema constraints.

The set-theoretic foundations of the relational data model provide the formal apparatus for representing and manipulating database tables as mathematical relations. In these foundations, a relational table is interpreted as a finite set of tuples, each modeled as a total function from attribute names (or roles) to values in their associated domains. This approach generalizes the classical mathematical notion of n-ary (often positional) relations to many-sorted, attribute-indexed structures, giving rise to the algebraic and logical operations central to database theory, query languages, and formal verification. Recent work augments this basis with formal treatments of bags (multisets), nulls, and logic-based query semantics, all firmly rooted in set-theoretic and first-order axioms [0607039], (Mitroshin, 2012, Kelly et al., 2012, Mohamed et al., 2024).

1. Set-Theoretic Primitives for Relations

At its core, the relational model is built upon the basic primitives of set theory:

• Set: A collection of distinct values, with membership denoted $x \in S$.
• Cartesian Product: For sets $X$ and $Y$, $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$, and generalized to $I$-indexed families as $\prod_{i \in I} X_i$.
• Function: $f: X \to Y$ is a set of ordered pairs, uniquely associating each $x \in X$ to $f(x) \in Y$.
• Tuple as Function: A tuple $t$ over attributes $X$0 is modeled as $X$1 with $X$2—where $X$3 denotes the disjoint union.

An n-ary relation with attributes $X$4 is any subset $X$5, where $X$6 is the tuple-space over $X$7. This formulation enables referring to tuple components by attribute name, supporting unrestricted arities, heterogeneous domains, and non-positional indexing [0607039], (Kelly et al., 2012).

2. Operations of Relational Algebra as Set Operations

The classic operations of the relational algebra are interpreted as set-theoretic operators on these sets of attribute-indexed tuples. Fundamental operations are defined as follows [0607039], (Mitroshin, 2012, Kelly et al., 2012, Mohamed et al., 2024):

• Selection $X$8: Subset of $X$9 where predicate $Y$0 holds.

$Y$1

• Projection $Y$2: Restricts tuples to attributes $Y$3.

$Y$4

• Cartesian Product $Y$5: Combine tuples over disjoint attribute sets $Y$6, $Y$7.

$Y$8

• Set Union, Intersection, Difference: Standard set operations, requiring union-compatible schemas.

$Y$9

• Renaming $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$0: Apply attribute renaming $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$1.

$X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$2

• Natural Join $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$3: Combine tuples from $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$4 and $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$5 on shared attributes $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$6.

$X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$7

• Theta-Join, Equi-Join: Apply selection $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$8 over $X \times Y = \{ (x, y) \mid x \in X, y \in Y \}$9.

These operations compose into expressions (queries), preserving closure: every operation yields a relation over a well-defined set of attribute names and domains.

3. Algebraic Laws and Closure Properties

The set-theoretic nature directly enforces key algebraic identities and properties:

• Closure: All operations (selection, projection, join, product, union, difference, renaming) yield relations.
• Associativity and Commutativity: For union, intersection, and natural join (when defined).
• Distributivity: Selection and projection distribute over union; selection distributes over projection if predicates are attribute-independent.
• Idempotence: For suitable domains, $I$0, $I$1, and, for join, $I$2.
• Completeness and Consistency: All constructions are finite or first-order in nature; paradoxes such as Russell's do not arise within these operationally closed fragments (Mitroshin, 2012).

4. Role of Attribute Indexing and Non-Positional Tuples

The principal set-theoretic innovation over classical (positional, binary) relations is the indexing of tuple entries by attribute, not by position. This enables:

• Attribute Name Matching: Joins and selections on common attribute names, not just positional alignment, thereby facilitating schema evolution and query formulation.
• Many-Sorted Relations: Each attribute $I$3 maps to a separate domain $I$4, supporting heterogeneous schemas.
• Formal Account of Renaming: Attribute renaming is purely a bijection on the indexing set, with total preservation of tuple structure [0607039], (Kelly et al., 2012).

Codd’s original model relied on positional $I$5-ary tuples; subsequent set-theoretic reconstructions (e.g., Kelly & van Emden's ETR) formalize relations as sets of many-sorted, attribute-indexed functions (Kelly et al., 2012).

5. Logical Foundations and Predicate Calculus Semantics

Set-theoretic relational algebra operations correspond to logical formulas in first-order predicate calculus. Under denotational semantics:

• Atomic Formulas: Correspond to relations.
• Conjunction: Implemented as natural join.
• Existential Quantification: Realized as projection.
• Negation and Disjunction: Respect Boolean operations over relation-sets.

By interpreting open formulas as sets of tuples (assignment maps from variable names), query evaluation becomes a composition of set-theoretic operations, not a satisfaction relation on ground terms. This yields a sound and complete operational semantics for database queries as compositions of relational/algebraic primitives (Kelly et al., 2012).

6. Extensions: Bags, Nulls, and Formal Verification

Recent developments articulate set-theoretic relational foundations in the context of actual database features and verification requirements (Mohamed et al., 2024):

• Bags (Multisets): Finite “bag” sorts $I$6 introduce element multiplicities $I$7; set-operations are extended to multiset-union, etc., with set semantics recovered by restricting $I$8.
• Nullable Sorts: Model SQL NULL with $I$9 sorts, equipped with constructors $\prod_{i \in I} X_i$0, $\prod_{i \in I} X_i$1, and testers $\prod_{i \in I} X_i$2; all query operators are lifted to operate over nullable values, with SQL’s 3-valued logic encoded axiomatically.
• Formal Verification: Modern SMT-based tools (such as those in cvc5) encode SQL/Table semantics as first-order theories over set/bag/nullable operations, enabling automated verification of relational query equivalences and schema properties within the set-theoretic framework.

7. Relational Schema, Keys, and Constraints in Set Theory

A relational schema is formalized as a finite set $\prod_{i \in I} X_i$3 assigning attribute names to domains. Constraints are expressed as set-theoretic properties:

• Primary Keys: $\prod_{i \in I} X_i$4 is a key iff $\prod_{i \in I} X_i$5 is injective.
• Foreign Keys: Refer to attributes $\prod_{i \in I} X_i$6 in $\prod_{i \in I} X_i$7, $\prod_{i \in I} X_i$8 in $\prod_{i \in I} X_i$9, for relations $f: X \to Y$0 and $f: X \to Y$1, as $f: X \to Y$2.

All such constraints are first-order, guaranteeing that schema integrity constraints remain both expressible and verifiable in the pure set-theoretic and first-order logical framework (Mitroshin, 2012).

---

The set-theoretic foundation thus provides a rigorous, uniform, and extensible base for the relational data model: relations are sets of attribute-indexed functions; all relational algebra operations are set-theoretic; logical semantics and schema constraints are reduced to set and function theory; and extensions to bags, nulls, and verification follow naturally from these primitives [0607039], (Mitroshin, 2012, Kelly et al., 2012, Mohamed et al., 2024).