Datalog⁻ Programs: Semantics & Complexity

• Datalog⁻ programs are an extension of classical Datalog with default negation, enabling non-monotonic reasoning and handling incomplete information.
• Their semantics include three-valued, stable, and well-founded models, with stratification ensuring tractable evaluation and decidability in key fragments.
• They underpin applications in database querying, graph algorithms, defeasible logic, and probabilistic programming while offering a rich framework for expressiveness and complexity analysis.

Datalog$^{\neg}$ Programs

Datalog$^{\neg}$ denotes the class of logic programs based on classical Datalog (function-free Horn clause programming over a finite domain) but extended with default negation in rule bodies. The language forms the foundation of a substantial portion of modern database theory, non-monotonic reasoning, and knowledge representation, providing a rigorous formalism for specifying complex queries and inference procedures, especially under incomplete information. Datalog$^{\neg}$ encompasses several key semantics, program classes, and algorithmic results, and serves as an anchor point for extensions to probabilistic programming, normal logic programs, and higher-order rule systems.

1. Syntax and Structural Properties

A Datalog$^{\neg}$ rule has the form

$$p_0(\mathbf{s_0}) \;\gets\; p_1(\mathbf{s_1}),\dots,p_m(\mathbf{s_m}), \; \neg p_{m+1}(\mathbf{s_{m+1})},\dots,\neg p_k(\mathbf{s_k}),$$

where $p_i$ are predicates, $\mathbf{s_j}$ tuples of constants or variables, $0 \le m \le k$, and all function symbols are constants (function-free). Rules are grouped into a program $P$, a finite set of such rules. Negation in the body is treated as negation-as-failure.

Ground instantiation is finite; every variable in the head and negative literals is required to appear in some positive body atom (safety).

Programs are classified by syntactic features:

• Positive: No negative literals.
• Stratified: A mapping from predicates to strata ensures negative dependencies only flow to lower strata and precludes cycles through negation.
• Call-consistent: No predicate depends negatively on itself (no $p \rhd^{-} \cdots \rhd^{-} p$).
• Range-restricted and negation-safe: Variables in the head, and in negative literals, must occur in some positive body literal (Maher, 2021).

Stratification is pivotal for tractability, decidability, and totality of various semantics.

2. Declarative Semantics

Three-valued semantics is canonical for Datalog$^{\neg}$:

• Interpretations: $I : \mathrm{HB}_P \rightarrow \{0, \star, 1\}$, where $0$ is false, $1$ true, and $\star$ unknown.
• Supported models: Two-valued $I$ satisfying Clark's completion, i.e., each atom is true iff justified by some rule whose body is true. Partial models relax this to three-valued logic (Trinh et al., 21 Apr 2025).
• Stable model semantics (Gelfond--Lifschitz): The reduct $P^I$ of $P$ with respect to a two-valued $I$ is formed by removing all rules with negative body literals failing under $I$ and eliminating remaining negative literals. $I$ is a stable model if it is the unique least Herbrand model of $P^I$.
• Partial-stable models/Regular models: Apply the reduct to three-valued $I$ and define minimality in the information or truth order.
• Well-founded model: The least fixed point of van Gelder–Ross–Schlipf’s three-valued operator, yielding a unique partial model—total for stratified programs.

For stratified Datalog$^{\neg}$ the well-founded model is total and coincides with the unique stable model (Maher, 2021).

3. Syntactic and Algorithmic Fragments

Stratified and type-consistent fragments enjoy low data complexity and robust evaluation properties:

• Stratified Datalog$^{\neg}$: Execution proceeds stratum by stratum. All negative dependencies are acyclic, ensuring deterministic bottom-up evaluation.
  • E.g., problems such as $H$-partition can be encoded in stratified Datalog$^{\neg}$ and solved in PTIME (Capon et al., 2022).
• Type-consistent limit-linear Datalog$^{\neg}$: Extends Datalog$^{\neg}$ with arithmetic, numeric variables, and limit predicates subject to type and sign constraints that guarantee polynomial time data complexity (Kaminski et al., 2018).
• General Datalog$^{\neg}$: Unrestricted programs (possibly with recursion through negation) have much higher computational complexity, typically complete for the second level of the polynomial hierarchy in data complexity (Kaminski et al., 2018).

4. Model-Theoretic and Dynamical Unifications

A comprehensive perspective arises when Datalog$^{\neg}$ programs are interpreted via Boolean networks:

• The atom dependency graph $adg(P)$, a signed directed graph with positive and negative edges, encodes dependencies.
• Trap spaces: Partial interpretations invariant under the update operator $U_P$ correspond to subcubes of the state space closed under the program’s dynamics (Trinh et al., 7 Jan 2026). Supported models, stable models, and other canonical semantics are realized as special classes of trap spaces:
  • Supported models: constant trap spaces.
  • Supported partial models: complete trap spaces (fixed points under $T_P$).
  • Stable models: minimal stable trap spaces under stable updates (Trinh et al., 21 Apr 2025, Trinh et al., 7 Jan 2026).
• Existence and uniqueness criteria are graph-theoretic: absence of odd cycles in $adg(P)$ ensures the existence of stable models; the absence of even cycles guarantees uniqueness.
• Feedback vertex set cardinality in $adg(P)$ provides upper bounds: For $k$ the size of a minimal (even) feedback vertex set, the number of regular (and stable) models is bounded by $2^k$ or $3^k$ (Trinh et al., 21 Apr 2025).

From the dynamical systems perspective, trajectories under $U_P$ correspond to the evolution of knowledge states, with steady-state classes and oscillatory behavior unified by trap-space semantics.

5. Expressiveness, Complexity, and Comparisons

Datalog$^{\neg}$ exhibits a rich spectrum of expressive power and algorithmic complexity:

• Expressiveness: Classical Datalog$^{\neg}$ subsumes positive Datalog; with stable model semantics, it further captures non-monotonic (default) reasoning.
• Comparison with other paradigms:
  • Probabilistic extensions: Generative Datalog$^{\neg}[\Delta]$ integrates sampling in rule heads and stable negation, supporting full declarative probabilistic programming with possible outcomes correlated by non-monotonic constraints (Alviano et al., 2022).
  • Defeasible reasoning: Key fragments of scalable defeasible logics can be compiled to Datalog$^{\neg}$, supporting efficient and correct implementation of prioritized non-monotonic reasoning (Maher, 2021).
  • Higher-order Datalog$^{\neg}$: For order $k\geq 1$, the (k+1)-order fragment under well-founded semantics captures $k$-EXPTIME. Under stable semantics, (k+1)-order $Datalog^{\neg}$ with choice captures $k$-NEXPTIME (brave) and co-$(k$-NEXPTIME$)$ (cautious) (Charalambidis et al., 27 Jul 2025).
• Complexity:
  • PTIME: Stratified, type-consistent fragments; bounded or acyclic dependency graphs (Kaminski et al., 2018, Capon et al., 2022).
  • $\Delta_2^p$-complete: Limit-linear stratified Datalog$^{\neg}$ (Kaminski et al., 2018).
  • EXPTIME$[k]$: Higher-order well-founded; NEXPTIME$[k]$ (brave) and co-NEXPTIME$[k]$ (cautious) for higher-order stable (Charalambidis et al., 27 Jul 2025).

6. Applications and Illustrative Encodings

Datalog$^{\neg}$ encodings are pivotal in database queries, combinatorial graph algorithms, knowledge representation, and nonmonotonic reasoning.

• Graph partitioning: The $H$-partition problem is PTIME-computable by stratified Datalog$^{\neg}$, leveraging recursive labelling/propagation and negation to eliminate inconsistent extensions. This encoding is provably complete for all but a small set of model graphs, and empirically competes with guess-and-check ASP on small to moderate input graphs (Capon et al., 2022).
• Defeasible logic: Direct compilation of prioritized rules and defeat relationships yields Datalog$^{\neg}$ programs with guaranteed correspondence (preservation/reflection) to proof-theoretic consequences. The semantics can be tailored to stratified or well-founded variants for efficiency and scalability (Maher, 2021).
• Declarative probabilistic programming: Generative Datalog$^{\neg}[\Delta]$ assigns a probability space over stable models (“possible outcomes”), supporting nonmonotonic and stochastic event modeling. The chase construction provides a Markov chain semantics isomorphic to grounder-based semantics (Alviano et al., 2022).

7. Research Outlook and Theoretical Developments

Recent advances deepen the integration of Datalog$^{\neg}$ with:

• Boolean network theory, supplying tight combinatorial and dynamical invariants for model existence, uniqueness, and complexity (Trinh et al., 21 Apr 2025, Trinh et al., 7 Jan 2026).
• Trap-space semantics, which unify steady-state and oscillatory program behaviors, and allow efficient existence/minimality proofs via order-theoretic and topological arguments (Trinh et al., 7 Jan 2026).
• Hierarchically stratified and higher-order extensions, supporting increased expressive power without sacrificing the declarative or computationally transparent character of the language (Charalambidis et al., 27 Jul 2025).
• Probabilistic and stochastic modeling, wherein stable negation enables the representation and manipulation of non-monotonic uncertainty (Alviano et al., 2022).

Datalog$^{\neg}$ remains a central formalism providing the backbone for finite model theory, database query languages, knowledge representation, and sophisticated non-monotonic and probabilistic logic programming.