1 Constructing definite clause programs

Here we briefly present a method of Drabent (Reference Drabent2018). For this we first informally describe the main concepts related to program correctness. For further details and references see the papers by Drabent (Reference Drabent2016, Reference Drabent2018) and Apt (Reference Apt1997). Definite clause programs will be called shortly positive programs.

In imperative (or functional) programming, a central notion is partial correctness. A program is partially correct if its termination implies its compatibility with the specification. In logic programming this divides into two notions: correctness and completeness. Correctness of a program $P$ w.r.t. (with respect to) a specification $S$ means that each answer of $P$ is compatible with $S$ , completeness – that each answer required by $S$ is an answer of $P$ . More technically: A specification is an Herbrand interpretation. A program $P$ with the least Herbrand model ${\mathcal{M}}_P$ is correct w.r.t. a specification $S$ if ${\mathcal{M}}_P\subseteq S$ . It is complete w.r.t. $S$ if $S\subseteq {\mathcal{M}}_P$ .

By an answer of a positive program $P$ we mean any query $Q$ such that $P\models Q$ . (Answer is sometimes called correct, or computed, instance of a query (Apt Reference Apt1997, Definition 4.6, 3.6).) In practice, if Prolog succeeds for $P$ and a query $Q_0$ with a substitution $\theta$ then $Q_0\theta$ is an answer for $P$ . For a program $P$ correct w.r.t. $S$ , each answer $Q$ of $P$ is compatible with $S$ (i.e. $S\models Q$ ); for $P$ complete w.r.t. $S$ , each ground answer $Q$ required by $S$ (i.e. $S\models Q$ ) is an answer of $P$ .

Proving correctness. There exists a simple (however often forgotten) way of proving correctness of positive programs: A sufficient condition for $P$ being correct w.r.t. $S$ is $S\models P$ (Clark Reference Clark1979). (In other words, the sufficient condition is that for each ground instance of a clause of $P$ , if the body atoms are in $S$ then the head is in $S$ .) Informally: any clause applied to correct atoms produces a correct atom.

Proving completeness. We need some auxiliary notions. A ground atom $A$ is covered (Shapiro Reference Shapiro1983) w.r.t. $S$ by a clause $C$ , if $C$ has a ground instance $A\mathop \gets B_1,\ldots , B_n$ and $B_1,\ldots, B_n\in S$ (informally: if $A$ can be produced by $C$ from $S$ ). Given a specification $S$ , program $P$ is complete for a query $Q$ if, speaking informally, it produces all the answers for $Q$ required by $S$ . $P$ is semi-complete if it is complete for any query for which there exists a finite SLD-tree. To reason about completeness, it is convenient to deal with semi-completeness and termination separately. Often a proof of completeness is similar to a proof of semi-completeness together with a proof of termination; and the termination has to be established anyway.

Again, there is a simple sufficient condition for semi-completeness: If each atom from $S$ is covered w.r.t. $S$ by a clause of $P$ then $P$ is semi-complete w.r.t. $S$ (Drabent Reference Drabent2016). Informally: any atom required to be produced can be produced by a clause of the program out of atoms required to be produced.

It is surprising that reasoning about completeness was often neglected. For example, an important monograph by Apt (Reference Apt1997) does not even mention the notion of program completeness. Completeness for positive programs was dealt with by Deransart and Małuszyński (Reference Deransart and Małuszyński1993), Drabent and Miłkowska (Reference Drabent and Miłkowska2005), Drabent (Reference Drabent2016), and for normal programs by Malfon (Reference Malfon and Bruynooghe1994) and Drabent and Miłkowska (Reference Drabent and Miłkowska2005). Sterling and Shapiro (Reference Sterling and Shapiro1994) discuss completeness informally.

Approximate specifications. An important observation is that many issues can be simplified if we consider separate specifications for correctness and completeness (Drabent and Miłkowska Reference Drabent and Miłkowska2005; Reference DrabentDrabent 2016, Reference Drabent2018). A single specification for both has to exactly describe the least Herbrand model of a program. This is often too troublesome (and not necessary). For instance, it is unimportant how append/3 of Prolog behaves on non list arguments, or what happens when the second argument of member/2 is not a list, or how insert/3 of insertion sort inserts a number into a not sorted list. Moreover, in program construction we should not fix in advance the behaviour of the future program in such unimportant cases. (In the main example of the paper by Drabent (Reference Drabent2018), such behaviour is different in consecutive versions of the program; otherwise an efficient version could not have been obtained.) A pair $(S_{\textit {compl}},S_{corr})$ of specifications for completeness and correctness, where $S_{\textit {compl}}\subseteq S_{corr}$ , will be called approximate specification. A program with the least Herbrand model ${\mathcal{M}}_P$ will be called fully correct w.r.t. $(S_{\textit {compl}}, S_{corr})$ if $S_{\textit {compl}}\subseteq {\mathcal{M}}_P\subseteq S_{corr}$ .

Program construction. The above sufficient conditions for semi-completeness and correctness suggest a method (Drabent Reference Drabent2018) of constructing a program, given a specification $(S_{\textit {compl}}, S_{corr})$ . Due to the condition for semi-completeness, we need (A) to construct clauses $C_1,\ldots, C_n$ so that each atom from $S_{\textit {compl}}$ is covered w.r.t. $S_{\textit {compl}}$ by some of them. For correctness we need that (B) $S_{corr}\models C_i$ for each such $C_i$ . This leads to a provably correct and semi-complete program. We also need that (C) the clauses are chosen so that the program terminates for queries of interest.

Termination is kept outside of the proposed rigorous method. One may use any way of proving termination; when applying the method informally, one uses the usual hints of Prolog programming craft, like using in the body proper subterms of the terms in the head.

2 Preliminaries

Basic notions. We assume that the reader is familiar with basics of logic programming and use the standard definitions and notation (Apt Reference Apt1997; Apt and Bol Reference Apt and Bol1994). A maybe nonstandard notion is (computed or correct) answer; by this we mean a query to which a (computed or correct) answer substitution has been applied. We assume a fixed set of function symbols (including constants) and of predicate symbols. $\mathcal{H U}$ stands for the Herbrand universe, and $\mathcal{H B}$ for the Herbrand base; $ground(P)$ is the set of ground instances of the clauses of a program $P$ . $\mathbb{N}$ is the set of natural numbers. We deal with normal (Lloyd Reference Lloyd1987) programs (called also “general” (Apt and Bol Reference Apt and Bol1994)), and we usually call them just “programs.” A procedure is a set of clauses beginning with the same predicate symbol.

Given a set $S\in {\mathcal{H B}}$ of ground atoms, $\neg S$ will stand for $\{\neg A \mid A\in S\,\}$ . By a level mapping we mean a function $|\ |\colon S\to W$ , where $S\subseteq {\mathcal{H B}}$ and $(W,\prec )$ is a well-ordered set (i.e. one in which there does not exist an infinite decreasing sequence).

4-valued logic. This logic plays an auxiliary role in the paper, and at the first reading the references to it may be skipped. We employ Belnap’s 4-valued logic. The truth values are the subsets of the set of two standard truth values t and f. The subsets $\emptyset ,\{\textbf {t}\},\{\textbf {f}\},\{\textbf {t},\textbf {f}\}$ will be denoted by $\textbf {u},\textbf {t},\textbf {f},\textbf {tf}$ , respectively. The rationale for the four values is that a query, apart from succeeding (t) and failing (f), may diverge (u); additionally a specification may permit it both to succeed and to fail (tf). A 4-valued Herbrand interpretation is a subset of ${\mathcal{H B}}\cup \neg {\mathcal{H B}}$ . (We will often skip the word “Herbrand.”) If such interpretation does not contain both $A$ and $\neg A$ (for any $A\in {\mathcal{H B}}$ ) then it is said to be 3-valued. Consider an interpretation $I\subseteq {\mathcal{H B}}\cup \neg {\mathcal{H B}}$ , and a ground atom $A\in {\mathcal{H B}}$ . The truth value $v\subseteq \{\textbf {t},\textbf {f}\}$ of $A$ in $I$ is determined as follows: $\textbf {t}\in v$ iff $A\in I$ , and $\textbf {f}\in v$ iff $\neg A\in I$ . We may briefly say that $A$ is $v$ in $I$ , for example, $p$ is tf and $q$ is u in $\{p,\neg p\}$ . We write $I,\vartheta \models _4 F$ (respectively $I\models _4 F$ ) to state that the truth value of a formula $F$ in an interpretation $I$ and a variable valuation $\vartheta$ (resp. all variable valuations) contains t. When $I$ is 3-valued, $I\models _3$ stands for $I\models _4$ . The logical operations $\land ,\lor$ are defined, respectively, as the glb (lub) in the lattice $(\{\textbf {t},\textbf {f}\},\preceq _t)$ , where $\textbf {f}\preceq _t\textbf {u}\preceq _t\textbf {t}$ , $\textbf {f}\preceq _t\textbf {tf}\preceq _t\textbf {t}$ , and $\textbf {tf},\textbf {u}$ are incomparable. The negation is defined by $\neg \textbf {t}=\textbf {f}$ , $\neg \textbf {f}=\textbf {t}$ , $\neg \textbf {u}=\textbf {u}$ , $\neg \textbf {tf}=\textbf {tf}$ . See the work by Stärk (Reference Stärk1996) or Fitting (Reference Fitting1991) for the treatment of $\leftrightarrow$ , and further explanations.

Using standard logic. In this work we prefer to avoid dealing with technical details of 4-valued logic. Instead we encode it in the standard 2-valued logic. Such approach is maybe less elegant, but it seems convenient to work within a well-known familiar logic. We extend the underlying alphabet by adding new predicate symbols, a distinct new symbol $p'$ for each predicate symbol $p$ (except for $=$ ). For the encoding, we use the following notation (Drabent and Martelli Reference Drabent and Martelli1991; Drabent Reference Drabent1996).

Let $\mathcal F$ be a query, the negation of a query, a clause, or a program. Then $\mathcal F'$ is $\mathcal F$ with $p$ replaced by $p'$ in every negative literal of $\mathcal F$ (for any predicate symbol $p$ ). Similarly, $\mathcal F''$ is $\mathcal F$ with $p$ replaced by $p'$ in every positive literal. If $I\in {\mathcal{H B}}$ is a (2-valued) Herbrand interpretation then $I'$ is the interpretation obtained from $I$ by replacing each predicate symbol $p$ by $p'$ . For example for a clause $C=a\mathop \gets \neg b,c$ , we have $C'=a\mathop \gets \neg b',c$ , and $C''=a'\mathop \gets \neg b,c'$ . Let $I=\{a,c\}$ , $J=\{c\}$ . Then $I\cup J'\models C'$ and $I\cup J'\mathrel {\,\not \!\models } C''$ (as $J'=\{c'\}$ ). Consider a 4-valued interpretation $I=X\cup \neg ({\mathcal{H B}}\setminus Y)$ (where $X,Y\in {\mathcal{H B}}$ ). For a query $Q$ , we have $I\models _4 Q$ iff $X\cup Y'\models { Q}'$ and $I\models _4\neg Q$ iff $X\cup Y'\models \neg Q''$ .

Negation in Prolog, Kunen semantics. Here we present a brief discussion, for missing details see, for example, the work by Apt and Bol (Reference Apt and Bol1994) or Doets (Reference Doets1994).

A natural way of adding negation to Prolog was negation as failure (more precisely, negation as finite failure, NAFF). This means deriving $\neg Q$ if a query $Q$ finitely fails, that is, has a finite SLD-tree without answers. (In Prolog, ${\mathtt {\backslash +}} Q$ fails if $Q$ succeeds, and succeeds when $Q$ terminates without any answer.) The corresponding operational semantics for normal programs is SLDNF-resolution (cf. Section 4.2).

The appropriate declarative semantics for NAFF was proposed by Kunen (Kunen Reference Kunen1987; Apt and Bol Reference Apt and Bol1994). (We will call it Kunen semantics, KS or completion semantics.) It is defined by means of logical consequences of the program completion $comp(P)$ (Clark Reference Clark, Gallaire and Minker1978) in a 3-valued logic of Kleene;Footnote ¹ a query $Q$ (resp. its negation $\neg Q$ ) is a result of a program $P$ when $comp(P)\models _3 Q$ (resp. $comp(P)\models _3\neg Q$ ). So soundness (of some operational semantics) w.r.t. KS means that if $Q$ with $P$ succeeds with a computed answer $Q\theta$ then $comp(P)\models _3 Q\theta$ , and if $Q$ fails then $comp(P)\models _3\neg Q$ . Completeness means the implications in the other direction.

Kunen semantics properly describes NAFF and SLDNF-resolution: First, SLDNF-resolution is sound w.r.t. the Kunen semantics, and is complete for wide classes of programs and queries. Also, it can be shown that the only reasons for incompleteness are floundering (cf. Section 4.2) or non-fair selection rule (Drabent Reference Drabent1996). Moreover, natural ways of augmenting SLDNF-resolution by constructive negation (Stuckey Reference Stuckey1991; Drabent Reference Drabent1995) are sound and complete w.r.t. this semantics.

The well-founded semantics. The suitable declarative semantics for normal programs with negation as (possibly infinite) failure (NAF) is the well-founded semantics (WFS). It is given by a specific 3-valued well-founded model $\textit{WF}(P)$ of a given program $P$ (Reference Van Gelder, Ross and SchlipfVan Gelder et al. 1991; Apt and Bol Reference Apt and Bol1994). WFS is not computable – it is in general impossible to check whether an infinite tree fails. An operational semantics for WFS is SLS-resolution (cf. Section 6.2). SLS-resolution is sound w.r.t. WFS, and complete for non-floundering queries (Ross Reference Ross1992; Apt and Bol Reference Apt and Bol1994). NAF and SLS-resolution are approximately implemented by Prolog with tabulation. The methods proposed in this paper depend on soundness of SLDNF- and SLS-resolution, but not on their completeness.

3 Specifications for the context of negation

Here we show how approximate specifications from Section 1 can be used for normal programs. This section is independent from the choice of semantics for negation. When we do not deal with negation, a specification describes which atoms may succeed, and which ones have to succeed. Now we also need to specify which atoms should/may fail. This would require four interpretations, which is cumbersome. However it is rather natural to demand that the (ground) atoms required to succeed are not allowed to fail, and those not allowed to succeed should fail. So a pair of interpretations as a specification will be treated from two points of view, as a specification for correctness, and for completeness (Drabent and Miłkowska Reference Drabent and Miłkowska2005).

We usually drop the adjective “approximate.” The letters $\textit{nf},t$ stand for “not false,” and “true” (cf. the 4-valued view of Definition 5). Comparing with Section 1, Snf corresponds to a specification for completeness, and St to that for correctness. The diagram illustrates a proper specification $spec=(\textit {Snf},\textit {St})$ , and the ground atomic queries that succeed/fail for a program $P$ which is correct and complete w.r.t. $spec$ .

Considering program correctness, informal understanding of a specification $(\textit {Snf},\textit {St})$ is that $A\in \textit {St}$ means that $A$ can be (an instance of) an answer of the program; and $ A\in {\mathcal{H B}}\setminus \textit {Snf}$ means that the query $A$ can fail (and $\neg A$ can be an instance of an answer). Hence, any atom $A\in \textit {St}\setminus \textit {Snf}$ is allowed both to succeed and fail, and any $A\in \textit {Snf}\setminus \textit {St}$ is neither allowed to succeed, nor to fail.

So, in the notation introduced in Section 2, for any answer $Q$ of a program $P$ correct w.r.t. $(\textit {Snf},\textit {St})$ we have $\textit {St}\cup \textit {Snf}^{\;\prime} \models Q'$ . Also, if $Q$ with $P$ fails then $\textit {St}\cup \textit {Snf}^{\;\prime} \models \neg Q''$ .

Considering program completeness, specification $(\textit {Snf},\textit {St})$ requires any atom $A\in \textit {Snf}$ to succeed, and any $A\in {\mathcal{H B}}\setminus \textit {St}$ to fail. So $\textit {St}\cup \textit {Snf}^{\;\prime} \models Q''$ means that $Q$ is required to be program answer; $\textit {St}\cup \textit {Snf}^{\;\prime} \models \neg Q'$ means that $Q$ is required to fail. A non proper specification makes no sense in the context of completeness, as it requires some atoms to both succeed and fail.

As an example, consider specification $(r,r_+)$ for a list membership predicate from Example 1. It is proper, and it says that the atoms from $r$ (resp. $r_+$ ) must (may) succeed (hence those from ${\mathcal{H B}}\setminus r_+$ cannot succeed). Taken negation into account, it also states that the atoms from ${\mathcal{H B}}\setminus r$ (resp. ${\mathcal{H B}}\setminus r_+$ ) may (must) fail (hence those from $r$ cannot fail).

The following definition provides a 4-valued logic view at approximate specifications.

4 Correctness and completeness, Kunen semantics

In this section we present sufficient conditions for correctness and semi-completeness for normal programs under Kunen semantics.

5 Systematic construction of programs, Kunen semantics

Theorems 8 and 14 suggest the following method: To build a program $P$ which is correct and SLDNF-semi-complete (hence semi-complete) under the Kunen semantics w.r.t. a given specification $spec=(\textit {Snf},\textit {St})$ , construct clauses so that

1. (A) each atom from $\textit {Snf}$ is covered by some clause $C\in P$ w.r.t. $spec$ , and

2. (B) $\textit {St}\cup \textit {Snf}^{\;\prime}\models C'$ , for each constructed clause $C\in P$ .

The program obtained in this way is correct w.r.t. $spec$ (by Theorem 8) and SLDNF-semi-complete w.r.t. $spec$ (by Theorem 14). For the program to be useful, care should be taken to (C) choose the clauses so that the program terminates and does not flounder for queries of interest. If the constructed program does not diverge for each ground query (under some selection rule) then it is complete w.r.t. $spec$ .

Example 16 (Paths in a graph). Consider a directed graph $G$ with the edges described by a predicate $e$ /2 (possibly given by a set of facts), correct and complete w.r.t.

\begin{equation*} (\textit {St}_e,\textit {St}_e) \qquad \mbox{where}\qquad \textit {St}_e = \{\, e(t,u)\in {\mathcal{H B}} \mid \mbox{there is an edge $(t,u)$ in }G\, \}. \end{equation*}

Let us construct a program finding paths between a given pair of nodes. We know that a naive program for transitive closure may miss some expected results for graphs with loops, due to negation by finite failure, cf. Example 11. To obtain a usable program, we add an argument with (a list of) nodes that should not be included in the path.

To construct a specification, let us introduce two auxiliary notions. By a simple path we mean one which does not visit a node twice (i.e. a $[t_1,\ldots ,t_n]$ where $t_i\neq t_j$ for any $i\neq j$ ). We say that a path $[t_1,\ldots ,t_n]$ bypasses a node $e$ when $e\not \in \{ t_2,\ldots ,t_{n-1}\}$ . It bypasses a list of nodes if it bypasses every node from the list. Now consider

Our current specification for the program is $spec_0=(\textit {Snf}_p\cup \textit {St}_e, \, \textit {St}_p\cup \textit {St}_e )$ . Informally speaking, it implies that answers of the form $p(t,v,s,[\,])$ provide (all) the simple paths from $t$ to $v$ in $G$ .

Procedure $e$ /2 defining the graph is given, it remains to construct procedure $p$ /4. For each atom from $\textit {Snf}_p$ we need a clause covering it. Consider an atom $A_1 = p(t,t,s,u)\in \textit {Snf}_p$ . Note that $s=[t]$ , as the path is simple. $A_1$ is covered by a fact $C_1= p(X,X,[X],\mathtt {\_})$ (which satisfies (B), as $C_1'=C_1$ and $\textit {St}_p\models C_1$ ).

Consider an atom $A_2 = p(t,v,s,u)\in \textit {Snf}_p$ , where $t\neq v$ . Then $s=[t|s_1]$ for a simple path $s_1$ from a node $t_1$ ( $t_1\neq t$ ) to $v$ , so that $(t,t_1)$ is an edge in $G$ . As $s$ bypasses $u$ , $t_1\not \in u$ and $s_1$ bypasses $u$ . Also, $s_1$ bypasses $t$ , as otherwise $s$ is not simple.

A candidate for a ground clause covering $A_2$ could be $C_{20}=p(t,v,[t|s_1],u)\gets e(t,t_1), p(t_1,v,s_1,[t|u]).$ However, it is easy to see that it would violate (B) (and lead to an incorrect program). We need to assure that $t\neq t_1$ and $t_1\not \in u$ , in other words $t_1\not \in [t|u]$ . For this it is convenient to employ a list membership program $M$ from Example 2, with specification $spec_m=(r,r_+)$ , where $r= \{\, m(e_i,[e_1,\ldots ,e_n])\in {\mathcal{H B}} \mid 1\leq i\leq n \,\}$ , and $r_+= r\cup \{\, m(e,u)\in {\mathcal{H B}} \mid u \mbox{ is not a list} \,\}$ . Our specification becomes

\begin{equation*} spec=(\textit {Snf},\textit {St}), \quad \mbox{where}\quad \textit {Snf} = \textit {Snf}_p\cup \textit {St}_e\cup r, \quad \textit {St} = \textit {St}_p\cup \textit {St}_e\cup r_+. \end{equation*}

Consider a clause

\begin{equation*} C_2 = p(T,T1,[T|S],U)\gets e(T,T2),\neg {m(T2,[T|U])}, p(T2,T1,S,[T|U]). \end{equation*}

and its ground instance

\begin{equation*} C_{21}= \underbrace {p(t,v,[t|s_1],u)}_H \gets \underbrace {e(t,t_1)}_{B_1}, \neg \underbrace {m(t_1,[t|u])}_{B_2}, \underbrace {p(t_1,v,s_1,[t|u])}_{B_3}. \end{equation*}

Condition (A) holds: Assume $H=A_2$ and $t_1$ as above. Then $C_2$ covers $A_2$ w.r.t. $spec$ , as $B_1,B_3\in \textit {Snf}$ and $B_2\not \in \textit {St}$ , due to the facts described above. (E.g. $B_3\in \textit {Snf}$ as $s_1$ is a simple path from $t_1$ to $v$ ; and $s_1$ bypasses $t$ and the nodes in $u$ .)

To show that $C_{21}$ satisfies condition (B) (i.e. $\textit {St}\cup \textit {Snf}^{\;\prime}\models C_{21}'$ for each ground instance $C_{21}$ of $C_2$ ), assume that $B_1,B_3\in \textit {St}$ and $B_2\not \in \textit {Snf}$ . We have to show that $H\in \textit {St}_p$ . This is immediate if $u$ is not a list. Otherwise $[t|u]$ is a list. Hence from $B_3\in {St}$ , we obtain that $s_1$ is a simple path from $t_1$ to $v$ bypassing $[t|u]$ . So $[t|s_1]$ is a path from $t$ to $v$ (by $B_1\in {St}$ ). From $B_2\not \in \textit {Snf}$ we obtain (as $[t|u]$ is a list) that $t_1\not \in [t|u]$ . So $t_1\neq t$ and thus path $[t|s_1]$ is simple. Also $[t|s_1]$ bypasses $u$ , as the first element $t_1$ of $s_1$ does not occur in $u$ and $s_1$ bypasses $u$ . Hence, $H\in {St}_p$ .

Thus the constructed program $\textit{PATH} = \{C_1,C_2\}\cup M$ is correct and SLDNF-semi-complete w.r.t. $spec$ ,

We explain that, under the Prolog selection rule, the main SLDNF-tree for PATH and a query $Q_0=p(t_0,t_1,s,u_0)$ (where $t_0,u_0$ are ground) does not diverge. Whenever $\neg m(\ldots )$ is selected, its arguments are ground, so the subsidiary tree (for $ m(\ldots )$ ) is finite. This implies lack of floundering. On each path in the main tree, every third element is of the form $Q_{3i}=p(t_i,t_1,s_i,u_i)$ ( $i\geq 0$ ), where $t_i\not \in u_i$ for $i\gt 0$ , and $u_i=[t_{i-1},\ldots ,t_0|u_0]$ . So $t_{i-1},\ldots ,t_0$ are distinct nodes of $G$ , which is finite. Thus every such path is finite, the tree does not diverge, and thus $\textit{PATH}$ is complete w.r.t. $spec$ .

6 The well-founded semantics

This section presents sufficient conditions for program correctness and semi-completeness under the well-founded semantics.

7 Construction of programs, the well-founded semantics

Theorems 18, 22 suggest the following method: To build a program $P$ correct and SLS-semi-complete (hence semi-complete) under WFS w.r.t. a specification $spec=(\textit {Snf},\textit {St})$ , choose a level mapping $|\ |\colon \textit {Snf}\to W$ to a well-ordered set $(W,\prec )$ , and construct clauses so that

1. (A) each atom $A\in \textit {Snf}$

1. (1) is covered by a ground instance $A\gets \vec L$ of a constructed clause $C$ , so that

2. (2) for each positive literal $L$ from $\vec L$ , $|L|\prec |A|$ ,

1. (B) $\textit {St}\cup \textit {Snf}^{\;\prime}\models C'$ , for each constructed clause $C$ .

For the obtained program to be useful, care should be taken to (C) choose the clauses so that the program does not diverge for the queries of interest. If the constructed program does not diverge for each ground query (under some selection rule), then it is complete w.r.t. $spec$ .

Example 23. We construct a procedure $p$ /2 finding, under the well-founded semantics, whether two nodes of a given finite directed graph $G$ are connected. The specification is

\begin{equation*} spec=(\textit {Snf},\textit {St}), \ \mbox{where} \begin{array}[t]{l} \textit {St} = \textit {Snf} = \textit {St}_e\cup \textit {St}_p, \\ \kern-4.2pt\textit {St}_e = \{\, e(t,u)\in {\mathcal{H B}} \mid \mbox{there is an edge $(t,u)$ in }G\, \}, \\ \kern-4.2pt\textit {St}_p = \left \{ p(t,u)\in {\mathcal{H B}} \mid \mbox{there is a path from $t$ to $u$ in $G$ } \right \}. \end{array} \end{equation*}

Treating $\textit {St}_e$ as a set of facts provides a procedure $e$ /2 correct and complete w.r.t. $spec$ . To construct $p$ /2 let us first choose the level $|p(t,u)|$ to be the length of the shortest path from $t$ to $u$ (for any $p(t,u)\in \textit {St}_p$ ), and let $|e(t,u)|=0$ (for any $e(t,u)\in \textit {St}_e$ ). Now we need to construct clauses so that each atom $p(t,u)\in \textit {St}_p$ is covered. A border case is $t=u$ , for this we use a fact $C_1=p(X,X)$ (for which (A)(1), (A)(2), (B) obviously hold). For $t\neq u$ , there exists an edge $(t,s)$ to a node $s$ connected with $u$ . This suggests a clause

\begin{equation*} C_2 \ = \ p(X,Z) \gets e(X,Y), p(Y,Z). \end{equation*}

Note that (B) holds for $C_2$ . Consider a path of length $|p(t,u)|$ from $t$ to $u$ , and its first edge $(t,s)$ . Obviously, there exists in $G$ a path from $s$ to $u$ of length $|p(t,u)|-1$ ; so $p(s,u)\in \textit {St}_p\subseteq \textit {Snf}$ . Also, $e(t,s)\in \textit {St}_e\subseteq \textit {Snf}$ . Thus, $p(t,u)$ is covered by an instance $C_{20}=p(t,u)\gets e(t,s),p(s,u)$ of $C_2$ ; (A)(2) holds for $C_{20}$ as $|p(s,u)|\lt |p(t,u)|$ .

The constructed program $\textit {PATH2}=\textit {St}_e\cup \{C_1,C_2\}$ is correct and SLS-semi-complete w.r.t. $spec$ . It is also complete w.r.t. $spec$ , as diverging main SLS-trees for atomic queries do not exists, due to lack of negation in the program. In particular, $p(t,u)$ would fail for any not connected nodes $t,u$ , even if the graph contains loops. Note that for such graphs PATH2 is not complete w.r.t. $spec$ under the Kunen semantics.