Relational Semantics for Databases and Predicate Calculus

The relational data model requires a theory of relations in which tuples are not only many-sorted, but can also have indexes that are not necessarily numerical. In this paper we develop such a theory and define operations on relations that are adequate for database use. The operations are similar to those of Codd’s relational algebra, but differ in being based on a mathematically adequate theory of relations. The semantics of predicate calculus, being oriented toward the concept of satisfiability, is not suitable for relational databases. We develop an alternative semantics that assigns relations as meaning to formulas with free variables. This semantics makes the classical predicate calculus suitable as a query language for relational databases.

💡 Research Summary

The paper revisits the foundational definition of a relation in the relational data model and proposes a more general, mathematically rigorous theory that better fits the practical needs of modern databases. Traditional relational algebra, as introduced by Codd, treats an n‑ary relation as a subset of a Cartesian product S₀ × … × Sₙ₋₁, where the index set is implicitly the ordered list {0,…,n‑1}. This view assumes that columns are identified by numeric positions, that each column has a distinct domain, and that the ordering of columns is significant. In real‑world database systems, however, column identifiers are often non‑numeric names (role names), the same domain may appear in several columns, and the index set need not be a contiguous sequence of natural numbers.

To address these mismatches, the authors define a tuple as a function I → T, where I is an arbitrary set of indexes (which may be strings, symbols, or any identifiers) and T is a set of pairwise disjoint type sets. A tuple t maps each index i∈I to a value t(i) belonging to a specific type τ(i)∈T. This functional view of tuples yields several advantages: (1) indexes can be non‑numeric and non‑contiguous; (2) identical domains can be distinguished by attaching a role name to each occurrence; (3) the notion of a tuple’s signature τ (a function I → T) is formalized via a “sorting function” σ_T that maps each value to its type, allowing the authors to say that a tuple t is sorted by τ precisely when τ = σ_T ∘ t.

The paper then develops basic operations on functions—restriction, insertion, sum, composition—and lifts them to operations on tuples and relations. A pattern p is a tuple whose components are variables drawn from a set X, equipped with a typing function ϕ : X → T. A concrete tuple t matches pattern p if there exists a substitution function s : X → ⋃T such that t = s ∘ p. This matching relation mirrors the variable binding mechanism of first‑order logic, enabling the authors to interpret any formula with free variables as a set of tuples that satisfy the formula. In other words, the semantics of a formula φ(x₁,…,x_k) is defined as the relation ⟦φ⟧ ⊆ I → ⋃T consisting of all tuples that make φ true.

With this semantics in place, the authors reconstruct the classic relational‑algebra operators:

• Projection (π) is realized as the restriction of a tuple’s function to a subset I₀ ⊂ I, i.e., π_{I₀}(r) = { t ↓ I₀ | t ∈ r }.
• Join (⋈) combines two relations r₁ ⊆ I₁ → ⋃T and r₂ ⊆ I₂ → ⋃T by first identifying the common index set I₁ ∩ I₂, then merging tuples whose values agree on that intersection. The merged tuple is the sum of the two underlying functions, yielding a new tuple over I₁ ∪ I₂.
• Filtering (σ_ψ) is a new operation that selects from a relation r only those tuples that satisfy a given logical condition ψ. Because ψ can be any first‑order formula, σ_ψ generalizes the traditional selection operator and integrates seamlessly with the logical semantics introduced earlier.

All these operators are defined purely set‑theoretically; no additional algebraic axioms are required. The authors prove that the resulting operator family is closed under composition, satisfies associativity where appropriate, and respects the natural correspondence with logical connectives (conjunction corresponds to join, disjunction to union, negation to set complement, etc.).

The crucial contribution lies in linking this operator suite to the alternative semantics for predicate calculus proposed in the paper. Traditional predicate‑calculus semantics focuses on satisfiability—whether a closed formula is true in a structure—making it ill‑suited for database queries that need to return concrete data. By interpreting formulas with free variables as relations, the authors turn logical entailment into a data‑retrieval mechanism: evaluating a query expressed as a first‑order formula directly yields the set of result tuples. Consequently, the relational model and first‑order logic become isomorphic: every relational‑algebra expression can be translated into an equivalent logical formula and vice versa, preserving meaning under the new semantics.

The paper also critiques Codd’s original treatment of “relationships” versus “relations.” Codd suggested that when domains repeat, users should think in terms of “relationships” with role‑qualified column names, effectively abandoning the pure mathematical notion of a relation. The authors argue that a single, uniform definition—relations as sets of function‑based tuples with role‑qualified signatures—eliminates the need for a separate “relationship” concept and restores the mathematical elegance of the model.

In summary, the authors present:

1. A function‑based definition of tuples and relations that accommodates arbitrary index sets and role‑qualified domains.
2. A pattern‑matching framework that captures variable binding and enables a relational interpretation of first‑order formulas.
3. Generalized relational‑algebra operators (projection, join, filtering) defined set‑theoretically and aligned with logical connectives.
4. An alternative semantics for predicate calculus where formulas denote relations, making the calculus a natural query language for relational databases.
5. A unified view that subsumes Codd’s “relationships” under a single, mathematically sound notion of relation.

The work bridges a long‑standing gap between the logical foundations of query languages and the practical requirements of database systems, offering a robust theoretical platform for future research on query optimization, language design, and formal verification of database applications.