ASPMT: Answer Set Programming Modulo Theories

• ASPMT is a non-monotonic, many-sorted first-order framework that combines ASP with SMT by applying stable-model semantics to both intensional predicates and functions.
• It integrates background theories like arithmetic and ODEs with rule-based defaults, facilitating reasoning in continuous, spatial, and hybrid domains.
• ASPMT employs tight compilation methods such as Clark completion and ranking constraints to reduce computational complexity in solving hybrid systems.

Answer Set Programming Modulo Theories (ASPMT) is a many-sorted first-order framework that combines answer set programming (ASP) with satisfiability modulo theories (SMT) by fixing a background theory and applying stable-model semantics to designated intensional predicates and functions. In this setting, arithmetic, uninterpreted functions, ODEs, or other theory symbols belong to the background signature, while non-monotonicity is carried by intensional symbols whose extensions or values are determined by the program. The framework is repeatedly characterized as a tight integration of ASP and SMT, analogous to the way SMT extends propositional satisfiability, and its distinctive contribution is the use of functional stable model semantics so that intensional functions are handled on the same semantic footing as intensional predicates (Bartholomew et al., 10 May 2026, Bartholomew et al., 2023).

1. Semantic core

An ASPMT program is presented as a first-order theory over a signature that combines a background theory $T$ with ASP-style rules allowing default negation. The signature is many-sorted and typically separates a fixed background signature from a program signature containing uninterpreted symbols. Some symbols are interpreted by $T$, such as arithmetic over the reals, while others are intensional and subject to stable-model minimization (Wałęga et al., 2016, Bartholomew et al., 12 Jun 2025).

A canonical rule form is

$$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$

where $h$ and the $b_i$ may be ordinary atoms or theory-atoms, and $C(\mathbf{x})$ is a conjunction of theory-atoms. Semantically, the rule is read as a first-order implication, while stable-model semantics applies only to the intensional symbols, with the background theory held fixed (Wałęga et al., 2016).

The second-order stable-model operator used in ASPMT is the functional extension of the Ferraris–Lee–Lifschitz semantics. For a formula $F$ and a list of intensional constants $c$,

$$\mathrm{SM}[F;c] \;\equiv\; F \;\wedge\;\neg\,\exists\hat c\Bigl(\hat c<c\;\wedge\;F^*(\hat c)\Bigr).$$

Here $F^*$ is obtained by replacing positive occurrences of intensional symbols by corresponding variables and recursively extending this transformation through connectives and quantifiers. A stable model of $T$0 relative to $T$1 is any classical structure satisfying $T$2 together with the background theory (Wałęga et al., 2016, Bartholomew et al., 10 May 2026).

A central semantic innovation is the treatment of intensional functions. In standard ASP, functions are pre-defined in the Herbrand universe and do not vary across answer sets. In ASPMT, an intensional function is treated much like an intensional predicate: its graph may vary between stable models and may be described by other functions and predicates. This is the basis on which ASPMT is defined as a first-order non-monotonic formalism over interpreted domains (Bartholomew et al., 2023, Bartholomew et al., 10 May 2026).

2. Tightness, Clark completion, and SMT reduction

The best-known metatheorem in ASPMT concerns the tight fragment. A formula is in Clark normal form relative to the intensional symbols if it is a conjunction of implications of the form

$T$3

one for each intensional predicate $T$4 and function $T$5. Clark completion replaces each implication by an equivalence. The dependency graph is defined over intensional symbols, with edges induced by strictly positive occurrences, and the theory is tight when this graph is acyclic (Wałęga et al., 2016, Lee et al., 6 Jul 2025).

Bartholomew and Lee’s completion theorem is the key compilation result: if $T$6 is in Clark normal form and tight on the intensional symbols, then, for interpretations over domains with at least two elements,

$T$7

Consequently, stable-model computation for tight ASPMT theories reduces to ordinary satisfiability of the completion in the background theory. This is the formal basis for treating tight ASPMT as SMT (Wałęga et al., 2016, Bartholomew et al., 12 Jun 2025).

The translation pipeline is correspondingly direct. For tight programs one writes the rules in Clark normal form, checks tightness, forms the completion, and submits the resulting first-order formula to an SMT solver for the background theory. In the 2025 system account, the translation is refined through completion, domain non-triviality, identification of theory atoms, and variable elimination steps that turn completed function definitions into quantifier-free SMT constraints (Bartholomew et al., 12 Jun 2025). The same paper states that the compiler uses the ASP grounder gringo and SMT solver z3, with gringo partially grounding input programs while leaving some variables to be processed by z3 (Bartholomew et al., 12 Jun 2025).

This reduction is not merely syntactic. It transfers the computational burden from grounding-heavy ASP workflows to SMT reasoning over large or infinite domains. The papers repeatedly emphasize real arithmetic as a target background theory, and in several examples the resulting SMT instances are quantifier-free formulas over linear or nonlinear arithmetic (Bartholomew et al., 12 Jun 2025, Lee et al., 6 Jul 2025).

3. Intensional functions, defaults, and non-monotonic persistence

ASPMT’s non-monotonic behavior is not limited to predicates. The later formalizations explicitly present intensional functions as a primary reason to adopt functional stable-model semantics. This matters in domains where non-Boolean fluents are more natural as functions, such as amounts, positions, speeds, or durations. In these settings, ASPMT permits the direct specification of functional values by default rules and causal laws rather than forcing reification into purely relational encodings (Bartholomew et al., 2023, Bartholomew et al., 10 May 2026).

Choice formulas are the standard mechanism for defaults. In ASPMT(QS), for every spatial relation $T$8, one writes

$T$9

which captures default persistence unless change is forced otherwise. An action effect can then specify exceptional change, for example:

$$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$0

The same pattern is used for spatial frame axioms and is explicitly described as the mechanism by which ASPMT(QS) solves the frame and ramification problems non-monotonically (Wałęga et al., 2016).

The same design recurs in continuous domains. In the aspsmt2smt description, inertia is encoded by rules such as $h$8 alongside dynamic laws involving arithmetic constraints. The system is reported to find real-valued durations and speeds that exactly solve the continuous planning problem, without any discretization of the numeric domain (Bartholomew et al., 12 Jun 2025).

A common misconception is that ASPMT is only ASP with theory atoms added to rule bodies. The functional-stable-model papers argue for a stronger claim: ASPMT is defined by stable-model minimization over both predicates and functions, with existing integration approaches viewed as special cases where functions are limited (Bartholomew et al., 10 May 2026, Bartholomew et al., 2023). This suggests that the semantic role of functions is not an implementation detail but part of ASPMT’s defining formal identity.

4. Non-tight programs, level rankings, and complexity

The completion theorem applies only to the tight fragment. For non-tight programs, Clark completion alone is insufficient. This restriction is explicit across the formal presentations, and several papers treat it as the principal boundary of the SMT-compilation result (Lee et al., 6 Jul 2025, Bartholomew et al., 12 Jun 2025).

One response is to extend the SMT encoding with ranking constraints. EZSMT+ is presented as an SMT-based constraint answer set solver whose theoretical foundation lies in generalizations of Niemelä’s characterization of answer sets via level rankings. For a ground program $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$1 and interpretation $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$2, a function $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$3 is a level ranking if, whenever a rule supports $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$4, the rank of $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$5 exceeds the rank of every atom in the positive body. EZSMT+ introduces integer variables rank_a and encodes ranking inequalities in QF_LIA, conjoining them with completion clauses and theory constraints in a single SMT-LIB formula (Shen et al., 2019).

The relation between CASP and SMT is made precise in the translation from constraint answer set programs with integer linear constraints to SMT(LIA). For tight programs, input completion suffices. For non-tight programs, ranking constraints are added, yielding an exact reduction of answer-set existence to SMT(LIA)-satisfiability (Lierler et al., 2017). In that account, ASPMT is described as a unifying framework in which ASP is combined with SMT, and models of the SMT(LIA) formula coincide with answer sets of the corresponding ASPMT/CASP specification (Lierler et al., 2017).

Complexity statements in the functional-stable-model treatment sharpen the distinction. In general, deciding whether $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$6 has a stable model is $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$7-complete already when the background theory is empty. For tight programs, however, the search reduces to one call, or a small finite number of calls, to an SMT solver for the background theory. If $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$8 is in NP, then finding a stable model is in NP, with polynomial-time overhead for constructing the SMT translation (Bartholomew et al., 10 May 2026). The complexity boundary therefore follows the combined effect of non-monotonic recursion and theory reasoning rather than theory reasoning alone.

5. Implementations and solver architectures

Several systems instantiate the ASPMT methodology. aspmt2smt and aspsmt2smt implement compilation of tight ASPMT theories to SMT. In the system architecture described for ASPMT(QS), the main components are a QS spatial representation library, a tightness checker, a translation engine, and SMT solver invocation. The tightness checker ensures the input is f-plain and av-separated, constructs the dependency graph on intensional symbols, and verifies acyclicity. The translation engine applies Clark completion and outputs an SMT-LIB file, after which Z3 returns either unsat or sat plus a theory-model (Wałęga et al., 2016).

The 2025 system account details a related pipeline: front-end syntax similar to f2lp for rules and C+2ASP for declarations; preprocessing that flattens uninterpreted functions into predicate atoms with auxiliary value constants; separation of ASP variables from SMT variables; partial grounding with gringo; reconstruction of functions; completion and variable elimination; and invocation of Z3 on the resulting SMT-LIB problem (Bartholomew et al., 12 Jun 2025).

cplus2aspmt extends the pattern to action languages and hybrid systems. In the hybrid-automata paper, linear hybrid automata with convex invariants are represented in an action language modulo theories and translated to QF_LRA; the framework is then extended to non-linear hybrid automata with non-convex invariants via action language modulo ODE, compiled to satisfiability modulo ODE, and solved by dReal (Lee et al., 2017). The companion continuous-change work similarly reformulates the semantics of action language $$\forall \mathbf{x}\;\Bigl(h(\mathbf{x})\; \leftarrow\; b_1(\mathbf{x}),\dots,b_m(\mathbf{x}),\;\mathit{not}\;b_{m+1}(\mathbf{x}),\dots,\mathit{not}\;b_n(\mathbf{x}),\;C(\mathbf{x})\Bigr),$$9 in terms of ASPMT and uses SMT solvers to compute trajectories involving both discrete and continuous change, including cumulative effects on continuous resources (Lee et al., 6 Jul 2025).

EZSMT+ exemplifies the non-tight branch of the ecosystem. Its workflow consists of grounding and completion, level-ranking generation, SMT-LIB translation, SMT solver invocation, and model-to-answer-set reconstruction, with optional blocking clauses for enumeration. The paper reports support for QF_LIA / QF_LRA, UF, and extensions for non-linear arithmetic where the back-end solver supports them, with back-ends including Z3, CVC4, and Yices (Shen et al., 2019).

6. Application domains, empirical profile, and boundaries

The most detailed application line in the supplied literature is non-monotonic spatial reasoning. ASPMT(QS) is introduced for dynamic spatial systems in commonsense cognitive robotics, computer-aided architecture design, and dynamic geographic information systems. It combines a qualitative spatial representation module with ASPMT-to-SMT compilation, encodes qualitative relations as systems of polynomial constraints, and performs reasoning in the theory of real nonlinear arithmetic (Wałęga et al., 2016).

Representative encodings are explicit. For circles $h$0,

$h$1

$h$2

and

$h$3

Orientation constraints are likewise polynomial, for example

$h$4

These formulas are inserted into the completion so that the SMT solver reasons jointly with geometry, qualitative relations, and defaults (Wałęga et al., 2016).

The empirical comparison in that work uses four benchmark scenarios—Growth, Motion, Attach I, and Attach II—against Clingo, GQR, and CLP(QS). On a 2.0 GHz dual-core, 4 GB RAM, total CPU times for ASPMT(QS) are reported as 0.169 s, 0.167 s, 0.625 s, and 0.268 s, respectively. The same summary states that only ASPMT(QS) correctly derives indirect spatial effects and solves the frame problem via default inertia, while GQR and Clingo cannot combine qualitative topology with quantitative geometry or express default persistence, and CLP(QS) lacks default reasoning and resorts to exhaustive scenario enumeration without preference (Wałęga et al., 2016). In the corresponding historical claim, ASPMT(QS) is described as the only existing system capable of reasoning about indirect spatial effects and integrating geometric and qualitative spatial information within a non-monotonic spatial reasoning context (Wałęga et al., 2016).

Beyond spatial reasoning, ASPMT is used for continuous planning, hybrid automata, and design space exploration. aspsmt2smt is reported to effectively handle real number computations for reasoning about continuous changes (Bartholomew et al., 12 Jun 2025). The $h$5 reformulation shows how ASPMT can represent cumulative effects on continuous resources (Lee et al., 6 Jul 2025). In embedded-system design, the methodology is stated to allow the direct integration of multi-objective optimization of non-linear objectives into ASP, using ASP with background theories together with asprin and clingo[DL]-style theory propagation (Wanko, 2019). In space-time reasoning, ASP Modulo Space-Time supports mixed qualitative-quantitative reasoning, consistency checking, and inferring compositions of space-time relations, and is described as the only general KR-based method for declaratively reasoning about the dynamics of `space-time' regions as first-class objects (Schultz et al., 2018).

The principal limitation stated across the formal literature is the tightness requirement for reduction by completion. aspsmt2smt is currently restricted to the tight fragment and to programs satisfying certain variable-isolation syntactic conditions, while supported background theories depend on the SMT solver and the implementation explicitly notes only linear and some nonlinear arithmetic over $h$6 and $h$7 (Bartholomew et al., 12 Jun 2025). The continuous-change and hybrid-system papers make the same point from a different angle: tight programs admit a purely first-order SMT treatment, whereas non-tight programs still require additional machinery (Lee et al., 6 Jul 2025, Lee et al., 2017). Another common misconception is that ASPMT replaces ASP search entirely with theory solving. The system papers instead show two complementary regimes: direct completion-based SMT compilation for tight theories, and completion plus ranking constraints or theory propagation for non-tight theories (Shen et al., 2019, Lierler et al., 2017).

Taken together, these results position ASPMT as a semantic framework rather than a single solver architecture. Its defining features are functional stable-model semantics, explicit background theories, and a compilation discipline that turns tight non-monotonic first-order specifications into SMT instances while retaining default reasoning, intensional functions, and elaboration-tolerant modeling over rich domains (Bartholomew et al., 10 May 2026, Bartholomew et al., 2023).