Abstract Relational Calculus (ARC)

• ARC is a mathematically rigorous framework for describing and unifying database queries, extending tuple relational calculus with explicit assignment, grouping, and aggregation.
• It defines relations as functions over many-sorted domains with comprehension syntax, grouping operators, and annotated joins to ensure precise compositional semantics.
• ARC serves as a reference metalanguage by enabling semantic equivalence among SQL, TRC, and other query languages through versatile modalities and robust denotational semantics.

Abstract Relational Calculus (ARC) is a mathematically rigorous framework for describing, reasoning about, and unifying database queries at an abstract level. ARC generalizes the traditional Tuple Relational Calculus (TRC) by explicitly incorporating assignment, grouping, aggregation, annotated joins, and modalities of query representation, all within the syntax and semantics of classical predicate calculus. It serves as a “Rosetta Stone” for expressing and comparing query intent across languages, environments (set/bag, NULLs), and human/machine modalities, and forms the basis for ARQL, an abstract relational query language proposal advocated for next-generation database systems (Gatterbauer et al., 15 Dec 2025, Kelly et al., 2012).

1. Formal Foundations of ARC

ARC defines relations on a many-sorted domain $D$ partitioned into disjoint sorts $T$, with arbitrary (non-numerical) tuple indexes. For any index set $I$ and signature $\tau: I \to T$, the cartesian product $(\tau)$ is the set of functions $t: I \to D$ such that $t(i) \in \tau(i)$ for all $i \in I$. A relation in ARC is a pair $\langle \tau, E \rangle$, where $E \subseteq (\tau)$. Thus, tuples are modeled as functions, and signatures determine attribute typing and arity.

The syntax for ARC queries is given by a comprehension form: $$\{\ Q(\overline{A})\ \mid\ \text{QuantList}[\text{Formula}]\ \}$$ where $\text{QuantList}$ comprises declarations such as $\exists x\,R$ (binding variable $x$ to range $R$), groupings $\gamma_{\overline{k}}$, and join annotations $J(\overline{x})$. The body supports conjunction ($\wedge$), disjunction ($\vee$), negation ($\neg$), comparison predicates ($x.A = y.B$), assignments ($Q.A = e$), aggregates ($Q.sm = \sum(x.B)$), and external predicates.

ARC strictly extends TRC by making head assignment explicit, supporting aggregates and grouping, representing join types at the calculus level, and treating external/domain-specific relations and recursion via least-fixed-point semantics (Gatterbauer et al., 15 Dec 2025).

2. Denotational Semantics

ARC interprets formulas by assigning sets (or bags) of tuple-valued environments that satisfy those formulas, parameterized by semantic conventions (set vs. bag, nulls, etc.) (Gatterbauer et al., 15 Dec 2025, Kelly et al., 2012). For a database instance $\mathcal{D}$ and variable environment $\rho$, an atomic formula $x \in R$ is true iff $\rho(x) \in_\Sigma \mathcal{D}(R)$, where $\Sigma$ indicates set or bag semantics. Predicates and assignments are evaluated under this environment.

Quantifiers and connectives are given compositional semantics:

• Existential quantification: The result of $\exists x\,R.\,\psi$ is the union of results for each $t \in_\Sigma \mathcal{D}(R)$, with $\rho[x \mapsto t]$.
• Conjunction (join): For formulas $F$ and $G$, with free variable sets $X$ and $Y$, $F \wedge G$ is interpreted as a join on the union of $X \cup Y$ attributes, respecting matching on shared variables.
• Disjunction (union): Formulas with the same signature are unioned.
• Negation (complement): The set complement under the appropriate signature.

Grouping operators $\gamma_{\overline{k}}$ partition the set of satisfying environments by key values, and aggregates compute values per group as dictated by the aggregate predicate (e.g., sum, count), without baking in handling of empty aggregates or nulls—these remain conventions (Gatterbauer et al., 15 Dec 2025).

3. Modalities and Representation

ARC supports multiple modalities, all canonically inter-translatable:

• Textual comprehension notation (close to “math set-builder” style), e.g.

$$\{\ Q(A,B) \mid \exists r\!:\!R,\ s\!:\!S,\, r.id=s.id \wedge r.A>0 \wedge Q.A=r.A \wedge Q.B=s.B\ \}$$

• Abstract Language Tree (ALT), which represents the syntactic and semantic structure of queries as trees for machine reasoning.
• Diagrammatic Higraph Representation, which encodes query structure in hierarchical graphs, supporting human verification and exploration.

These three modalities enable natural bidirectional translation among query languages, and serve different verification and usability scenarios (Gatterbauer et al., 15 Dec 2025).

4. Key Relational Patterns and Expressiveness

ARC captures all canonical patterns of relational query languages, each mapping directly to SQL, TRC, or Datalog constructs:

Pattern	ARC Formulation Example	SQL Equivalent
Selection	$$\{Q(A)\mid \exists r\!:\!R\,[\,r.A>10\wedge Q.A=r.A]\,\}$$	SELECT R.A FROM R WHERE R.A>10
Projection	$\{Q(A)\mid \exists r\!:\!R\,[Q.A=r.A]\,\}$	SELECT DISTINCT R.A FROM R
Join	$$\{Q(A,B)\mid\exists r\!:\!R,\ s\!:\!S\,[r.id=s.id \wedge Q.A=r.A\wedge Q.B=s.B]\,\}$$	SELECT R.A,S.B FROM R,S WHERE R.id=S.id
Aggregation	$$\{Q(\mathit{dept},\mathit{sm}) \mid \exists e\!:\!\mathit{Emp},\; \gamma_{e.\mathit{dept}[Q.\mathit{sm}=\sum(e.\mathit{sal})]} \}$$	SELECT dept, SUM(sal) FROM Emp GROUP BY dept
Negation	$$\{Q(A)\mid \exists r\!:\!R\,[ r.A>0 \wedge \neg\,\exists s\!:\!S\,[ r.A=s.A ] \wedge Q.A=r.A ]\,\}$$	SELECT R.A FROM R WHERE R.A>0 AND NOT EXISTS ...
Recursion	$$\{A(s,t)\mid [\exists p\!:\!P,[A.s=p.s\wedge A.t=p.t]]\vee[\exists p\!:\!P, a\!:\!A,[A.s=p.s\wedge p.t=a.s\wedge a.t=A.t]] \}$$	Datalog ancestor rules

Editor's term: The "relational-core" property refers to ARC directly surfacing the compositional structure of queries—joins, projections, selections, groupings, and recursions—as first-class constructs.

5. Semantic Adequacy and Theoretical Guarantees

ARC provides a compositional semantics that assigns to each query exactly the relation specified by its logical form. Key theorems established by Kelly and van Emden (Kelly et al., 2012) include:

• Atom theorem: $(q(t_0, ..., t_{n-1})) = M(q):[t_0, ..., t_{n-1}]$.
• Conjunction theorem: $$(B_0 \wedge ... \wedge B_{k-1}) = (B_0) \bowtie ... \bowtie (B_{k-1})$$.
• Existential quantification theorem: $(\exists y.F) = \pi_{free(F)\setminus\{y\}}(F)$.
• Negation theorem: $(\neg F) = (F)^C$.

Collectively these guarantee that ARC is adequate for representing and evaluating all first-order queries, generalizing Codd’s completeness result for relational algebra/calculus, and ensuring that well-formed formulas receive precisely their intended relation as denotation (Kelly et al., 2012).

6. Comparison to Other Relational Query Formalisms

Aspect	ARC	Codd Relational Algebra/TRC	Tarski Semantics
Domain	Many-sorted, arbitrary index set, tuples as functions	Single domain, fixed-arity n-tuples	Arbitrary first-order structures
Syntax	Standard predicate calculus, comprehension with explicit assignment/group/agg/join annotations	Ad hoc algebra/calculus, head nesting	Standard predicate calculus
Semantics	Denotation: queries return relations of satisfying assignments for any open formula	Truth-value or ad hoc, not compositional	Assigns truth to closed formulas
Implementation	Directly implementable, compositional for database backends	Projection/renaming ad hoc	Not naturally operator-based
Modality separation	Three modalities: comprehension, ALT, diagrammatic	None	None

ARC thus unifies the intuitiveness of predicate logic with the compositional, implementation-amenable character of Codd’s algebra, subsuming all first-order expressiveness, extending to aggregation and bag semantics, and removing limitations related to ad hoc renaming/projection or lack of support for advanced patterns (Gatterbauer et al., 15 Dec 2025, Kelly et al., 2012).

7. Applications and Role as Reference Metalanguage

ARC functions as a reference metalanguage in the evolving ecosystem of relational query interfaces:

• Semantic equivalence: By uniquely representing query intent, ARC enables semantic equivalence and round-trip translation among SQL dialects and other query languages, irrespective of syntactic or environment-level convention differences.
• Nuanced translation: Natural language interfaces (NL2SQL), Datalog systems, and diverse SQL implementations can be mediated via ARC’s ALT or comprehension representation, supporting both verification and interoperability.
• Convention separation: Separation of relational core, modalities, and conventions provides a mechanism for querying under different null-handling regimes, set/bag semantics, and aggregation practices—enabling robust cross-system validation and program derivation.

A plausible implication is that ARC, as envisioned in ARQL, is positioned to undergird future database query systems where both human and machine actors collaborate over queries whose intent, structure, and conventions may need to be systematically compared, transformed, or verified (Gatterbauer et al., 15 Dec 2025).