2.1 Constraint answer set programming

We next introduce linear constraints and variables in our programs, thus turning to CASP. We consider a countable set $\mathcal{V}$ of linear variables. Each $v \in \mathcal{V}$ has a domain $D(v)$ , that is, assumed to be an integer range, which defaults to $[-\infty , +\infty ]$ ; it can be restricted by a domain constraint of the form

(7) \begin{align} v \in [l,u] \end{align}

where $l$ and $u$ , $l \leq u$ , are integer lower and upper bounds. In general, bounding the linear variables is not required but the CASP solver might infer bounds or fallback to some default values.

A linear constraint is of the form

(8) \begin{align} a \leftrightarrow v_1 \cdot w_1 + \dots + v_n \cdot w_n \circ g \end{align}

where $a$ is an atom, each $v_i$ is a linear variable, each $w_i$ and $g$ are integer constants, and $\circ \in \{ \lt ,\gt ,=,\neq , \leq , \geq \}$ is a comparison operator. Intuitively, $a$ is constrained to the truth value of the linear constraint. Syntactically, $a$ can appear in the bodies of standard ASP rules (1). For any CASP program $P$ , we denote by $\mathcal{V}_P$ and ${\mathcal{A}_P}^{\mathit{lin}}$ the sets of all linear variables and all propositional atoms occurring in linear constraints of $P$ , respectively.

We additionally allow a CASP to contain global constraints. An alldifferent constraint is of the form

(9) \begin{align} \&\mathit{distinct}\{ v_1 , \dots , v_n\} \end{align}

where each $v_i$ is a linear variable and all are constrained to be pair-wise different. A cumulative constraint is of the form

(10) \begin{align} \&\mathit{cumulative}\{ (s_1,l_1,r_1) , \dots , (s_n,l_n,r_n)\} \leq g \end{align}

where $s_i$ is a linear variable representing the start of each interval, $l_i$ is a linear variable representing the length, $r_i$ is a linear variable denoting the resource usage, and $g$ is an integer bound. The constraint then enforces that at each time point, the sum of the resource usages of the overlapping intervals does not exceed $g$ . A global disjoint constraint is of form $\&\mathit{disjoint}\{ (s_1,l_1) , \dots , (s_n,l_n)\}$ and can be seen as a special case of a constraint (10) where $r_i$ and $g$ are assumed to be $1$ .

Semantics. An extended (e-) interpretation for a CASP program $P$ is a tuple $\mathcal{I}=\langle I,\delta \rangle$ where $I$ is a set of propositional atoms and $\delta : {\mathcal{V}_P} \rightarrow \mathbb{Z}$ is an assignment of integers to linear variables $\mathcal{V}_P$ . Satisfaction $\mathcal{I} \models \phi$ , where $\phi$ is a head, body, rule, program etc., is defined as above via $I$ .

An e-interpretation $\mathcal{I}=\langle I,\delta \rangle$ is a constraint answer set of $P$ if (1) $I$ is an answer set of $P \cup \{ \{a\} \leftarrow \ \mid a \in {{\mathcal{A}_P}^{\mathit{lin}}} \}$ , (2) for each domain constraint (7) in $P$ , $\delta (v)\in [l,u]$ , and (3) for each linear constraint (8) in $P$ , $a \in I$ if $\sum _{1\leq i \leq n} \delta (v_i) \cdot w_i \circ g$ . By slight abuse of notation we also use ${\mathit{AS}}(P)$ to refer to the constraint answer sets of a CASP program $P$ .

For CASP programs, we allow minimization over the linear variables with statements

(11) \begin{align} \mathit{min} \ v_1 \cdot w_1 + \dots + v_n \cdot w_n \end{align}

where each $v_i$ is a linear variable and each $w_i$ is an integer constant. The cost $c_P(\mathcal{I})$ of an e-interpretation $\mathcal{I}$ of a CASP program $P$ is the sum of the costs determined by statements (6) and (11), and optimal constraint answer sets are, mutatis mutandis, analogous to optimal answer sets.

4.1 Translation constraints

The translation, ${\mathit{Tr}}(P)$ consists of several groups of constraints, which encode different aspects of an answer set of a (C)ASP program $P$ :

• • ranking constraints $\mathit{TrRk}(P)$ , which encode the level ranking constraint;

• • rule body constraints $\mathit{TrBd(r)}$ , which encode the satisfaction of rules bodies;

• • rule head constraints $\mathit{TrHd(r)}$ , which must be satisfied when rule bodies fire; and

• • supportedness constraints $\mathit{TrSupp(P)}$ , ensuring that true atoms are supported.

The complete translation for a program ${\mathit{Tr}}(P)$ is then given by

\begin{equation*}\textstyle {\mathit{Tr}}(P) = \mathit{TrRk}(P) \cup \bigcup _{r\in P} \mathit{TrRule(r)} \cup \mathit{TrSupp(P)}\,,\end{equation*}

where $\mathit{TrRule(r)} = \mathit{TrBd(r)} \cup \mathit{TrHd(r)}$ is the combined body and head translation of $r$ .

Ranking c onstraints $\boldsymbol{\mathit{TrRk(P)}}$ . First, we introduce some auxiliary atoms to handle the level ranking constraints, which follows the formulation given by Janhunen (Reference Janhunen2023). Note that we assume that there are no tautological rules, that is, $\mathit{DG}^+_P$ has no self-loops.

For each atom $a$ such that $|SCC(a)|\gt 1$ , we introduce an integer variable $\ell _a$ with domain $[1,|SCC(a)|+1]$ and add the following reified constraint to the translation:

(13) \begin{align} \ell _a \leq |SCC(a)| \;\leftrightarrow a \end{align}

The constraint enforces that atom $a$ has rank $|SCC(a)|+1$ if $a$ is set to false. Now, for all $b\in \mathit{SCC}(a)$ such that $\mathit{DG}^+_P$ has an edge $(a,b)$ , we add a boolean auxiliary variable $\mathit{dep}_{a,b}$ and

(14) \begin{align} \ell _a - \ell _b \geq 1\ \leftrightarrow \mathit{dep}_{a,b} \end{align}

which ensures that $\mathit{dep}_{a,b}$ is true if $a$ has higher rank than $b$ . The rank defined by these constraints is not strict, i.e., an answer set may have multiple rankings. To enforce strictness, we add

(15) \begin{align} \ell _a - \ell _b \geq 2\ \leftrightarrow \mathit{y}_{a,b} \end{align}

(16) \begin{align} a \land b \land \mathit{y}_{a,b}\ \leftrightarrow \mathit{gap}_{a,b} \end{align}

where $\mathit{gap}_{a,b}$ is a Boolean variable indicating a gap in the ranks of true atoms $a$ and $b$ .

We denote the ranking constraints (13)–(16) by $\mathit{TrRk(P)}$ ; if $P$ is tight, $\mathit{TrRk(P)}=\emptyset$ .

Body t ranslation $\boldsymbol{TrBd(r)}$ . Next, for each $r \in P$ , we perform a body translation $\mathit{TrBd(r)}$ . Suppose first that $r$ is a constraint. If $B(r)$ is normal, that is, of form (4), then we add the clause

(17) \begin{align} \textstyle \bigvee _{b \in B^+(r)} \neg b \vee \bigvee _{b \in B^-(r)} b\,, \end{align}

whereas if $B(r)$ is weighted (5), we add the constraint

(18) \begin{align} \textstyle \sum _{b \in B^+(r)} b \cdot w_b^r + \sum _{b \in B^-(r)} \neg b \cdot w_b^r \ \leq \ l - 1\,. \end{align}

Note that this is a pseudo-Boolean constraint, which our intended formalism does not support, and likewise Boolean variables in linear constraints. To circumvent this, we introduce new 0-1 integer variables for each literal and link their values; for better readability, we will leave this implicit. We similarly use auxiliary variables for negated atoms in conjunctions and leave this also implicit.

If $r$ is not a constraint, we divide $H(r)$ into $T= \{ a \in H(r) \mid \mathit{SCC}_P(a) \cap B^+(r) = \emptyset \}$ and $H(r)\setminus T$ , where $T$ are the head atoms that are locally tight. If $T\neq \emptyset$ , we perform the standard Clark’s completion (Clark Reference Clark1977) to $r$ , that is, if $B(r)$ is normal, we add

(19) \begin{align} \textstyle \bigwedge _{b \in B^+(r)} b \land \bigwedge _{b \in B^-(r)} \neg b \ \leftrightarrow \ \mathit{bd}_{r}^{}\,; \end{align}

and if $B(r)$ is weighted, we add

(20) \begin{align} \textstyle \sum _{b \in B^+(r)} b \cdot w_b^r + \sum _{b \in B^-(r)} \neg b \cdot w_b^r \geq l \leftrightarrow \ \mathit{bd}_{r}^{}\,. \end{align}

Furthermore, for each $a \in T$ such that $|\mathit{SCC}_P(a)| \gt 1$ , we add the following constraint, which enforces that $a$ has rank 1 if both $a$ and $\mathit{bd}_{r}^{}$ are true, where $s_a = |\mathit{SCC}_P(a)|+1$ :

(21) \begin{align} s_a \cdot \mathit{bd}_{r}^{} \ + s_a \cdot a + \ 1 \cdot \ell _a \ \leq \ 2 \cdot s_a + 1\,, \end{align}

and for each $a \in H(r)\setminus T$ , we add constraints as follows: for a normal $B(r)$ of form (4),

(22) \begin{align}\bigwedge _{b \in B^+(r) \setminus \mathit{SCC}_P(a)} b\quad \land \bigwedge _{b \in B^+(r)\cap \mathit{SCC}_P(a)} \mathit{dep}_{a,b}\quad \land \bigwedge _{b \in B^-(r)} b \ \leftrightarrow \ \mathit{bd}_{r}^{a}\end{align}

(23) \begin{align}\neg \mathit{bd}_{r}^{a} \ \lor \ \bigvee _{b \in B^+(r)\cap \mathit{SCC}_P(a)} \neg \mathit{gap}_{a,b},\end{align}

whereas for a weighted $B(r)$ of form (5), we add

(24) \begin{align}\sum _{b \in B^+(r) \setminus \mathit{SCC}_P(a)} b\cdot w_b^r \ + \sum _{b \in B^-(r)} \neg b \cdot w_b^r \ \geq \ l \ \leftrightarrow \ \mathit{ext}_r^a\end{align}

(25) \begin{align}\sum _{b \in B^+(r) \setminus \mathit{SCC}_P(a)} b \cdot w_b^r \ + \sum _{b \in B^+(r) \cap \mathit{SCC}_P(a)} \mathit{dep}_{a,b} \cdot w_b^r + \sum _{b \in B^-(r)} \neg b \cdot w_b^r \ \geq \ l \ \leftrightarrow \ \mathit{int}_r^a\end{align}

(26) \begin{align}\sum _{b \in B^+(r) \setminus \mathit{SCC}_P(a)} b \cdot w_b^r \ + \sum _{b \in B^+(r) \cap \mathit{SCC}_P(a)} \mathit{gap}_{a,b} \cdot w_b^r + \sum _{b \in B^-(r)} \neg b \cdot w_b^r \ \leq \ l-1 \ \leftrightarrow \ \mathit{aux}_r^a\end{align}

(27) \begin{align}\mathit{ext}_r^a \lor \mathit{aux}_r^a \lor \neg \mathit{int}_r^a\\[-30pt]\nonumber\end{align}

(28) \begin{align}s_a \cdot \mathit{ext}_r^a \ + s_a \cdot a + \ 1 \cdot \ell _a \ \leq \ 2\cdot s_a + 1\\[-30pt]\nonumber\end{align}

(29) \begin{align}\mathit{ext}_r^a \lor \mathit{int}_r^a \ \leftrightarrow \ \mathit{bd}_{r}^{a}.\end{align}

Overall, the rule body translation follows the intuition of the original completion by Clark (Reference Clark1977). Namely, we introduce an auxiliary variable for each rule and constrain it to be true if the rule body is true. For each head atom $a$ from the SCC of some body atom, we follow the approach by Janhunen (Reference Janhunen2023) and introduce an auxiliary atom $\mathit{bd}_{a}^{r}$ for the pair of $a$ and the rule body of $r$ . The atom $\mathit{bd}_{a}^{r}$ is set true exactly when the rule body “fires” without need of cyclic support, which is achieved by considering the dependency variables instead of the atoms, cf. (22). For weighted rule bodies, we follow Janhunen (Reference Janhunen2023) and introduce auxiliary variables for external (24) and internal (25) support of a rule body and a head atom. The former can be seen as the fact that the rule body fires regardless of any atoms in the SCC of the head atom, while the latter expresses rule firing despite some potentially cyclic dependencies. Constraint (29) defines an auxiliary variable denoting that the rule supports the head atoms, which is true whenever internal or external support exists. The constraints (21), (23), (27), and (28) ensure a strict ranking, that is, no gaps in the level mapping.

Head t ranslation $\boldsymbol{TrHd}(r)$ . To capture the semantics of a rule $r$ , that is, if $B(r)$ holds then $H(r)$ hold as well, we need further constraints in the translation $\mathit{TrHd}(r)$ .

For each $a\,{\in }\,H(r)$ , we use a new Boolean variable $\mathit{sp}_{r}^{a}$ to denote that $r$ supports $a$ . Suppose first $r$ is a disjunctive rule and $|H(r)| \gt 1$ . Recall that by our assumption, every $a \in H(r)$ is locally tight, so we only need to consider the single body variable $\mathit{bd}_r$ .

Inspired by Alviano and Dodaro’s (Reference Alviano and Dodaro2016) disjunctive completion, we add for each $a_i \in H(r)$ :

(30) \begin{align} \textstyle \mathit{bd}_r \land \bigwedge _{a_j\in H(r), i \neq j } \neg a_j \ \ \leftrightarrow \ \ \mathit{sp}_{r}^{a} \end{align}

Furthermore, we add the following clause ensuring that the rule is satisfied:

(31) \begin{align} \textstyle \bigvee _{a \in H(r)} a \ \lor \neg \mathit{bd}_r \end{align}

Otherwise, $r$ is a choice rule or $|H(r)| = 1$ . For each $a \in H(r)$ we add the constraint

(32) \begin{align}\mathit{sp}_r^{a} \leftrightarrow \mathit{bd}_r & \text{ if } \mathit{SCC}_P(a) \cap B^+(r) = \emptyset\end{align}

(33) \begin{align}\text{ and }\quad \mathit{sp}_r^{a} \leftrightarrow \mathit{bd}_{r}^{a} & \text{ otherwise}.\end{align}

Note that these constraints define the support variables as the respective rule bodies, and thus would make them redundant. However, we keep them to ease readability and for formulating further constraints. Furthermore, if $r$ is not a choice rule, we add:

(34) \begin{align} \mathit{sp}_{r}^{a} \rightarrow a \end{align}

Supportedness constraints $\boldsymbol{TrSupp(P)}$ . It remains to encode the supportedness condition of a model. This is achieved by adding for each $a \in {\mathcal{A}_P} \setminus {{\mathcal{A}_P}^{\mathit{lin}}}$ the following clause to $\mathit{TrSupp(P)}$ :

(35) \begin{align} \textstyle \bigvee _{r \in P, a \in H(r)} \mathit{sp}_{r}^{a} \lor \neg a \end{align}

4.2 Correctness

That ${\mathit{Tr}}(P)$ captures the answer sets of a CASP program $P$ faithfully in a 1-1 correspondence is shown in several steps. We view e-interpretations as models of ${\mathit{Tr}}(P)$ with the usual semantics. The following lemma is useful (cf. Def. 2 for partially shifted programs).

Based on this lemma and Proposition2, we obtain that the translation is sound.

Conversely, we show also completeness.

Theorems1 and 2 establish a many-to-one mapping between the models of the translation and the answer sets of the program. That the mapping is in fact 1-1 is achieved through correspondence constraints given by (15), (16), (21), (23), (26), (27), (28), and the gap variables, which – as for Janhunen (Reference Janhunen2023) – ensure that the level mapping is strict, that is, has no gaps and starts at 1.

For the implementation and the experiments, we also consider a non-strict version of the translation without the mentioned constraints, where Theorem3 does not hold.

6.1 ASP benchmarks

We compare asp-fzn 0.1.0 with ASP solvers clingo 5.7.1 (Gebser et al. Reference Gebser, Kaminski, Kaufmann and Schaub2019) and DLV 2.1.0 (Alviano et al. Reference Alviano, Calimeri, Dodaro, Fuscà, Leone, Perri, Ricca, Veltri and Zangari2017) on benchmarks from ASP competitions (Alviano et al. Reference Alviano, Calimeri and Charwat2013; Calimeri et al. Reference Calimeri, Ianni and Ricca2014; Calimeri et al. Reference Calimeri, Gebser, Maratea and Ricca2016). As backend solvers for asp-fzn, we used the MIP solver Gurobi 12.0.1 (Gurobi Optimization, LLC, 2025) and CP solvers CP-SAT 9.12.4544 from Google OR-Tools (Perron et al. Reference Perron, Didier and Gay2023) and Chuffed 0.13.2 (Chu Reference Chu2011).

Both CP-SAT and Chuffed are lazy-clause generation based, which is a method taken from SMT and has been highly effective for CP solving. In particular, CP-SAT has won the gold medal in the MiniZinc ChallengeFootnote ⁴ for the last years. Gurobi on the other hand is a state-of-the-art, proprietary MIP solver, which has a MiniZinc interface. We ran all solvers using default settings, except for CP-SAT (interleaved search enabled). For asp-fzn, we used gringo 5.7.1 for grounding and MiniZinc 2.9.2 (Nethercote et al. Reference Nethercote, Stuckey, Becket, Brand, Duck and Tack2007) to interface Gurobi and for output formatting, and we considered two settings: the strict translation ${\mathit{Tr}}(P)$ with a 1-1 mapping between the models of ${\mathit{Tr}}(P)$ and ${\mathit{AS}}(P)$ , and the non-strict many-to-one variant.

We included both decision and optimization problems in the benchmark, listed in Table 1, with 31 problems and 772 instances in total. We used the encodings from the competition, but replaced in few some parts with modern constructs like choice rules. Note that the decision variants of all problems, except StableMarriage, are NP-hard and several encodings are non-tight.

Table 1. ASP problems, $n$ instances, type T = (o)ptimization $\mid$ (d)ecision, (*) non-tight

Table 2 presents the comparison of asp-fzn with clingo and DLV, and cactus plots can be found in Appendix A. Here $\mathit{Score1} = \sum _{i=1}^{31} c_i/n_i * 100$ where $c_i$ is the number of closed instances of domain $D_i$ , that is, shown to be (un)satisfiable for type $d$ resp. optimal for type $o$ ; the maximum score is 3100. Score2 measures the best performers, by $\mathit{Score2} = \sum _{i=1}^{31} b_i/n_i * 100$ , where $b_i$ is the number of instances from $D_i$ where the solver either closed the instance or found a solution of best value among all solvers.

Table 2. Comparison of asp-fzn with ASP solvers on plain ASP benchmarks. The symbols next to the score indicate whether a higher value ( $\uparrow$ ) or lower value ( $\downarrow$ ) is better

Lastly, $\mathit{Score3} = \sum _{i=1}^{31} t_i/n_i$ is the PAR10 score, where $t_i$ is the time the solver took to complete instance $i$ respectively $10\times 1200$ if the solver did not complete the instance. Hence, here a lower number is better.

In single-threaded mode, clingo performs best on Score1, but asp-fzn with CP-SAT as backend is trailing closely behind, beating DLV. Under the non-strict translation, asp-fzn performs slightly better on Score1 and significantly better on Score2 . Furthermore, clingo also has the best Score3, indicating it is also closing most instances quicker than the rest; however, asp-fzn with CP-SAT under the non-strict translation is only 1.37% worse than clingo. Gurobi and Chuffed as backends perform worse than CP-SAT, but the non-strict variant is also better here. This difference between strict and non-strict variants is similar to previous observations for translation-based ASP solving (Janhunen et al. Reference Janhunen, Niemelä and Sevalnev2009). It seems non-strictness does not interfere with search-tree pruning.

For space reasons, we cannot give a detailed breakdown of the results over the particular problem domains, but unsurprisingly asp-fzn performs worse than clingo mostly on domains which are non-tight or feature heavy usage of disjunctions. An exception here is the Traveling Salesperson Problem where asp-fzn using CP-SAT or Gurobi outperforms clingo. Except for a few further non-tight domains, like Bayesian Network Learning and Systems Synthesis, Gurobi achieves worse results than CP-SAT as a backend solver.

Since clingo, Gurobi, and CP-SAT support parallel solving, we ran the benchmark on them using 8 threads. Again, clingo was best, cf. Table 2; while asp-fzn performed better with Gurobi and CP-SAT, the gap to clingo widened. Nonetheless, the benchmarks show that asp-fzn with the right backend solver is competitive with known ASP solvers.

6.2 CASP benchmarks

We now turn our attention to CASP. We look at three problem domains with ASP benchmark instances from the literature that can be modeled with CASP. We compare asp-fzn against clingcon 5.2.1 (Banbara et al. Reference Banbara, Kaufmann, Ostrowski and Schaub2017) as it supports a similar language.

Parallel Machine Scheduling Problem (PMSP) was first studied with ASP by Eiter et al. (Reference Eiter, Geibinger, Musliu, Oetsch, Skocovský and Stepanova2023), who provided a benchmark set of 500 instances. The task is assigning jobs with release dates and sequence-dependent setup times to capable machines. The objective is minimizing the total makespan, that is, the maximal completion time of any job.

Table 3 shows the results for PMSP on the 500 instances using the (non-tight) CASP encoding which for space reasons is given in the appendix. In single-threaded solving, asp-fzn with CP-SAT and the non-strict translation is again superior, closing 40 instances and achieving the best result for 166; the strict translation is slightly worse but closes the same number of instances. The solver clingcon closed 36 instances, which is more than asp-fzn with any of the other backend solvers.

Table 3. asp-fzn vs. clingcon on PMSP (strict / non-strict)

Looking at the PAR10 score, cf. Section 6.1, we see that asp-fzn with CP-SAT achieves the best score, indicating that it can close the instances faster than clingcon. Interestingly, the strict translation does better here but the difference is marginal.

The picture changes for multi-threaded solving: here clingcon achieved the top value for best with 298 instances versus 167 by asp-fzn with CP-SAT for the non-strict translation. The latter setting closed the second most instances (54); changing to the strict translation closed one instance but decreased best results. The large number of best results found by clingcon can be explained by its strength in finding feasible solutions for PMSP in parallel mode, while asp-fzn struggles. However, when a solution is found, asp-fzn and CP-SAT typically provide the best final result and as the PAR10 score shows, it also takes the least CPU time to prove optimality.

Test Laboratory Scheduling Problem (TLSPS) is a variant of a scheduling problem due to Mischek and Musliu (Reference Mischek and Musliu2018), that is, efficiently solvable using a CASP encoding (Geibinger et al. Reference Geibinger, Mischek and Musliu2021; Eiter et al. Reference Eiter, Geibinger, Ruiz, Musliu, Oetsch, Pfliegler and Stepanova2024). As the encoding is tight, the strict and the non-strict translation are the same.

TLSPS concerns scheduling jobs in a test lab by assigning them an execution mode, a starting time in its time window, and required resources from a set of qualified resources. The overall objective has several components, like assigning preferred employees for certain jobs, minimizing the number of employees on a project, reducing tardiness, and minimizing the project duration.

For clingcon, we essentially use Eiter et al.’s (Reference Eiter, Geibinger, Ruiz, Musliu, Oetsch, Pfliegler and Stepanova2024) encoding employing ASP minimization. The asp-fzn encoding, shown partially in Listing 2 (full version in Appendix A), mixes minimization of plain ASP and linear variables; clingcon does not support the latter, but allows for a more natural encoding of the objective. Also, the asp-fzn encoding uses global disjunctive constraints to enforce unary resource usage; this is not possible in clingcon but proved to be quite effective.

Fig 2. Partial TLSPS encoding used by asp-fzn.

Our benchmark consisted of 123 instances from Mischek and Musliu (Reference Mischek and Musliu2018) of which 3 are real-world; the instances were converted to ASP facts (see supplementary data).

The results, collected in Table 4, show that asp-fzn performed very well. Column closed lists how many instances were solved and proven optimal, and best lists the number of solutions that were best among all solvers; instances for which no solver found any solution were discarded. Our tool asp-fzn with backend CP-SAT performed best for TLSPS in single-threaded mode as it solved 55 instances to optimality and produced for 76 instances the best result. Furthermore, it also achieved the lowest, and thus best, PAR10 score. With backend Chuffed, asp-fzn performed significantly worse but produced always best results; also clingcon lagged significantly behind. Gurobi was not used as it does not support disjunctive global constraints. With multi-threaded solving, clingcon outperformed asp-fzn and CP-SAT, closing more instances and more often yielding the best result, while also taking less time to prove optimality on average.

Table 4. asp-fzn vs. clingcon on TLSPS

Table 5. asp-fzn vs. clingcon on MAPF

Multi agent path finding (MAPF) was recently studied by Kaminski et al. (Reference Kaminski, Schaub, Son, Svancara and Wanko2024), who provided an instances and a generator. The task is planning the routes of several agents to reach their goals without colliding. Our tight CASP encoding (see Appendix A) is similar to Kaminski et al.’s (2024) but uses linear constraints for the event ordering.

For our comparison, we selected 547 MAPF instances from one of the sets by Kaminski et al. The results are shown in Table 5, listing the number of instances for which a plan was found (MAPF has no optimization objective). With Gurobi and CP-SAT as backends, asp-fzn closed more instances than clingcon, but it closed fewer with Chuffed. The best result is achieved by asp-fzn and CP-SAT with 224 instances solved; it also achieves the best PAR10 score. For parallel solving (8 threads), asp-fzn with CP-SAT closed the most instances (233, 9 more than single-threaded). Gurobi did not benefit from parallelism while it improved the clingcon results. However, the latter still lagged behind CP-SAT.

6.3 Summary

Overall, asp-fzn with CP-SAT as backend achieved decent results, being competitive as a plain ASP solver and performing better than clingcon for TLSPS and MAPF. However, we note that CP-SAT has a rather high memory footprint. The average total memory usage of clingo on the plain ASP benchmark was five times lower than the one of asp-fzn with CP-SAT and the latter hit the memory limit for several instances. This is not only due to the translation itself, but a high memory usage of CP-SAT in general.

Regarding strict versus non-strict translation, it appears beneficial to use the non-strict translation by default, except when solution enumeration is requested. The time it takes to translate the gringo output to FlatZinc, this never took longer than a couple of seconds and was dwarfed by the grounding time.