2 Inductive definitions of sets of propositions

We all have encountered many inductively defined sets in our journeys through mathematics. The first example might be the set, $Nat$ , of natural numbers, that is, 0, 1, 2, …, whose definition can be:

\begin{equation*} x \in Nat = \left \{ \begin {array}{c@{\quad}l} \mbox {if} & x = 0 \\[5pt] \mbox {if} & x' \in Nat \mbox { and } x = succ(x') \end {array}\right . \end{equation*}

meaning that $x$ is a natural number if it is $0$ , or if it is the successor of a natural number.

Another example is the set $R_a^G$ of nodes reachable in a graph $G$ from node $a$ :

\begin{equation*} x \in R_a^G = \left \{ \begin {array}{c@{\quad}l} \mbox {if} & x = a \\[5pt] \mbox {if} & y \in R_a^G \mbox { and there is an edge in $G$ from }y \mbox { to } x \end {array}\right . \end{equation*}

As a simple example of a definition (perhaps not inductive but still rule-based) is the set of university requirements that a student has satisfied on their journey toward a degree. We might define (schematically for a hypothetical university):

met_cs_calc_reqs if took_calc_I and took_calc_II

met_cs_calc_reqs if took_calc_A and took_calc_B and took_calc_C

met_cs_math_reqs if met_cs_cals_reqs and took_discrete_math

met_cs_intro_pgming_reqs if took_pgming_I and took_pgming_II

met_cs_adv_pgming_reqs if met_cs_intro_pgming_reqs and took_algorithms

…

met_graduation_reqs if met_cs_reqs and met_distribution_reqs

We have left out many rules but expect the reader can envision how they could be completed. The idea is that if we plug in a student’s transcript to define what took_* propositions hold, then these rules define the set of requirements that that student has met, the goal of most students being to generate a transcript that causes met_graduation_reqs to show up in the set defined by these rules.

These rules can be understood as rules in a propositional logic: all the symbols in these rules (except the if and and) are propositional constants, or propositions. The set of requirements met by a particular student is an inductively defined set of propositions generated from those rules and facts. So, our goal is to precisely define propositional models for sets of rules and facts.

Thus, we turn to a general theory behind inductive definitions of sets of propositions. An inductively defined set is determined by a collection of propositional rules on a set of propositions. We let $U$ denote the set of all propositions.

We represent a propositional rule in positive Prolog:

\begin{equation*} p_0 \mbox { :- } p_1, p_2, \ldots, p_n \end{equation*}

as the slightly more abstract pair $(p_0, \{p_1, p_2, \ldots, p_n\})$ , turning the rule body sequence into a set. The general form of a propositional Prolog rule will be $(h,B)$ where $h \in U$ and $B \subseteq U$ . We call such a pair simply a rule. For rule $(h,B)$ , $B$ is the body of the rule and $h$ is the head.

We note that the propositions in $U$ may be structured. To handle grounded Prolog rules, we take $U$ to be the set of all expressions (or trees) over finite string symbols. This set is the set of all legal Prolog ground terms. In logic, this set of trees is both the set of ground atomic formulas, and the set of ground terms. We will generally use the neutral word “expression” for a member of this set when we want to stress its structure; otherwise, we may call it a proposition. $U$ will be the set of expressions throughout our development.

We use inductive definitions on the set of propositions $U$ to define sets of propositions. Note that since for us $U$ is the set of expressions, an inductive definition will define a set of expressions, that is, a set of atomic formulas. And a set of atomic formulas uniquely determines a first-order Herbrand structure, that structure that is true of all and only atomic formulas in the set. In this way we can think of our inductive definitions as determining first-order (Herbrand) models. We will return to discuss this idea later.

The same set of rules $\mathcal{P}$ can determine different closed sets depending on the set $A$ , hence we call $A$ a parameter set for the rules $\mathcal{P}$ .

The previous lemma ensures that there is a unique minimal such set. Thus, $F_{\mathcal{P}}(A)$ is well-defined.

Definition 2.5. (Head and Body Sets of $\mathcal{P}$ ) The Head Set, $H_{\mathcal{P}}$ , and Body Set, $B_{\mathcal{P}}$ , of rule set $\mathcal{P}$ are:

\begin{equation*}H_{\mathcal {P}} = \{h: (h,B) \in \mathcal {P}\}\end{equation*}

\begin{equation*}B_{\mathcal {P}} = \bigcup _{(h,B)\in \mathcal {P}} B \end{equation*}

$H_{\mathcal{P}}$ is the set of propositions that appear in the head of any rule in $\mathcal{P}$ . Note that the least set $F_{\mathcal{P}}(A)$ will contain only elements from $H_{\mathcal{P}}$ or $A$ that is, $F_{\mathcal{P}}(A) \subseteq H_{\mathcal{P}} \cup A$ for any $A \subseteq U$ . In Prolog we usually think of a set of clauses as defining a predicate, and all rules with that predicate in the head as determining a specific subset of that predicate. In our propositional framework, we use $H_{\mathcal{P}}$ to define the set from which the rules define a subset. And since parameter sets for rules $\mathcal{P}$ should influence how $\mathcal{P}$ determines a set and not add elements directly, we require throughout that parameter sets to be allowable:

Definition 2.7. (Propositional Model Satisfying $\mathcal{P}$ ) A propositional model $M$ is a set of propositions, $M \subseteq U$ .

\begin{equation*} M \models \mathcal {P} \mbox { if } F_{\mathcal {P}}((B_{\mathcal {P}} - H_{\mathcal {P}}) \cap M) = (H_{\mathcal {P}} \cap M) \end{equation*}

The intuition behind this definition is the following. The model $M$ itself provides the definition of the set $A$ , a parameter set for $\mathcal{P}$ . That is, $A = (B_{\mathcal{P}} - H_{\mathcal{P}}) \cap M$ . Then given this parameter set, $M$ agrees precisely with the least set determined by it and $\mathcal{P}$ for all the head propositions of $\mathcal{P}$ . All other propositions of $U$ may or may not be in $M$ .

Fig. 1.

Venn diagram for sets determined by rules $\mathcal{P}$ .

We visualize the set of propositions of $U$ that appear in a set of rules $\mathcal{P}$ as shown in Figure 1. The outer box encloses all the propositions of $U$ . The horizontal blue box contains the propositions in heads of rules, $H_{\mathcal{P}}$ , and the yellow box represents the set of body propositions that are not also head propositions, $B_{\mathcal{P}} - H_{\mathcal{P}}$ . The vertical salmon-colored box represents an allowed parameter set $A$ . Note it is disjoint from $H_{\mathcal{P}}$ . The darker blue sub-box of $H_{\mathcal{P}}$ and the salmon box represent $F_{\mathcal{P}}(A)$ .

We have characterized the set $F_{\mathcal{P}}(A)$ as the least set containing $A$ and closed under $\mathcal{P}$ . There are other ways to define this same set, and we turn to those other possible definitions.

$T_{\mathcal{P},A}$ is a function on subsets of $U$ that simply accumulates all the heads of rules whose body elements are all in the input set and adds all elements of $A$ . $F_{\mathcal{P}}(A)$ , the least set containing $A$ and closed under $\mathcal{P}$ , can be defined in terms of $T_{\mathcal{P},A}$ .

We note that since $T_{\mathcal{P},A}$ is monotone operator on sets, it is known to have a least fixpoint. This theorem claims that least fixpoint is $F_{\mathcal{P}}(A)$ .

We now have two definitions of $F_{\mathcal{P}}(A)$ , but neither presents any obvious way to compute membership in this set. We next present two more definitions of $F_{\mathcal{P}}(A)$ , which do lead to such algorithms.

This countable union indeed defines $F_{\mathcal{P}}(A)$ , the least set containing $A$ and closed under $\mathcal{P}$ . That is if we start with the empty set and iteratively apply the $T_{\mathcal{P},A}$ operator countably many times (or until nothing new is obtained), we obtain the least set of propositions containing $A$ and closed under the rules $\mathcal{ P}$ .

Since $T_{\mathcal{P},A}$ is monotonic, this is a non-decreasing sequence of sets. Our universal set $U$ is infinite, so this might be an infinite sequence of ever-increasing sets and the defined set would be infinite. If $H_{\mathcal{P}}$ is finite, then $F_{\mathcal{P}}(A)$ will be finite and for some natural number $n$ , $F_{\mathcal{P}}(A) = \bigcup _{i=0}^n T_{\mathcal{P}}^{(i)}$ . A direct implementation of this construction provides a bottom-up algorithm for producing finite $F_{\mathcal{P}}(A)$ .

Indeed there is yet another definition of $F_{\mathcal{P}}(A)$ that suggests another way to compute its members. The iterated $T_{\mathcal{P},A}$ algorithm computes the entire proposition set $F_{\mathcal{P}}(A)$ . This next definition allows us, in some cases, to compute membership (and non-membership) in $F_{\mathcal{P}}(A)$ even when it is infinite.

With this characterization of $F_{\mathcal{P}}(A)$ , we can show membership of a proposition of $F_{\mathcal{P}}(A)$ by producing a justification sequence for it. A justification sequence for a given $p \in U$ can be constructed by first testing whether $p \in A$ and if not, finding a rule $(p,B)$ and then recursively constructing a justification sequence for each $b \in B$ . This produces a top-down (partial) algorithm for determining membership in $F_{\mathcal{P}}(A)$ . A top-down tabling algorithm also constructs a justification sequence but guarantees in addition that no proposition appears in it more than once.

3 Parameters of inductive definitions and program components

Thus far, we have thought of parameter sets as being directly provided. But we can use a set of rules to define the parameter set for another set of rules.

3.1 Nested parameterized inductive definitions

Consider how we might use one parameterized inductive definition to determine a parameter set for another parameterized inductive definition. We can think of examples where this might be useful.

Example 3. Consider again our transitive closure example:

tc(X,Y) :- edge(X,Y).

tc(X,Y) :- edge(X,Z), tc(Z,Y).

Let the corresponding set of propositional rules be $\mathcal{TC}$ . Given a set $E$ of expressions of the form edge(A,B) for some constants A and B, we have that $F_{\mathcal{TC}}(E)$ is the transitive closure of the graph $E$ . But perhaps our graph is over states, and the edges represent pairs of states in which the second is directly accessible from the first through some action. We want to write a definition of this set of edge pairs. So, we write a definition, that might look something like:

edge(X,Y) :- applicable_action(X,Op), apply_action(Op,X,Y).

where our edge definition checks and applies applicable actions that can move from one state to another. Let the ground rules of this program be $\mathcal{MV}$ .

Now we want the transitive closure of this particular edge relation, the one defined by $\mathcal{MV}$ . We use $\mathcal{MV}$ to determine a set of edge expressions, and then use that set as the parameter set to the $\mathcal{TC}$ program. And, assuming $\mathcal{MV}$ doesn’t need a parameter set, this is exactly the set $F_{\mathcal{TC}}(F_{\mathcal{MV}}(\emptyset ))$ .

This idea of using one component to generate parameter sets for another allows us to collect various program components and put them together. There are clearly some constraints on the forms of rules sets that can be combined in this way. The following theorem clarifies these constraints.

Theorem 4. Let $\mathcal{P}$ and $\mathcal{Q}$ be parameterized inductive definitions over $U$ . (We want $\mathcal{Q}$ to generate the parameter set for $\mathcal{P}$ .) Assume $H_{\mathcal{P}} \cap (H_{\mathcal{Q}} \cup B_{\mathcal{Q}}) = \emptyset$ , that is, the head set of $\mathcal{P}$ does not intersect with either the head set or the body set of $\mathcal{Q}$ . Then $F_{\mathcal{P} \cup \mathcal{Q}}(A) = F_{\mathcal{P}}(F_{\mathcal{Q}}(A))$ . That is the meaning of the union of the clause sets is the indicated composition, with $\mathcal{Q}$ providing the parameter set for use by $\mathcal{P}$ .

This constraint on the use of propositions of $U$ is clearly important. Here $\mathcal{P}$ uses $\mathcal{Q}$ to generate its parameter set. $\mathcal{Q}$ cannot define or use any proposition that is potentially defined by $\mathcal{ P}$ ; it can define only propositions used by $\mathcal{P}$ , that is, propositions in $B_{\mathcal{P}} - H_{\mathcal{P}}$ . The set ( $F_{\mathcal{Q}}(A))$ (of the clause set of the component below) may, and to be helpful does, intersect with the body set of the clause set of the component above. (The body sets of the two components intersecting just suggests that they both might use yet another clause set as a parameter.)

Fig. 2.

Venn diagram for sets determined by parameterized $\mathcal{P}$ .

Figure 2 shows a Venn diagram for the propositions of a parameterized inductive definition $\mathcal{P}$ with parameter set $A$ , which is generated as the least closed set of definition $\mathcal{Q}$ . that is, component $\mathcal{Q}$ generates the parameter set for component $\mathcal{P}$ . The horizontal blue and yellow rectangle represents the propositions of $\mathcal{P}$ , as indicated. The vertical red-outlined rectangle represents the propositions of $\mathcal{Q}$ . Its head propositions overlap with $\mathcal{P}$ ’s body (but not head) propositions. The smaller salmon-colored rectangle represents $F_{\mathcal{Q}}(\emptyset )$ , as would be computed from $\mathcal{Q}$ . This set is a subset of $H_{\mathcal{Q}}$ , disjoint from $H_{\mathcal{P}}$ , intersects with $B_{\mathcal{P}} - H_{\mathcal{P}}$ , and constitutes the parameter set $A$ for $\mathcal{P}$ .

In this way we can build inductive definitions by using definitions to determine parameters to other parameterized definitions, as long as their head and body sets obey the necessary constraints. We can build large definitions by using smaller components by combining them in this way. Similarly, we may be able to decompose a large definition into subcomponents, again subject to the head and body constraints. Note that these constraints will require that a set of mutually recursive definitions must all reside in the same component. Thus, we have a compositional framework for parameterized inductive definitions.

4 Inductive definitions with negation

Prolog programs may have bodies with negative conditions, and we want to provide a semantics for such programs. However, unconstrained use of negative conditions in cycles is known to lead to complications; traditional Prolog systems go into infinite loops on programs with those cyclic uses of negation. It is known that Prolog meaningfully evaluates the so-called stratified programs, so this is a class of programs for which we want to provide a meaning here.

We note that the (allowable) parameter set for a parameterized inductive definition does not change in the bottom-up construction of the least model of the definition. That is it can be constructed for a subcomponent independently, and then just used in the construction of the higher component. So, we can allow a test for non-membership in a parameter set assuming we can ensure that this non-membership test will not change in the least model construction. And we can ensure this by requiring that the negative goals in the rule bodies are disjoint from the head set and refer only to the parameter set. With these conditions, the non-membership conditions of negative subgoals will not change during the bottom-up construction, and the modified construction operator will converge.

We start the formalization of this idea by defining rules with negative conditions:

For example a Prolog rule with negative conditions, such as $p \mbox{ :- } q, \mbox{ not }r, s, \mbox{ not } t.$ would correspond to the rule $(p, \{q, s\}, \{r, t\})$ .

Definition 4.2. (The Set of Negative Condition Propositions) Given set $\mathcal{P}$ of rules with negative conditions, the set of negative condition propositions of $\mathcal{P}$ is:

\begin{equation*} N_{\mathcal {P}} = \bigcup _{(h,B,N)\in \mathcal {P}} N \end{equation*}

With this constraint, the propositions of $N_{\mathcal{P}}$ can get their meanings only from a parameter set.

If $N_{\mathcal{P}} = \emptyset$ , this definition reduces to the same definition we gave for positive programs. Thus, we again use $F_{\mathcal{P}}(A)$ for this set.

Fig. 3.

Venn diagram for sets of parameterized $\mathcal{P}$ with negation.

Figure 3 shows the structure of a component with negative rules and a parameter set. Again the large horizontal blue and yellow rectangle represents the propositions of $\mathcal{P}$ , with the blue being the heads, and the yellow being the non-heads. $N_{\mathcal{P}}$ , the negated propositions, are outlined by a red box, which is disjoint from $H_{\mathcal{P}}$ . The box labeled $A$ , a parameter set, is disjoint from $H_{\mathcal{P}}$ but intersects with $N_{\mathcal{ P}}$ . Propositions in that intersection are treated as true, those in $N_{\mathcal{P}}$ but not in $A$ are considered as false. Note that those false propositions will not be in $F_{\mathcal{P}}(A)$ , since they are not in $H_{\mathcal{P}}$ .

We next extend the definition of the set function $T_{\mathcal{P},A}$ to include $\mathcal{P}$ with rules with negation.

Definition 4.7. (The $T_{\mathcal{P},A}$ Set Function) Given set of rules with negation $\mathcal{P}$ and allowable parameter set $A$ ,

\begin{equation*}T_{\mathcal {P},A}(S) = A \cup \{h : \exists (h,B,N) \in \mathcal {P} \mbox { such that } B \subseteq S \wedge N \cap A = \emptyset \}\end{equation*}

This is same definition as for positive programs but now applies to parameterized programs with negation. And we again get the bottom-up constructive definition, this time for programs with negation:

A valid decomposition of a program with negation provides a stratification of the propositions of the program. Propositions that are parameters to a component are in lower strata than propositions in the heads of rules in the component. The framework here supports a somewhat stronger form of predicate stratification, but not full local stratification. Predicate stratification requires that the rules can be partitioned using the root symbol of each expression in the head of any rule. (This implies that a program with a variable as a root head is not predicate stratifiable and not stratifiable by our definition either.) Our definition requires that heads of parameters not be unifiable with heads of the containing rules.

Recall that Prolog adds the builtin rules:

true.

(A,B) :- A, B.

to describe the semantics of rule bodies. Prolog programs are expressions and so rules are expressions and so to support metainterpretation, the rules bodies must be given meanings, and that is what these two rules do. Now we have added a new form for rule bodies, those containing negative literals. So for example the rule $(p,\{q,t\}, \{r,s\})$ (written in the form in our definitions with a positive set and a negative set) can be written in Prolog as p :- q, not(r), not(s), t. (Other orders of the body literals would also be a Prolog form of this rule.) So negative body literals are represented by trees with root not/1. Thus, we need another rule in the metainterpreter:

not(X) :- not(X).

This looks like a tautology but is not; the not in the head is the root of an expression; the not on the right must be treated by the Prolog evaluator as indicating a negative body literal. that is, this syntax must be interpreted by the Prolog evaluator as the rule $(not(X),\{\},\{X\})$ . This allows Prolog to metainterpret programs with negative body literals.

Unfortunately, our definition of stratified negation is not strong enough to support this metarule. Any program containing this rule, indeed this rule itself, is not stratifiable. Note that not(a) is an instance of the head of this rule, and with X instantiated to not(a) it is also in the set of negated bodies of instances of this rule. So there is a nonempty intersection and the instance of this rule cannot be stratified. Thus, a complete semantics for metaprogramming with Prolog programs with negation must await a treatment of nonstratified negation. The work Denecker and Vennekens (Reference Denecker and Vennekens2014) on a well-founded semantics for inductive definitions with negation should be directly applicable here and would solve this problem.

5 First-order models of (meta-)programs

Thus far, we have defined the least propositional model for a set of propositional rules. Recall that the propositions are, in fact, expressions, that is, ground atomic formulas in a first-order logic over an appropriate language. As such, the set of ground atomic formulas uniquely determines a first-order Herbrand model. We can take that first-order model to characterize the meaning of the given Prolog program. This is formalized in the definition:

Definition 5.1. (First-Order Herbrand Model of $\mathcal{P}$ ) Let $M$ be a first-order Herbrand structure over a super-language of $\mathcal{P}$ . Let $M$ be the set of ground atomic formulas true in $M$ . Then

\begin{equation*} M \models \mathcal {P} \mbox { if } M \cap H_{\mathcal {P}} = F_{\mathcal {P}}((B_{\mathcal {P}} - H_{\mathcal {P}}) \cap M) \end{equation*}

That is, if we use the atomic formulas true in $M$ to determine an allowable parameter set, $A$ , then on the heads of $\mathcal{P}$ , $M$ is true for exactly the atomic formulas in the least set containing $A$ and closed under $\mathcal{P}$ . It is the case that models of the composition of components is the intersection of the models of the components.

Consider an example of a metarule and its meaning in a first-order model:

truly_believes(X,P) :- believes(X,P), P.

This rule says that if someone believes a proposition P and P is true, then that someone has a true belief of P. Note that the first two occurrences of P in this rule are first-order terms, while the final occurrence is an atomic formula.

Now consider a ground instance of this rule:

truly_believes(david,tall(marc)) :- believes(david,tall(marc)), tall(marc).

Considered as a first-order statement, the term tall(marc) is being used as a name (an object in the domain of the structure) for the atomic formula tall(marc) in the logic. This is a kind of “Goedel numbering” the structure tall(marc) serves as a name for the formula tall(marc). Since the elements of our Herbrand domain, that is, expressions, look so much like atomic formulas in our logic, Prolog uses this “identity” function as its Goedel formula-naming function.

Every term in a Prolog program is the Goedel expression of a ground atomic formula. Prolog also treats not(X) as the name for the negation of the ground literal not X. (This means, of course, that not cannot be a predicate symbol.)

7 Why yet another semantics for Prolog?

Do we need yet another semantics for Prolog? The traditional minimal Herbrand model semantics for Prolog is based on first-order logic (FOL) and its models and proof theory. This is appropriate for Prolog as a language for representing data and knowledge since FOL is the accepted foundation for knowledge representation (KR) languages. But Prolog is also a programming language for implementing algorithms and was clearly understood as such in its early days (Warren et al., Reference Warren, Pereira and Pereira1977; Kowalski, Reference Kowalski1979a,Reference Kowalski1979b). The semantics of this paper is based on simple set induction, a basic computational paradigm. Induction is fundamentally about computing; FOL is fundamentally about static knowledge representation.

This induction semantics is lower-level, more primitive, more abstract, than the logic-based semantics. This induction semantics can be used to define the minimal model semantics, as described in Section 5. And it is clear why: a complete proof system is an inductive definition of the set of logically true expressions, exactly an inductive definition. But to allow FOL to give an account of Prolog, the non-first-order concept of minimality, or closed world assumption, must be added. This add-on that is necessary for FOL is intrinsic to inductive definitions.

Also note that another important application of Prolog after KR is grammars. And grammars are introduced to students in courses on the theory of computation, not as statements in a logic, but as inductive definitions of sets of strings. Undoubtedly there is a close relationship between logic and grammars (e.g., Pereira and Warren (Reference Pereira and Warren1983)), but it seems clear that grammars are fundamentally first understood as inductive definitions.

Teaching the semantics of Prolog to students without a strong background in logic would be much easier with this inductive semantics. The student need not be taught FO formulas, quantification, FO models, truth in a model, satisfiability, proofs, general substitutions, Skolemization, disjunctive normal form, resolution, Horn clauses, refutation proofs, and finally Herbrand models (in which the previously intuitive FO concept of a function gets specialized into a very non-intuitive particular function). These are all very important concepts, and they should be understood by students of knowledge representation. But, they are not required by students who simply want to understand the meaning of a Prolog program as they would understand the meaning of a Lisp program.

And finally, this semantics is compositional, as any self-respecting programming language semantics simply must be. Programmers understand their programs by understanding their programs’ pieces. A semantics simply must account for this. Denecker et al. (Reference Bruynooghe, Denecker and Marek2001) and Warren and Denecker (Reference Warren and Denecker2023) emphasized the importance of compositionality and we have followed his lead.

8 Related work

There has been much work on metaprogramming in logic programming. We discuss briefly work deemed relevant to ours.

Costatini (Reference Costantini, Kakas and Sadri2002) provides a good survey of a number of early approaches to metaprogramming in logic. Bry (Reference Bry2020) explores metalogic in the context of a much larger fragment of logic than just Prolog.

The idea of basing Prolog semantics on a least fixpoint dates back to van Emden and Kowalski’s seminal paper (van Emden and Kowalski, Reference Van Emden and Kowalski1976), in which the $T|_{\mathcal{P}}$ operator was defined. It was further elaborated by Lloyd (Reference Lloyd1984).

Our approach to the semantics of Prolog most closely follows that of Denecker et al. (Reference Bruynooghe, Denecker and Marek2001) and Denecker and Warren (Reference Denecker and Warren2023) in emphasizing parameterized inductive definitions. Our approach here agrees with Denecker’s on Prolog programs that are in first-order logic. But we also handle metarules (non-first-order rules), treating them as templates for propositional programs. Also, our treatment of negation is more restrictive than Denecker’s, as noted, but we feel ours may have clearer motivations being based on parameterized programs.