Bound-Founded Answer Set Programming

• Bound-Founded ASP is a modeling paradigm that unifies inductive logical definitions with numeric constraint reasoning, eliminating exponential grounding issues.
• It overcomes classical ASP limitations by directly handling numeric bounds, thus providing a well-founded framework for problems like shortest path computation.
• BFASP employs flattening techniques and magic set transformations to boost solver efficiency in combinatorial optimization over mixed domains.

Bound-Founded Answer Set Programming (BFASP) is an extension of Answer Set Programming (ASP) that unifies inductive definitions over Booleans with constraint reasoning over numeric domains. BFASP generalizes the stable model semantics of ASP to founded numeric variables and their bounds, enabling efficient modeling and solution of problems such as (bounded) shortest paths and other inductive numeric combinatorial problems. By capturing inductively founded bounds over numeric variables, BFASP eliminates grounding bottlenecks inherent in both classical ASP and hybrid ASP-CP systems and provides a single, semantically well-founded modeling and solving paradigm for combinatorial optimization over mixed domains (Aziz, 2014, Aziz et al., 2014).

1. Motivation, Historical Background, and Limitations of ASP and Hybrids

Classical ASP is tailored to Boolean variables, and encodes finite-domain or integer variables by introducing a separate Boolean for every possible value—a strategy that leads to an exponential “grounding bottleneck” as domain sizes grow. While CP solvers handle native integers without such blowup, they lack the stable-model semantics of ASP, specifically its ability to inductively define truth via stratification and to exclude circular justifications. This is crucial for modeling reachability and related inductive properties. Hybrid ASP+CP systems merely delegate standard constraints to a CP back-end, but fail to inductively define bounds for numeric variables. Naively flattening numeric founded bounds into sets of Booleans reintroduces the same grounding bottleneck, and hybrid semantics cannot prevent circular justifications among bounds.

A canonical example is shortest path derivation in graphs: expressing inductive upper bounds on path distances requires recursion over integer variables and eliminating cyclical justification (e.g., $a \leq b$, $b \leq a$ permitting arbitrary finite values). This cannot be prevented under classical Boolean stable model semantics without opaque global constraints. BFASP extends stable model semantics with native support for founded bounds on numeric variables, addressing this critical expressive gap (Aziz, 2014).

2. Formal Syntax and Semantics of BFASP

2.1 Variable Classes and Program Structure

Let $V$ denote the program variables, partitioned into standard variables $V^s$ (CP-like, take values from fixed domains) and founded variables $V^f$ (values justified only via inductive rules). Each variable $x \in V$ has a domain $D(x) \subseteq \mathbb{Z}$, $\mathbb{R}$, or {\textit{true}, \textit{false}}. A BFASP program is a tuple $P=(V^s, V^f, C, R)$, where $C$ is a set of global CP-style constraints and $R$ is a set of founded rules.

2.2 Constraints and Rules

A constraint $c$ is a set of valid valuations over its scope $\mathit{vars}(c)$. $c$ is increasing (decreasing) in $y$ if, once satisfied by $\theta$, it remains satisfied under increases (decreases) of $y$. Each rule is a pair $(c, y)$ with $c$ increasing in the head $y \in V^f$.

Rules may be written: $$\alpha\!: \; a_1 \wedge \ldots \wedge a_k \wedge x_{k+1}\leq t_{k+1} \wedge \ldots \wedge x_m\leq t_m \longrightarrow x_0 \leq t_0$$ where literals and bounds may be standard or founded.

2.3 Stable Model Semantics

BFASP semantics generalize ASP’s stable model semantics to founded numeric variables. For assignment $\theta$, construct reduct $P^\theta$ by (i) grounding global constraints by substituting standard variables using $\theta$, and (ii) in each rule $(c, y)$, substituting each $x \neq y$ that is standard or is not decreasing in $c$ with $\theta(x)$. Discard vacuously satisfied rules. The reduct $P^\theta$ is a positive-CP, i.e., a system of monotone constraints in $y$’s. Its minimal solution $M$ (componentwise least values) is unique.

$\theta$ is a BFASP-stable model iff $\theta$ satisfies global constraints $C$ and, for each founded $y$, $M(y)=\theta(y)$.

Circular support is eliminated by minimality: only recursively grounded bounds are justified, and cycles without external anchoring are pruned (Aziz, 2014).

3. Modeling Capabilities and Running Example

3.1 Inductive Numeric Definitions

BFASP natively models inductive bounds—such as distances, diameters, or resource load—while ensuring that only externally grounded values are justified. This mechanism subsumes standard ASP's inductive definitions over Booleans and strictly generalizes them to numeric domains.

3.2 Single-Source Shortest Path Example

Let $\mathit{src}$ denote a fixed node. For each node $v$, introduce founded variable $d(v) \in \mathbb{N} \cup \{\infty\}$ representing "distance from $\mathit{src}$ to $v$."

• Standard Booleans: ${\rm edge}(u,v,w)$ is true iff graph $G$ contains edge $u \to v$ of weight $w$.
• Founded integers: $d(v)$, initialized to $\infty$ (not yet justified).

BFASP encodes:

• Base rule: $r_0: d(\mathit{src}) \leq 0$
• Inductive rule family:

$$r_{sp}(u,v,w): \; {\rm edge}(u,v,w) \longrightarrow d(v) \le d(u) + w$$

This produces an inductive, non-circular justification of all reachable distances, by fixed-point application of rules until stabilization. No explicit Boolean encoding of every possible distance (and thus no explosion in grounded rules) is required.

4. Flattening and Grounding Techniques

BFASP specifications often use complex non-ground expressions. For tractability, arbitrary rules are flattened to primitive forms, using the following procedure (Aziz et al., 2014):

• Decompose expressions recursively using auxiliary variables (standard or founded) based on whether subexpressions involve founded variables and the monotonicity (increasing/decreasing) with respect to the head variable.
• Primitive rule forms include $(y \geq x_1 + x_2, y)$, $(y \geq \min(x_1, x_2), y)$, $(y \geq -x, y)$, and conditional rules.
• For each ground rule, apply the flattening transformation that preserves stable model semantics by introducing auxiliary founded variables as per the Key Rewrite Theorem.

After flattening, efficient bottom-up grounding is achieved by:

• Tracking, for each founded variable $y$, the unconditionally justified bound (ujb) from explicit base rules.
• Computing, for each rule, a formula $\varphi_r$ over $cr(\cdot)$-atoms (signaling which variables may be justified to exceed their ujb).
• Grounding proceeds by iteratively instantiating rule templates only when their $\varphi_r$ become true under the current set of justified variables.

A further enhancement is the application of the magic set transformation to only ground and process rules relevant to a query, dramatically reducing the ground program when only a small fraction of variables are relevant.

5. Solver Architecture and Algorithms

BFASP solvers integrate:

• CP-style bound-propagators for standard constraints.
• Founded rule propagation, computing the minimal solution to the reduct at each search node via fixed-point computation.
• Unfounded-set detection via source-pointer or MIP-based methods to cut off circularly justified sets of founded variables.
• DPLL-style search for splitting and branching, including both Boolean variables and bounds on numeric variables.

A core loop consists of:

1. Propagating CP-style constraints.
2. Propagating founded rules—recomputing reducts and applying fixed-point propagation.
3. Checking for conflicts and backtracking or proceeding to decision selection.
4. Unfounded-set pruning by seeking nonempty sets of founded variables not anchored by any rule and eliminating such assignments as nogoods.

6. Theoretical Properties and Complexity

BFASP strictly generalizes ASP (when all variables are Boolean) and CP (when there are no founded variables or rules):

• If all variables are boolean and all rules standard, BFASP reduces to classic ASP.
• With no founded variables or rules, BFASP reduces to standard CP reasoning.

Combined complexity is at least NP-complete (since it subsumes ASP). Checking the minimality of a candidate solution is in coNP, and the general existence question is $\Sigma^P_2$-complete. However, for practical subclasses with linear or monotone constraints, decision and grounding remain in NP or PTIME (Aziz, 2014).

Existing ASP+CP hybrids must flatten founded numeric rules into sets of Booleans, leading to a second, often worse grounding bottleneck; only BFASP’s semantics natively handles bounds and their inductive justification.

7. Empirical Evaluation and Implementation

Prototype BFASP solvers have been implemented as extensions to MiniZinc and Chuffed (augmenting both flattening and propagation for founded rules) (Aziz et al., 2014, Aziz, 2014). Three main evaluation domains were used:

• Road Construction (RoadCon): Shortest-path feasibility with founded bounds.
• Utilitarian Policies (UtilPol): Inductive interdependent happiness policy selection.
• Company Control (CompanyCon): Inductive propagation of majority control among companies.

Empirical results demonstrate that bottom-up grounding achieves 5–10× speedups over exhaustive grounding, and further 5–20× speedups when using magic sets, especially when the solution involves only a small subset of all variables.

Tables from (Aziz et al., 2014) provide benchmark details:

Problem	Flat. Time (s)	Solve Time (s)	Magic Flat. (s)	Magic Solve (s)
RoadCon (N=100)	1.37	0.64	0.27	0.04
UtilPol (C=50,P=100)	2.02	1.90	0.48	0.01
CompanyCon (C=1000)	24.27	5.20	0.79	0.70

A plausible implication is that BFASP provides a scalable and principled approach for inductive-combinatorial problems with numeric bounds, avoiding all grounding bottlenecks previously inherent to ASP and hybrid methodologies (Aziz et al., 2014, Aziz, 2014).