[

[

Abstract

In Knowledge Representation, it is crucial that knowledge engineers have a good understanding of the formal expressions that they write. What formal expressions state intuitively about the domain of discourse is studied in the theory of the informal semantics of a logic. In this paper we study the informal semantics of Answer Set Programming. The roots of answer set programming lie in the language of Extended Logic Programming, which was introduced initially as an epistemic logic for default and autoepistemic reasoning. In 1999, the seminal papers on answer set programming proposed to use this logic for a different purpose, namely, to model and solve search problems. Currently, the language is used primarily in this new role. However, the original epistemic intuitions lose their explanatory relevance in this new context. How answer set programs are connected to the specifications of problems they model is more easily explained in a classical Tarskian semantics, in which models correspond to possible worlds, rather than to belief states of an epistemic agent. In this paper, we develop a new theory of the informal semantics of answer set programming, which is formulated in the Tarskian setting and based on Frege’s compositionality principle. It differs substantially from the earlier epistemic theory of informal semantics, providing a different view on the meaning of the connectives in answer set programming and on its relation to other logics, in particular classical logic.

i
\NewDocumentCommand\formulas

g\IfValueTF#1L_#1L \NewDocumentCommand\structuresg\IfValueTF#1S_#1S \NewDocumentCommand\infsemFOmgg \IfValueTF#2FO_#1^#2FO_#1 \IfValueTF#3(#3) \NewDocumentCommand\infsemFOAmgg \IfValueTF#2^FO_#1^#2^FO_#1 \IfValueTF#3(#3) \NewDocumentCommand\infsemmgg \IfValueTF#2I_#1^#2I_#1 \IfValueTF#3(#3) \NewDocumentCommand\infsemGLmgg \IfValueTF#2GL_#1^#2GL_#1 \IfValueTF#3(#3) \NewDocumentCommand\infsemTmgg \IfValueTF#2OB_#1^#2OB_#1 \IfValueTF#3(#3) The informal semantics of Answer Set Programming: A Tarskian perspective]The informal semantics of Answer Set Programming: A Tarskian perspective Denecker, Lierler, Truszczynski and Vennekens] Marc Denecker
Department of Computer Science, KU Leuven, 3001 Leuven, Belgium
and Yuliya Lierler
Department of Computer Science, University of Nebraska at Omaha, Omaha, NE 68182, USA
and Miroslaw Truszczynski
Department of Computer Science, University of Kentucky, Lexington, KY 40506-0633, USA
and Joost Vennekens
Department of Computer Science, KU Leuven, Campus De Nayer, 2860 Sint-Katelijne-Waver, Belgium

nformal semantics, knowledge representation, answer-set programming

1 Introduction

I am not here in the happy position of a mineralogist who shows his audience a rock-crystal: I cannot put a thought in the hands of my readers with the request that they should examine it from all sides. Something in itself not perceptible by sense, the thought is presented to the reader—and I must be content with that—wrapped up in a perceptible linguistic form.
Gottlob Frege, Der Gedanke

In knowledge representation, a human expert expresses informal propositions about the domain of discourse by a formal expression in some logic . The latter is formulated in a vocabulary for which the expert has an intended interpretation specifying the meaning of the vocabulary symbols in the domain. It is essential that the human expert understands which informal propositions about the problem domain are expressed by formal expressions of . The fundamental task of the informal semantics of a logic , sometimes called the declarative reading or the intuitive interpretation of , is to provide this understanding by explaining formal expressions of (or of a fragment of ) as precise informal propositions about the domain of discourse.

In Frege’s terms, an informal proposition is a thought in the mind of the expert. It is not a tangible object and is not perceptible by others. To be observed, studied and used, it must be presented in linguistic form. In this paper, we will therefore assume that the domain expert’s intended interpretation maps each vocabulary symbol to some natural language statement that represents the imperceptible “thought” that this symbol is supposed to represent. Likewise, the informal semantics of a logic is a mapping that, given such an intended interpretation , assigns to a formal expression of a natural language reading that captures the meaning of in .

We already hint here that natural language is to play a key role in any study of informal semantics. Such use of natural language may be controversial. For instance, Barwise and Cooper (1981) say: “To most logicians (like the first author) trained in model-theoretic semantics, natural language was an anathema, impossibly vague and incoherent.” Upon closer inspection, however, the situation is not quite so dire. Indeed, Barwise and Cooper (1981) go on to say that: “To us, the revolutionary idea […] is the claim that natural language is not impossibly incoherent […], but that large portions of its semantics can be treated by combining known tools from logic, tools like functions of finite type, the -calculus, generalized quantifiers, tense and modal logic, and all the rest.” In this article, we subscribe to this more optimistic view on natural language. While it is certainly possible to create vague, ambiguous or meaningless natural language statements, we believe that a careful use of suitable parts of natural language can avoid such problems. Indeed, much of science and mathematics throughout the centuries has been developed by means of a clear and precise use of natural language. It is this same clarity and precision that we want to achieve in our study of informal semantics.

The main goal of this paper is to study the informal semantics of answer set programming (ASP) — a broadly used logic-based knowledge representation formalism (Marek and Truszczynski, 1999; Niemelä, 1999; Brewka et al., 2011; Gebser et al., 2012). ASP has its roots in extended logic programming (ELP) proposed by Gelfond and Lifschitz (1988; 1991). As part of the development of ELP, Gelfond and Lifschitz presented an informal semantics for extended logic programs based on epistemic notions of default and autoepistemic reasoning. According to their proposal, an extended logic program expresses the knowledge of a rational introspective agent, where a stable model (or an answer set) represents a possible state of belief of the agent by enumerating all literals that are believed in that state. The Gelfond-Lifschitz informal semantics is attuned to applications in epistemic domains. However, it is not well aligned with others.

A decade after ELP was conceived, researchers realized that, in addition to modeling applications requiring autoepistemic reasoning, the language can be used for modeling and solving combinatorial search and optimization problems (Marek and Truszczynski, 1999; Niemelä, 1999). The term answer set programming was proposed shortly thereafter by Lifschitz (1999; 2002) to be synonymous with the practice of using extended logic programs for this type of applications. Since then, ASP has gained much attention and evolved into a computational knowledge representation paradigm capable of solving search problems of practical significance (Brewka et al., 2011). Particularly influential was the emergence of a methodology to streamline the task of programming in this paradigm. It consists of arranging program rules in three groups: one to generate the search space, one to define auxiliary concepts, and one to test (impose) constraints. Lifschitz (2002) coined the term generate-define-test (GDT) to describe it. Programs obtained by following the GDT methodology, or GDT programs, for short, form the overwhelming majority of programs arising in search and optimization applications.

However, for GDT programs, the epistemic informal semantics is inappropriate and ineffective in its role. To illustrate this point, consider the graph coloring problem. One of the conditions of the problem is the following informal proposition:

(1)

In the language of ELP of 1999, this condition can be expressed by the rule

(2)

The reading that the informal semantics provides for rule (2) is: for every , Aux holds if the agent does not know Aux and is a node and the agent does not know that has a color. There is an obvious mismatch between this sentence and the simple (objective, non-epistemic) proposition (1) that rule (2) intends to express. In other words, in this example, the explanatory power of the epistemic informal semantics diminishes. It fails to provide a direct, explicit link between the formal expression on the one side, and the property of objects in the domain of discourse it is intended to represent, on the other.

Modern ASP dialects typically provide a more elegant notation for writing down constraints, such as:

(3)

However, in itself this does not address or fix the mismatch. Moreover, as we discuss further on in this paper, it is often surprisingly difficult to extend the Gelfond-Lifschitz epistemic informal semantics to cover the new language constructs of modern ASP dialects.

At the root of the mismatch lies the reflective epistemic agent. A key aspect of the original applications for ELP was the presence of such an agent in the domain of discourse; typically it was a knowledge base that reflects on its own content. Such an agent is absent in the graph coloring problem and in typical problems that are currently solved using ASP. For example, there are no benchmarks in the series of ASP competitions (Gebser et al., 2007b; Denecker et al., 2009; Calimeri et al., 2011; Alviano et al., 2013a) that mention or require an epistemic introspective agent.

In this paper, we present a new theory of the informal semantics for ASP. We call it Tarskian because it interprets an answer set of an ASP program in the same way as a model of a first-order logic (FO) theory is interpreted—namely, as an abstraction of a possible state of affairs of the application domain, and not epistemically as a state of beliefs of an agent. We define this theory for the pragmatically important class of GDT programs and their subexpressions. Our informal semantics explains the formal semantics of ASP under the Tarskian view of answer sets. It offers an explanation of the meaning of connectives, including “non-classical” ones, and it satisfies Frege’s compositionality principle. Under the new semantics, the mismatch between the information the user encapsulated in the program and the intended reading of the program disappears. For example, it maps the constraint (3) to the informal proposition (1). It is worth noting that the epistemic semantics reflects the fact that ASP’s roots are in the domain of commonsense reasoning. By contrast, the informal semantics that we introduce here uses the kind of natural language constructs common in mathematical texts.

A major issue in building an informal semantics for ASP concerns the structure of programs. Formally, programs are “flat” collections of rules. However, to a human expert, GDT programs have a rich internal structure. To build our informal semantics , we develop an “intermediate” logic ASP-FO that is directly inspired by the GDT methodology, in which the (hidden) internal structure of GDT programs is made explicit. This structure supports the use of the compositionality principle when defining the informal semantics for the logic ASP-FO. We show that by exploiting splitting results for ASP (Ferraris et al., 2011), programs constructed following the GDT methodology can be embedded in the logic ASP-FO. Thanks to the embedding, our discussion applies to the fragment of ASP consisting of GDT programs and establishes an informal semantics for this class of programs.

The paper is organized as follows. We start by reviewing theories of informal semantics for two logics: the one of first-order logic (Section 2), which provides guidance for our effort, and the Gelfond-Lifschitz theory of informal semantics for ELP (Section 3), with which we contrast our proposal. We then discuss the class of GDT programs, the focus of our work (Section 4), and present the logic ASP-FO as a way of making the internal structure of GDT programs explicit (Section 5). Section 6 then presents the main contribution of this paper: the informal semantics . Section 7 presents a number of formal results in support of this information semantics. We finish with a discussion of related work (Section 8) and some conclusions (Section 9).

2 The formal and informal semantics of first-order logic

In this section, we introduce classical first order logic (FO), with special attention to its informal semantics. This serves two purposes. First, it is meant as an introduction of the interplay between formal and informal semantics. Much of that will be reused for the logic ASP-FO that we define later in this paper. Second, ASP-FO is a proper superset of FO. Hence, its formal and informal semantics will extend that of FO.

Formal syntax of FO

We assume an infinite supply of non-logical symbols: predicate and function symbols, each with a non-negative integer arity. Predicate and function symbols of arity 0 are called propositional and object symbols, respectively. A vocabulary is a set of non-logical symbols.

A term is an object symbol or a compound expression , where is an -ary function symbol and the ’s are terms. An atom is an expression , where is an -ary predicate symbol and the ’s are terms (in particular, propositional symbols are atoms). A formula is then inductively defined as follows:

  • Each atom is a formula;

  • If are terms, then is a formula;

  • If and are formulas, then so are , , and ;

  • If is a formula, then so are , and , where is an object symbol, here called a variable.

An occurrence of a symbol in a formula is bound if it is within a subformula of the form or . Otherwise, the occurrence is free. In FO, the only symbols that occur bound are object symbols.

Given a vocabulary , we call a formula a sentence over if all symbols with free occurrences in belong to . The set of sentences over is denoted . A theory is a finite set of formulas. A theory over is a finite set of sentences over .

Example 1

The running application in this section is graph coloring. We choose the vocabulary that consists of unary predicates and ; a binary predicate ; and a unary function intended to be the mapping from nodes to colors. We define to be the following sentence over :

Formal semantics of FO

The basic semantic objects of FO are structures for a given vocabulary.

Definition 1

Let be a vocabulary. A -structure consists of (i) a non-empty set , called the domain of , and (ii) an interpretation function that assigns an appropriate value to each symbol of :

  • The value of an -ary function symbol is an -ary total function over .

  • The value of an -ary predicate symbol is an -ary relation over .111This definition correctly handles the case of 0-ary function and predicate symbols. Functions from , i.e., the empty tuple , into can be viewed as elements from , yielding a standard interpretation of 0-ary function symbols (which are often called constants); and each 0-ary predicate symbol is represented by one of exactly two 0-ary relations over : or , i.e., false or true.

We call the interpretation or value of in . Given a -structure , we denote its vocabulary by . We say that interprets a vocabulary if it interprets each symbol in (that is, if ).

For a given vocabulary , we denote by the class of all -structures. For a -structure , we define the projection of on , written , to be the -structure with the same domain as and the interpretation function of restricted to . We call an expansion of if .

Example 2

For the vocabulary , consider, for instance, the structure defined as follows:

  • ,

  • ,

  • and

  • .

Note that, in FO, a structure must interpret each function symbol by a total function on its domain. Therefore, while we intend to be a function that maps nodes to colors, it must also map each of the colors to some value. This could be avoided by, for instance, allowing partial functions, or by using a typed variant of FO. For simplicity, however, we stay with classical definitions of FO.

For a structure , a 0-ary function symbol and a corresponding value , we denote by the structure identical to except that .

Definition 2

We extend the interpretation function of structure to all compound terms over by the inductive rule
.
We further extend this function to tuples of terms over by defining
, where .

The value/interpretation is a well-defined object in the domain of provided is a term and interprets all function and object symbols in .

Next, we define the truth relation, or the satisfaction relation, between structures and formulas.

Definition 3 (Satisfaction relation )

Let be an FO formula and a structure interpreting all free symbols of . We define by induction on the structure of :

  • , where is a predicate symbol, if ;

  • if and ;

  • if or (or both);

  • if ; i.e., if it is not the case that ;

  • if or (or both);

  • if for some , .

  • if for each , .

  • if ; i.e., have identical interpretations in .

When , we say that is true in , or that satisfies , or that is a model of .

The satisfaction relation is easily extended from formulas to theories.

Definition 4

Let be an FO theory over . A -structure  is a model of (or satisfies ), denoted , if for each .

The satisfaction relation induces definitions of several other fundamental semantic concepts.

Definition 5 (Derived semantic relations)

A theory (or formula) entails a formula , denoted , if is satisfied in every structure that interprets all symbols with free occurrences in  and , and satisfies . A formula is valid (denoted ) if it is satisfied in every structure that interprets its free symbols. A formula or theory is satisfiable if it is satisfied in at least one structure. A formula is logically equivalent to (denoted ) if for every structure that interprets the free symbols of both formulas, if and only if .

The informal semantics of FO

The theory of informal semantics of FO is a coherent system of interpretations of its formal syntax and semantics that explains formulas as objective propositions about the application domain, structures as “states of affairs” of the application domain, and the satisfaction relation as a truth relation between states of affairs and propositions. It also induces informal semantics for the derived semantical relations. We will denote this informal semantics by , and the three components of which it consists (i.e., the interpretation of formulas, the interpretation of structures, and the interpretation of semantic relations such as satisfaction) by , and , respectively.

The informal semantics of a formula is the information that is represented by about the problem domain. It is essentially a thought. Following the quote by Frege at the beginning of this article, we make these thoughts tangible by giving them a linguistic form. In other words, the first component of the theory of informal semantics of FO consists of a mapping of FO formulas to natural language statements.

The informal semantics of a formula depends on a parameter — the meaning that we give to the symbols of vocabulary of in the application domain. This is captured by the intended interpretation of the vocabulary . To state the informal semantics of a formula over in linguistic form, we specify as an assignment of natural language expressions to the symbols of . For an -ary function , (or , if the arity is clear or immaterial) is a parameterized noun phrase that specifies the value of the function in the application domain in terms of its arguments. Similarly, for an -ary predicate , is a parametrized sentence describing the relation between arguments of . In either case, the th argument is denoted as .

Example 3

In the running example, the intended interpretation  of the vocabulary  can be expressed in linguistic form as parameterized declarative sentence and parameterized noun phrases:

  • is a node”;

  • “there is an edge from to ”;

  • “the color of ”;

Given an intended interpretation for a vocabulary , the informal semantics of FO terms and formulas over is now the inductively defined mapping from formal expressions to natural language expressions specified in Table 1.

                      
x (where is a variable)
(i.e., the noun phrase with its parameters instantiated to )
(i.e., the declarative sentence with its parameters instantiated to )
or (or both)
and
it is not the case that (i.e., is false)
if then (in the sense of material implication)
there exists an in the universe of discourse such that
for all in the universe of discourse,
and are the same (i.e., they represent the same elements of the universe of discourse)
and …and
Table 1: The informal semantics of FO formulas.

A special case in Table 1 is its final row. It gives the meaning of the implicit composition operator of FO, i.e., the operator that forms a single theory out of a number of sentences. The informal semantics of this operator is simply that of the standard (monotone) conjunction.

Example 4

For the theory defined in Example 1, results in the following statement:

For all in the universe of discourse, for all in the universe of discourse, if there is an edge from to , then it is not the case that the color of and the color of are the same.

In other words, states that adjacent nodes are of different color.

Example 5

Let us consider an alternative application domain for the FO language considered above, in which we have humans, each of some age, and each possiby with some siblings. We now may have the following intended interpretation of the vocabulary :

  • is a human”;

  • and are siblings”;

  • “the age of ”.

For theory , yields this statement:

For all in the universe of discourse, for all in the universe of discourse, if and are siblings, then it is not the case that the age of and the age of are the same.

In other words, in the “sibling” application domain, the theory states that siblings have different age.

Informal semantics for FO’s semantical concepts

In addition to explaining the informal meaning of syntactical expressions, the informal semantics of FO also offers explanations of FO’s formal semantical objects: structures, the satisfaction relation, and the derived concepts of entailment, satisfiability, and validity.

The basic informal notion behind these concepts is that of a state of affairs. States of affairs differ in the objects that exists in the universe of discourse, or in the relationships and functions amongst these objects. The application domain is in one of many potential states of affairs. In a state of affairs, a proposition of the application domain is either true or false.

The intended interpretation in general does not fix the state of affairs. Rather, it determines an abstraction function from states of affairs to -structures.222More accurately, it determines an abstraction function from states of affairs to classes of isomorphic -structures.

Example 6

Under the intended interpretation for the vocabulary , the -structure of Example 2 represents any state of affairs with five elements in the universe of discourse: three nodes abstracted as with edges corresponding to and and two colors represented by ; finally, a coloring mapping that associates colors to all elements (nodes and colors).

In the sequel, we denote the class of states of affairs that abstract under to structure as . We call this the informal semantics of the structure under . Table 2 expresses the meaning of structures as explained above.

Different intended interpretations give rise to different abstractions.

Example 7

Under the alternative intended interpretation of Example 5, represents any state of affairs with three persons and two ages, where the sibling relation consists of pairs corresponding to and and where persons have the same age different from that of . However, no possible state of affairs under this intended interpretation abstracts into , since the sibling relation amongst a group of persons is always an equivalence relation while is not. Stated differently, contains only impossible states of affairs.

a state of affairs that has abstraction
the set of elements in the universe of discourse of
the property of described by the declarative sentence
the function in described by the noun phrase
Table 2: The informal semantics of FO structures.

The informal semantics of the satisfaction relation between structures and sentences is the relation between states of affairs and true propositions in it. That is, is interpreted as “(the proposition represented by) is true in the state of affairs (corresponding to) .” Table 3 summarizes this observation.

                               
The property holds in the states of affairs
Table 3: The informal semantics of the satisfaction relation of FO.

We thus specified for each vocabulary and for every intended interpretation for a triple that explains the informal semantics of formulas, structures and the satisfaction relation. We call this the (standard) theory of informal semantics of FO.

Informal semantics of derived semantical relations

The standard theory of informal semantics of FO also induces the informal meaning for the derived semantical concepts of entailment, equivalence, validity, satisfiability, and equivalence in a way that reflects our understanding of these concepts in mathematics and formal science.

For instance, under the standard informal semantics of FO, a formal expression (entailment), becomes the statement that the informal semantics of (a statement that expresses a property of the application domain) is true in every state of affairs for that application domain, in which the informal semantics of (another statement that expresses a property of the application domain) is true (which, in case the informal semantics of and are mathematical propositions, means that the first proposition, the one corresponding to , mathematically entails the second proposition, the one corresponding to ). Similarly, validity of means that the informal semantics of is true in every state of affairs, and satisfiability of means that the informal semantics of is true in at least one state of affairs.

Precision of the informal semantics

The informal semantics of a sentence of theory under intended interpretation is a syntactically correct statement in natural language, but is this statement a sensible and precise statement about the application domain? This is a concern given the vagueness, ambiguity and the lack of coherence that is so often ascribed to natural language (Barwise and Cooper, 1981). We now discuss this.

First, when the intended interpretation of is vague or ambiguous, then indeed, the informal semantics of FO sentences over will be vague or ambiguous. E.g., if we interpret as ” is rather similarly looking as ”, then surely the informal semantics of sentences containing this predicate will be vague. FO is not designed to express information given in terms of vague concepts. In FO, as in many other languages, it is the user’s responsibility to design a vocabulary with a clear and precise intended interpretation.

A second potential source of ambiguity lies in the use of natural language connectives such as “and”, “or”, “if…then…”, etc. in Table 1. Several of these connectives are overloaded, in the sense that they may mean different things in different contexts. However, this does not necessarily lead to ambiguity or vagueness, since human readers are skilled in using context to disambiguate overloaded concepts. Let us consider several potential ambiguities.

In natural language, the connective “and” corresponds not only to logical conjunction, but also to temporal consecutive conjunction exemplified in I woke up and brushed my teeth. However, the temporal interpretation arises only in a temporal context. Table 1 is not stated within a temporal context, so it is logical conjunction that is intended and this intended meaning is inherited in every occurrence of in every FO sentence. Similarly, the word “or” is used to denote both inclusive and exclusive disjunction. In mathematical texts its accepted meaning is that of inclusive disjunction. The rule for “or” in Table 1 explicitly adds “or both”, to remove any possibility for ambiguity.

The conditional “if …then …” is famously ambiguous. It can mean many different things in varying contexts (Dancygier and Sweetser, 2005). Therefore, any choice for the formal and informal semantics of the implication symbol can only cover part of the use of the conditional in natural language333This suggests adding symbols to the logic to express other conditionals, which is something we we will do later in this paper).. In FO, the informal semantics of was chosen to be the material implication, which interprets “if A then B” as “not A or B”. It has the benefit of being simple and clear, and it is likely the conditional that we need and use most frequently in mathematical text.

To summarize, the natural language connectives and quantifiers in Table 1 are precise and clear. This precision is inherited by the informal semantics of FO sentences. Consequently, under the assumption that the intended interpretation is also clear, the natural language statements produced by are as clear and unambiguous as mathematical text.

Informal semantics as the “empirical” component of logic

Formal sentences of a knowledge representation logic are used to specify information about an application domain. The role of the informal semantics theory of a knowledge representation logic is to provide a principled account of which information about an application domain is expressed by formal sentences of the logic. In other formal empirical sciences, we find theories with a similar role. A physics theory (e.g., quantum mechanics) not only consists of mathematical equations but, equally important, also of a theory that describes, often with extreme precision, how the mathematical symbols used in these equations are linked to observable phenomena and measurable quantities in reality. This second part of the theory therefore plays a role similar to that of the informal semantics theory of a knowledge representation logic.

A physics theory is a precise, falsifiable hypothesis about the reality it models. Such a theory can never be proven. But it potentially can be experimentally falsified by computing a mathematical prediction from the formal theory, and verifying if the measured phenomena match the predictions. If not, the experiment refutes the theory. Otherwise, it corroborates (supports) the theory. Availability of a large and diverse body of corroborating experiments, in the absence of experimental refutation, increases our confidence in the theory.

Likewise, a formal logic with a theory of informal semantics is a precise, falsifiable hypothesis about the forms of information (the “thoughts”) expressible in the logic and their truth in different states of affairs. A possible experiment here could consist of a choice of a vocabulary with intended interpretation , a -theory and a -structure . The experiment would falsify the theory of informal semantics if and yet would not be considered to be true in the states of affairs of by human reasoners. Or, conversely, if it holds that while would be considered by human reasoners to be true in . That such mismatches do not occur corroborates the theory of informal semantics of FO. Here, we present one such corroborating experiment.

Example 8

Let us return to our running example. Since , we check that also holds. Indeed, it is evident that human reasoners would determine that in all states-of-affairs described by it is the case that (all neighbouring nodes have different colors). Therefore, this experiment corroborates the standard theory of FO’s informal semantics.

Alternative theories of informal semantics of FO

That the informal and formal semantics correspond so well to each other is not an accident. The key to this is the tight correspondence between the natural language expressions occurring in Table 1 and the statements used in the bodies of rules of Definition 3, for instance, between the informal and formal semantics of , where we have “ or (or both),” on the one side, and the condition for , “ or (or both),” on the other. Breaking this correspondence would lead to many mismatches between informal and formal semantics. E.g., suppose we modify the formal semantics:

if or (exclusively)

but we keep the entry for in Table 1. That would obviously create a range of experiments in which formal and informal semantics are in mismatch. E.g., for the propositional vocabulary , it now holds that while under any intended interpretation of , the statement ” or (or both)” is true in the state of affairs .

However, while the formal semantics constrains the informal semantics, it does not uniquely determine it. The informal semantics of formulas arises from a coherent set of interpretations of language constructs and of the semantic primitives: structures and . By carefully changing this system, we may obtain an informal semantics that still matches with the formal semantics although it assigns a very different meaning to formulas. Let us illustrate this.

In the proposed new informal semantics, we reinterpret all connectives such that the informal semantics of any sentence is exactly the negation of its standard informal semantics, and we reinterpret to mean that the informal semantics of is false in states of affairs represented by . These two negations then compensate for each other, leading to a theory of informal semantics that still matches with the formal semantics, even though it assigns the negation of the standard informal semantics to each FO sentence! To be precise, the alternative informal semantics theory is given by , where that is, the informal semantics of structures as states of affairs is as in the standard informal semantics of FO, and the interpretations of the two non-standard components and are defined in Table 4. To illustrate, let us consider the formula :

The non-standard informal semantics interprets the formula as:

For all in the universe of discourse, for all in the universe of discourse it is not the case that there is an edge from to , or the color of and the color of are not the same.

Stated differently, says that adjacent nodes are of different color. Note that this statement is the negation of the standard informal semantics of this formula and that it has the same meaning as the one produced by the standard informal semantics for the (different) formula . Since in the new informal semantics, structures are still interpreted in the same way as before, it follows that is satisfied in the state-of-affairs . On the formal side, nothing has changed and it is the case that , i.e., the formula is not formally satisfied in the structure. But under the new informal semantics, the relation is now interpreted as non-satisfaction and hence, is to be interpreted as the fact that is (not non-)satisfied in . Which is true!

Thus, even though the formal semantics of a logic strongly constrains its informal semantics, there may nevertheless remain different informal semantics that correspond to the logic’s formal semantics. In the case of FO, an informal semantics such as is counterintuitive and of no practical use.

                             
it is not the case that
and
or
it is not the case that
for all in the universe of discourse,
there exists an in the universe of discourse such that
and are not the same
or …or
                               
The property does not hold in the state-of-affairs
Table 4: A non-standard informal semantics of FO. The informal semantics of terms is as in Table 1 and the informal semantics of structures as in Table 2.

As many logics reuse the connectives of FO, we will use the following terminology. We will say that a connective is classical in a logic under some informal semantics if interprets it in the same way as does (i.e., by the same natural language phrase). For instance, in the non-standard informal semantics for FO, the negation connective is classical, whereas the conjunction connective is not.

In the rest of this paper, we often omit the superscript from the notation when it is clear which of the three components of a theory of informal semantics is intended.

3 The original formal and informal semantics of extended logic programs

In this section, we recall the standard formal and informal semantics of extended logic programs as it appeared in Gelfond and Lifschitz (1988, 1991). An alternative review of the informal semantics for this logic can be found in (Gelfond and Kahl, 2014, Section 2.2.1). For simplicity, here we only consider the propositional case. Logic programs with variables are interpreted by the means of their so-called grounding that transforms them into propositional programs.

A literal is either an atom or an expression , where is an atom. An extended logic programming rule is an expression of the form

(4)

where , , and are propositional literals. If all the literals , and are atoms (i.e., symbol does not appear in the rule), then such a rule is called normal. The literal is the head of the rule and expression is its body. We may abbreviate this rule as . An extended logic program is a finite set of such rules. We denote the set of all programs in a given vocabulary by .

A consistent set of propositional literals is a set that does not contain both and its complement for any atom . A believed literal set is a consistent set of propositional literals. We denote the set of all believed literal sets for a vocabulary by . A believed literal set satisfies a rule of the form (4) if belongs to or there exists an such that or a such that . A believed literal set is a model of a program if it satisfies all rules .

For a rule of the form (4) and a believed literal set , the reduct is defined whenever there is no literal for such that . If the reduct is defined, then it is the rule

The reduct of the program consists of the rules for all , for which the reduct is defined. A believed literal set is a stable model or answer set of , denoted , if it is a -least model of .

The formal logic of extended logic programs consists of the triple . Gelfond and Lifschitz (1988; 1991) described an informal semantics for such programs based on epistemic notions of default and autoepistemic reasoning. Just as with , the informal semantics arises from a system of interpretations of the formal syntactical and semantical concepts. We now recall this informal semantics, which we name . We denote its three components by , and .

One of the key aspects of is that it views a believed literal set as an abstraction of a belief state of some agent. An agent in some belief state considers certain states of affairs as possible and the others as impossible. The corresponding believed literal set is the set of all literals that the agent believes in, that is, those that are true in all states of affairs that agent regards as possible. Importantly, it is not the case that a literal that does not belong to is believed to be false by the agent. Rather, it is not believed by the agent: the literal is false in some states of affairs the agent holds possible, and it may be true in others. In fact, is true in at least one of the agents possible state of affairs unless the complement of belongs to (unless the agent believes the complement of ). Thus, the informal semantics explains the meaning of programs in terms of what literals an agent with incomplete knowledge of the application domain might believe in.

Example 9

Consider the believed literal set

under the obvious intended interpretation for the propositional atoms. This is the abstraction of any belief state in which the agent both believes that Mary is a student and that John is male, and does not believe that John is a student or that Mary is male. One such belief state is the state in which the agent considers the following states of affairs as possible:

  1. John is the only male in the domain of discourse; Mary is the only student.

  2. John and Mary are both male students.

  3. John and Mary are both male; Mary is the only student.

  4. John is the only male; John and Mary are both students

Another belief state corresponding to is the state in which the agent considers the states of affairs 2-4 of as possible. In both, Mary is a student and John a male in all possible states of affairs. John is student in worlds 2,4; Mary is male in worlds 2,3. Hence, literals and are not believed.

Although both belief states abstract to the same believed literal set, they are different. When compared to , the belief state contains the additional belief that either John is a student or Mary is male. Since this additional belief is not atomic, a formal believed literal set cannot distinguish belief states in which it holds (e.g., ) from belief states in which it does not (e.g., ). In this way, different informal belief states are still abstracted to the same formal believed literal set. This shows that believed literal sets are a rather coarse way of abstracting belief states, compared to, e.g., believed formula sets or Kripke structures.

A belief set A belief state that has abstraction
for atom has the belief that is true; i.e., is true in all states of affairs possible in
for atom has the belief that is false; i.e., is false in all states of affairs possible in
for atom does not have the belief that is true; i.e., is false in some state of affairs possible in
for atom does not have the belief that is false; i.e., is true in some state of affairs possible in
Table 5: The Gelfond-Lifschitz informal semantics of belief sets.

We denote the class of informal belief states that are abstracted to a given formal believed literal set under an intended interpretation as . Table 5 summarizes this abstraction function.

Table 6 shows the Gelfond-Lifschitz informal semantics of programs. As in the informal semantics for FO, each atom has an intended interpretation which is represented linguistically as a noun phrase about the application domain. The intended interpretation is “it is not the case that ”. As is clear from this table, under , extended logic programs have both classical and non-classical connectives. On the one hand, the comma operator is classical conjunction and the rule operator is classical implication. On the other hand, the implicit composition operator (constructing a program out of individual rules) is non-classical, because it performs a closure operation: the agent knows only what is explicitly stated. Of the two negation operators, symbol is classical negation, whereas not is a non-classical negation, which is called default negation.

                                   
propositional atom
propositional literal it is not the case that
expression of the form not  the agent does not know that
expression of the form and
rule if then (in the sense of material implication)
program All the agent knows is: and
Table 6: The Gelfond-Lifschitz (1988; 1991) informal semantics for ASP formulas.

The final component of the GL theory of informal semantics is , which explains what it means for a set of literals to be a stable model of a program . As can be seen in Table 7, this means that, given that represents precisely the knowledge of the agent, could be the set of literals the agent believes.

                       
Given that all the agent knows is , could be the set of literals the agent believes
Table 7: The Gelfond-Lifschitz (1988; 1991) informal semantics for the ASP satisfaction relation.

To illustrate this informal semantics, let us consider Gelfond and Lifschitz’ well-known interview example.

Example 10

Whether students of a certain school are eligible for a scholarship depends on their GPA and on their minority status. The school has an incomplete database about candidate students. Students for which the school has insufficient information to decide eligibility should be invited for an interview. The following ELP program expresses the school’s knowledge.

The three rules for specify a partial policy for eligibility: they determine the eligibility for all students except for non-minority students with fair GPA. In this sense, under , this program does not actually define when a student is eligible. The next rule is epistemic. It expresses that the school interviews a person whose eligibility is unknown. The remaining rules specify partial data on students Mary, Brit and David. In particular, and even are unknown.

For Mary, the first rule applies and the school knows that she is eligible. The epistemic fourth rule will therefore not conclude that she should be interviewed. Incidentally, nor is it implied that she will not be interviewed; the school (formally, the program) simply does not know. This follows from the informal semantics of the implicit composition operator: “all the agent knows is…”. For Brit and David, their eligibility is unknown. However, the reasons are different: for Brit because of lack of data, for David because the policy does not specify it. Therefore, both will be interviewed. The unique answer set extends the student data with the following literals:

The crucial property of this example is that whether a student should be interviewed does not only depend on properties of the student alone, but also on the agent’s knowledge about this student. In other words, it is perfectly possible that the same student should be interviewed when applying to school but not when applying to school , even when the eligibility criteria used by the two schools are precisely the same. Indeed, this can happen if school has more information on record about the student in question. Because of this property, a logic with a subjective informal semantics is required here.

It is illustrative to compare this example to, for instance, graph coloring. Whether a graph is colorable given a certain number of colors is purely a property of this graph itself. It does not depend on anyone’s knowledge about this graph, and it does not depend on which agent is doing the coloring. In other words, graph coloring lacks the subjective, epistemic component of the interview example. Consequently, as we illustrated in Section 1, applying to the rules of a typical GDT graph coloring program produces a misleading result. It refers to the knowledge of an agent, when in fact there exists no agent whose knowledge is relevant to the problem.

The interview example, with its inherent epistemic component, is a clear case where the informal semantics applies. Similar informal semantics have also been developed for other formalisms for modeling reasoning with incomplete information, including default logic (Reiter, 1980) and autoepistemic logic (Moore, 1985), and much of our discussion above extends to such formalisms, too. They all have a role to play but it is important to be aware of the scope of their applicability.

To the best of our knowledge, is the only informal semantics developed in the literature for the language of extended logic programs. Answer set programming adopted it, when it adopted the language of extended logic programming. However, the informal semantics is not suitable for typical answer set programing applications. Moreover, over time, answer set programming has developed a richer language with features not found in the original papers by Gelfond and Lifschitz, including choice rules, aggregates and weight constraints. If is often non-trivial to extend to these richer languages, as illustrated in the next paragraph.

Extending to modern ASP is difficult

As a simple example of a modern ASP language feature, we consider the constraint (3) used to model the property that nodes should be colored. As stated in the introduction, provides the following informal semantics for this rule: for every , Aux holds if the agent does not know Aux and is a node and the agent does not know that has a color.

Can a simpler informal semantics (that avoids the predicate ) be given for constraint (3) directly? This question is not easily answered. Starting from the way in which Table 6 interprets atoms and the operator not, one plausible candidate for such an informal semantics is the sentence: “for every , it is not the case that is a node and the agent does not know that has a color’.

However, upon closer analysis, this sentence turns out not to match with the formal semantics. This can be seen as follows. Let us suppose for simplicity that the Herbrand universe consists of only one constant . The proposed informal semantics boils down then to:

(*) “It is not the case that a is a node and the agent does not know that a has a color.”

Consider now the ASP program that consists only of the constraint (3). This program has a unique answer set , the empty believed literal set. Let be any (informal) belief state that satisfies (*). In order for our proposed sentence (*) to be a correct informal semantics for (3), this belief state must abstract to the unique answer set of . If so, then in it is not known that is colored (because ). It follows that must satisfy the property “it is not the case that a is a node.” In other words, cannot consider as possible any state of affairs in which is a node. Or, to put it in even simpler terms, the belief state must contain the belief that is not a node. However, since abstracts to , it must then be the case that , which is clearly false. Therefore, our proposed informal semantics of (3) is incorrect.

It is not the purpose of this article to present an epistemic informal semantics for modern ASP languages. We bring up this issue to point out that doing so is often more problematic than one might expect. This is not only the case for constraints, but also for choice rules, whose informal epistemic semantics has been the topic of lively debates in the ASP community444This is illustrated by the Texas Action Group discussion on the matter (http://www.cs.utexas.edu/users/vl/tag/choice_discussion).. For the sake of completeness, we conclude this discussion by mentioning that a correct informal epistemic reading of  (3) is:

(**) “for every , it is not the case that the agent knows that is a node and the agent does not know that has a color.”

Writing constraints such as (3) is common practice among ASP programmers. At the same time, the fact that (*) is not a correct informal semantics for them while (**) is, appears to be far from common knowledge. This illustrates the pitfalls of using the Gelfond and Lifschitz’ epistemic informal semantics with the GDT programming methodology.

Our goal in this paper is to develop an alternative informal semantics for answer set programming, which, unlike , is objective, that is, not epistemic, and extends to new features of the language that ASP now takes for granted. The rationale behind this effort is our conviction that such an objective informal semantics will be better aligned with typical GDT programs. Before we introduce it, we first review the GDT paradigm.

4 Generate-Define-Test methodology

The generate-define-test (GDT) methodology (Lifschitz, 2002) was proposed as a principled way to encode search problems in ASP. Over the years, it became the de facto standard in the field. The GDT methodology yields programs that consist of three parts: generate, define and test.

The role of generate is to generate the search space. In modern ASP languages this task is often accomplished by a set of choice rules:

(5)

where , , and are atoms (possibly, non propositional). Intuitively, rule (5) states that the atom in the head can take any of the values true and false, if the condition expressed by the body of the rule holds. We call the predicate symbol of generated.

The define part is a set of definitions of input and auxiliary predicates. Each definition is encoded by a group of normal rules (i.e., rules of the form (4) in which the expressions , and are all atoms). In such a rule, the predicate symbol of the head is the one being defined. Input predicates are defined by exhaustive enumeration of their extensions. That is, their definitions consist of sets of facts, i.e., rules of form (4) that have empty bodies and contain no variables. For facts, the symbol is often omitted from the notation. Auxiliary predicates are defined by sets of rules (4) that specify these symbols by describing how to derive their extensions from the extensions of the generated and input symbols.

Finally, the test part eliminates some generated candidate answer sets. It consists of constraint rules:

(6)

where and are atoms. Each constraint rule eliminates those candidate answer sets, in which all are true and all are false.

As such, the GDT methodology identifies different components of programs by assigning them a particular operational task (e.g., “generate search space”, “test candidate solution”) in the computation of answer sets. Thus, it is about the computation process of answer sets and not about the meaning of expressions in ASP programs. In other words, the GDT methodology does not specify an informal semantics for GDT programs.

We call finite sets of choice, normal, and constraint rules core ASP programs. For these core ASP programs, we will adopt the formal semantics proposed by Ferraris et al. (2011). The main concepts of this semantics are briefly reviewed in the appendix; we omit the details, as they are not relevant for the purposes of this paper.

While syntactically simple, core ASP programs are expressive enough to support the GDT methodology. Moreover, they are a part of almost all ASP dialects, modulo minor syntactic differences. Thus, they form a convenient target language for our study of GDT programs. However, the GDT methodology is not restricted to core ASP. Many applications rely on extensions such as aggregates and weight expressions, or use different means to implement the generate task (pairs of rules ; disjunctions ; or rules ). The discussion we present here also applies to programs that contain such expressions. We touch on this subject in Section 8.

To illustrate the GDT methodology, we present a core ASP program that encodes the Hamiltonian cycle problem.

(7)

The long horizontal lines indicate the partition of the program into the generate, define, and test parts respectively. The short lines inside the define part separate groups of rules defining individual predicates. Inside the test part, they separate individual constraints. Predicate symbol is a generated symbol, symbols and are input symbols, and is an auxiliary one. The generate part specifies all subsets of the relation as candidate solutions. The relations and represent all vertices and edges of the input graph and are defined by enumeration. The relation represents the auxiliary concept of the transitive closure of the relation . The test part “weeds out” those candidate answer sets, whose relation does not correspond to a Hamiltonian cycle. The auxiliary relation is necessary to state the constraint that a Hamiltonian cycle connects every pair of vertices.

As this example illustrates, a GDT program often has a rich internal structure. For instance, in the example above

  • rules can be partitioned into three groups generate, define and test

  • define contains separate definitions for three predicates , and , and

  • test consists of three independent constraints.

The fact that the internal structure of programs remains implicit in the standard ASP formalism motivates us to introduce the ASP-FO language in the next section that makes the structure of programs explicit. In ASP-FO, rules in generate, define and test can be further split out in independent modules called G-modules, D-modules and T-modules.

5 The logic ASP-FO

We now turn to our goal of developing an informal semantics for GDT programs. To this end, motivated by the GDT methodology, we propose a logic ASP-FO and develop for it an informal semantics. We design the logic ASP-FO so that each core ASP program can be cast as an ASP-FO program without any essential changes. In this way, the informal semantics for ASP-FO can be used for ASP programs and, as we argue, becomes particularly effective in explaning the meaning of GDT programs.

5.1 Syntax

As in FO, expressions of ASP-FO are built from predicate and function symbols of some vocabulary . Theories of ASP-FO consist of three types of modules: G-modules, D-modules and T-modules.

A choice rule is an expression of the form:

(8)

where is an FO formula, is an atom, and includes all free variables appearing in the rule. We call the expression the head of the rule and refer to as its head predicate. We call the body of the rule.

Definition 6 (G-module)

A G-module is a finite set of choice rules with the same head predicate. Moreover, the head predicate may not appear in the body of the rules.

While many modern ASP solvers allow recursive choice rules, our concept of G-modules is more restrictive. This is in keeping with our view of G-modules as modules that generate the search space from a given problem instance. To generate such a search space, recursion does not seem to be required.

Recursion is allowed and, in fact, necessary in the define part. A define rule is an expression of the form

(9)

where is an FO formula, is an atom, and includes all free variables appearing in the rule. The concepts of the head, the head predicate and the body of the rule are defined in an obvious way similarly as above.

Definition 7 (D-module)

A D-module is a pair , where Def is a finite set of predicates, called defined predicates, and is a finite set of define rules such that the head predicate of each rule belongs to Def.

For a D-module , we denote the set Def of its defined predicate symbols by . We write for the set of all predicate and function symbols in other than the defined predicates. We call the set of parameter symbols of .

For a set of define rules , by we denote the set of all predicate symbols appearing in the heads of rules in . Note that if is the set of define rules of a D-module , then . If the inclusion is proper, the D-modules and are different; the latter makes all predicates in universally false. In the following, we use as a shorthand notation for a D-module .

Definition 8 (T-module)

A T-module is an FO sentence.

While G-modules and D-modules are sets of expressions, a T-module is not. Since any finite set of FO sentences can be equivalently represented by its conjunction , the restriction of T-modules to single formulas does not result in any loss of generality.

Definition 9

An ASP-FO theory is a finite set of G-modules, D-modules, and T-modules.

We say that an ASP-FO module or theory is over vocabulary if every non-logical symbol mentioned in belongs to . In case of a D-module , also symbols in Def should belong to .

We say that a predicate is specified by a G-module or D-module if it is the head predicate of the G-module or a defined predicate of the D-module. Unless stated differently, we assume that no predicate is specified by more than one module in an ASP-FO theory as this suffices to express GDT programs. However, the formal definitions of syntax and semantics of ASP-FO do not require this limitation.

5.2 From Core ASP to ASP-FO Informally

There is an obvious match between language constructs of ASP-FO and those used in ASP to express generate, define and test. Specifically, an ASP choice rule (5) corresponds to an ASP-FO choice rule

a normal rule (4) corresponds to an ASP-FO define rule

and an ASP constraint (6) corresponds to the T-module given by the FO sentence

where in each case, is the set of variables occurring in the ASP expression (5), (4) and (6), respectively. These syntactical translations turn both the constraint operator and the negation-as-failure symbol not in (6) into the negation symbol .

Consider the encoding (7) of the Hamiltonian cycle problem. It can be embedded in ASP-FO in several ways, including the following encoding that makes explicit the hidden structure of that program:

(10)

Merging the three D-modules into one would yield another embedding, with less internal structure.

Any answer set program written in the base formalism of Section 4 has a straightforward syntactic translation to an ASP-FO theory: choice rules are grouped according to their head predicate; normal rules are grouped together in one D-module, and each constraint can be represented as a single T-module (in each case, after rewritings described above). In the case of a D-module we can often reveal its hidden structure by splitting it into several smaller D-modules (as we did in the theory (10)). Section 5.5 provides a detailed formal account on the relation between answer set programs and ASP-FO theories.

5.3 Semantics

We now introduce the formal semantics of ASP-FO. As in FO and in a growing number of ASP semantics, the semantics is based on the standard notion of -structures instead of literal sets. Using the terminology of logic programming and ASP, we call -structures also -interpretations.

A crucial feature of the semantics of ASP-FO is modularity: a structure/interpretation is a model of an ASP-FO theory if it is a model of each of its modules. In other words, an ASP-FO theory can be understood as a standard monotone conjunction of its modules.

Definition 10

An interpretation satisfies (is a model of) an ASP-FO theory , written , if satisfies (is a model of) each module in .

To complete the definition of the semantics of ASP-FO theories, we now define the semantics of individual modules.

T-modules

The case of T-modules is straightforward. T-modules are FO sentences and we use the classical definition of satisfaction (cf. Definition 3) to specify when a T-module holds in a structure.

G-modules

The role of choice rules in GDT programs is to “open up” some atoms  — to allow them to take any of the values true and false. We take this idea as the basis of our formalization of the semantics of G-modules.

Definition 11

An interpretation is a model of a G-module with head predicate  if for each tuple of elements in the domain of such that , there is a choice rule in and a tuple so that .

D-modules

We define the semantics of D-modules by adapting the stable semantics of definitions introduced by Pelov et al. (2007)<