A Brief History of Updates of Answer-Set Programs

In this paper, we will take a historical journey through some of the main approaches proposed to deal with the problem of updating logic programs under the stable model semantics.

Knowledge-based systems must keep a representation of the world — often encoded in some logic-based language equipped with a formal semantics and reasoning mechanisms — which is then used for reasoning, e.g., to automate decision making. Whereas languages that are based on classical logic — hence monotonic — like description logics, are often used, it has been known for several decades that non-monotonic features are important for common-sense reasoning, e.g., to properly deal with default information, preferences, the frame problem, etc. Of the many existing languages for knowledge representation that exhibit non-monotonic features, logic programming under the stable model semantics (a.k.a. answer-set programming, or ASP, for short), introduced by Gelfond and Lifschitz (1988; 1991), is perhaps the biggest success story so far. Established some 30 years ago, ASP is similar in syntax to traditional logic programming, and has a simple and well-understood non-monotonic declarative semantics with known relationships with other logic-based formalisms such as default logic, autoepistemic logic, propositional and predicate logic, etc. (cf. the work of Lifschitz (2008) and references therein). Its rich expressive power allows to compactly represent all NP and coNP problems if non-disjunctive logic programs are used, while disjunctive logic programs capture the complexity class $\Sigma_{2}^{p}$ and $\Pi_{2}^{p}$ (Eiter et al. 1997). Additionally, the existence of efficient implementations such as clasp (Gebser et al. 2011) and dlv (Leone et al. 2006) has made it possible to use ASP in significant applications in diverse areas such as configuration, diagnosis and repair, planning, classification, scheduling, robotics, information integration, legal reasoning, computational biology and bioinformatics, e-medicine, and decision support systems (cf. the surveys by Erdem et al. (2016), Erdem and Patoglu (2018),Falkner et al. (2018), and references therein).

One of the more recent challenges for knowledge engineering and information management is to efficiently and plausibly deal with the incorporation of new, possibly conflicting knowledge and beliefs. There are several domains where this may be required. For example, knowledge-based systems that check for legal and regulatory compliance — such as a public procurement monitoring system — need to keep track of changing laws and regulations, and reason with them. Simply adding the new laws and regulations to the knowledge base containing the older ones would not work, since the newer may be in conflict with the older. It may also not be as simple as deleting the old conflicting ones, since the conflict may be contingent on particular cases. For example, some initial regulation may state that institutions are allowed to enter a contract without a public offer if the contract’s value is below some fixed amount, and a later regulation may state that publicly funded foundations (a special kind of an institution) that have not filed their previous year’s tax return, are not allowed to enter a contract without a public offer. The knowledge-based system would have to automatically deal with these cases, in a way similar to the legal principle of lex posterior used by judges and other legal practitioners, according to which a newer law repeals an earlier conflicting one. Other domains where dealing with dynamic, possibly conflicting, knowledge and beliefs is important include multi-agent systems, where agents need to change their knowledge and beliefs to properly reflect their observations, including incoming messages from other agents, and even new norms, possibly resulting in a change in behaviour; stream reasoning systems that learn/extract knowledge from streams of data, which may be in conflict with previously learnt knowledge; or even transfer learning, where what is learnt by one system in one domain serves as initial knowledge when that system is placed in a different domain, which is then changed as new knowledge is learnt in the new domain. Indeed, any knowledge-based system that maintains a knowledge base about a dynamic world, i.e., a world that changes, needs to efficiently and plausibly deal with the incorporation of new, possibly conflicting knowledge.

The problems associated with the evolution of knowledge have been extensively studied over the years, in the context of classical logic. Most of this work was inspired by the seminal contribution of Alchourrón, Gärdenfors and Makinson (AGM) who proposed a set of desirable properties of belief change operators, now called AGM postulates (Alchourrón et al. 1985). Subsequently, update and revision have been distinguished as two very much related but ultimately different belief change operations (Keller and Winslett 1985; Winslett 1990; Katsuno and Mendelzon 1991). While revision deals with incorporating new better information about a static world, update takes place when changes occurring in a dynamic world are recorded. Katsuno and Mendelzon formulated a separate set of postulates for update, now known as KM postulates. For a comprehensive treatment of the subject and further references on belief change in classical logic, the reader is referred to the survey paper by Fermé and Hansson (2011).

Despite the large body of research on belief change in general, and on updates in particular, in the context of classical logic, the use of ASP for knowledge representation in dynamic domains, mainely due to its rule-based syntax and non-monotonic semantics, has called for a specific line of research on how to update an answer-set program, which constitutes the central topic of this paper.

To illustrate the problem at hand, consider an agent with knowledge represented by the following program $\mathcal{P}$ (where $\mathop{\sim\!}$ denotes default negation):

The only stable model of $\mathcal{P}$ is $I=\Set{\mathsf{money},\mathsf{goRestaurant}}$, capturing that the agent has money by rule (3), so according to rule (2) it plans to go to a restaurant. Suppose that the beliefs of the agent are to be updated by the program $\mathcal{U}$ with the following two rules:

What should the agent’s beliefs be after the update of $\mathcal{P}$ by $\mathcal{U}$?

The central research question is then how to semantically characterise pairs or, more generally, sequences of ASP programs (a.k.a. dynamic logic programs) where each component represents an update of the preceding ones, and, if possible, produce an ASP program that encodes the result of the updates.

Going back to the previous example, when we update $\mathcal{P}$ by $\mathcal{U}$, the intuitively correct result is that $\mathsf{robbed}$ is true and $\mathsf{money}$ is false, because of the rules in the update $\mathcal{U}$, and that $\mathsf{goRestaurant}$ should now be false because its only justification, $\mathsf{money}$, is no longer true. Furthermore, we would expect that $\mathsf{goHome}$ be now true, i.e., the rule (1) should be triggered because $\mathsf{money}$ became false.

Over the years, many have tackled this issue, which has proved far more difficult and elusive than perhaps originally thought. Earlier approaches (Marek and Truszczynski 1994; 1998; Przymusinski and Turner 1995; 1997; Alferes and Pereira 1996) were based on literal inertia, following some of the basic principles inherited from the possible models approach by Winslett (1988) — an approach to updates in propositional logic based on minimising the set of atoms whose truth value changes when an interpretation is updated that satisfies the KM postulates. However, they were soon found to be inadequate, or at least not sufficiently expressive to capture the result of updating an answer-set program by means of another answer-set program (Leite and Pereira 1998).

Since then, many different approaches were put forward. Though the state-of-the-art approaches are guided by the same basic intuitions and aspirations as belief change in classical logic, they build upon fundamentally different principles and methods. While many are based on the so-called causal rejection principle (Leite and Pereira 1998; Alferes et al. 2000; Eiter et al. 2002; Alferes et al. 2005; Osorio and Cuevas 2007), others employ syntactic transformations and other methods, such as abduction (Sakama and Inoue 2003), forgetting (Zhang and Foo 2005), prioritisation (Zhang 2006), preferences (Delgrande et al. 2007), or dependencies on defeasible assumptions (Šefránek 2011; Krümpelmann 2012).

One interesting feature about these developments is that the resulting operators often bear characteristics of revision rather than update, as viewed from the perspective of belief change in classical logic, often blurring the frontier between these two types of operations. We will review not only those approaches that aim to deal with updates, but also some operators that are closer to revision, but whose authors position their contribution as having similar goals, namely by comparing them with the operators specifically defined for updates. However, while evaluating the reviewed approaches, we will guide ourselves by the basic idea of what an update is, i.e., an operation that deals with incorporating new information about a dynamic world, as opposed to a revision which deals with incorporating better knowledge about a static world. In our opinion, underlying this definition of update is the assumption that the information acquired at each point in time is correct at that moment, as opposed to the assumption adopted in revision, whereby the information acquired at each time point is not necessarily correct, just better than what we had before. One relevant consequence is that an empty or tautological update (which we take to represent that nothing changed) should have no effect, because our beliefs about the world were correct and nothing changed, while it is acceptable that a revision by an empty or tautological update may lead to some change, for example restoring consistency, because we take it that in revision, our beliefs about the world were not necessarily correct.

More recently, both the AGM and KM postulates were revisited, taking into account a monotonic characterisation of ASP — HT-models (Pearce 1997; Lifschitz et al. 2001) — as the basis for new classes of revision and update operators (Delgrande et al. 2013; Slota and Leite 2014). Despite their own merits and shortcomings, these approaches based on HT-models have opened up new avenues to investigate other belief change operations in ASP, such as forgetting (Wang et al. 2012; 2013; 2014; Delgrande and Wang 2015) (see the paper by Gonçalves et al. (2016) for a survey on forgetting in ASP, or another survey in this volume), and new insights into unifying classical logic and ASP-based updates (Slota and Leite 2012a; b; Slota et al. 2015).

In this paper, we will briefly revisit the main landmarks in the history of updating answer-set programs. We will follow a chronological approach that divides it into three main eras, although not without intersection — model updates, syntax-based updates, and semantics-based updates — that correspond to the three main sections of this paper. These sections are preceded by a brief section (pre-history) on belief change in classical logic, and followed by an outlook where some current and future issues are discussed. Before we begin the journey, we provide a brief background section with the usual preliminaries on propositional logic, answer-set programming, and other basic concepts used throughout the paper.

Given the nature of this paper, we will often exercise some restraint on technical content in favour of better conveying the main intuitions and concepts underlying each approach and focusing on providing simple examples that bring forward their main differentiating features. Despite this compromise, this paper still conveys a novel and, we hope, significant scientific contribution, inasmuch as it is, to the best of our knowledge, the first encompassing and critical survey of the field, not only comparing different approaches but sometimes even providing intuitions and illustrative examples that were absent from the original papers.

The basic syntactic building blocks of rules are also propositional atoms from $\mathcal{L}$. A negative literal is an atom preceded by $\mathop{\sim\!}{}$ denoting default negation. A literal is either an atom or a negative literal. Throughout this paper, we adopt a convention that double default negation is absorbed, so that $\mathop{\sim\!}\mathop{\sim\!}\mathsf{p}$ denotes the atom $\mathsf{p}$. Given a set $S$ of literals, we introduce the following notation: $S^{+}=\Set{\mathsf{p}\in\mathcal{L}}{\mathsf{p}\in S}$, $S^{-}=\Set{\mathsf{p}\in\mathcal{L}}{\mathop{\sim\!}\mathsf{p}\in S}$, and $\mathop{\sim\!}S=\Set{\mathop{\sim\!}L}{L\in S}$.

A rule is a pair of sets of literals $\pi=\langle H(\pi),B(\pi)\rangle$. We say that $H(\pi)$ is the head of $\pi$ and $B(\pi)$ is the body of $\pi$. Usually, for convenience, we write $\pi$ as

A rule is called non-disjunctive if its head contains at most one literal; a fact if its head contains exactly one literal and its body is empty; an integrity constraint if its head is empty. A program is any set of rules. A program is non-disjunctive if all its rules are.

We define the class of acyclic programs using level mappings (Apt and Bezem 1991). A level mapping is a function $\ell$ that assigns a natural number to every atom, and is extended to default literals and sets of literals by putting $\ell(\mathop{\sim\!}L)=\ell(L)$ and $\ell(S)=\max\set{\ell(L)}{L\in S}$. We say that a program $\mathcal{P}$ is acyclic if there exists a level mapping $\ell$ such that for every rule $\pi\in\mathcal{P}$ it holds that $H(\pi)\neq\emptyset$ and $\ell(l_{H})>\ell(l_{B})$ for every $l_{H}\in H(\pi)$ and every $l_{B}\in B(\pi)$.

In the following, we define the answer-sets (a.k.a. stable models) of a program (Gelfond and Lifschitz 1988; 1991) as well as two monotonic model-theoretic characterisations of rules and programs. One is that of classical models, where a rule is simply treated as a classical implication. The other, HT-models, is based on the logic of here-and-there (Heyting 1930; Pearce 1997) and is expressive enough to capture both classical models and answer-sets.

Satisfaction of programs is obtained by treating rules as classical implications. Table 1 defines satisfaction of literals $l$ and $\mathop{\sim\!}l$, a set of literals $S$, a rule $\pi$ and a program $\mathcal{P}$ in an interpretation $J\subseteq\mathcal{L}$. We say that $J$ is a C-model (classical model) of a rule $\pi$ if $J\mathrel{\mid}\joinrel=\pi$, and a C-model of a program $\mathcal{P}$ if $J\mathrel{\mid}\joinrel=\mathcal{P}$. The set of all C-models of a rule $\pi$ is denoted by $\llbracket\pi\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{C}$}}$ and for any program $\mathcal{P}$, $\llbracket\mathcal{P}\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{C}$}}=\bigcap_{\pi\in\mathcal{P}}\llbracket\pi\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{C}$}}$. A program $\mathcal{P}$ is consistent if $\llbracket\mathcal{P}\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{C}$}}\neq\emptyset$, and inconsistent otherwise.

The stable and HT-models are defined in terms of reducts. Given a program $\mathcal{P}$ and an interpretation $J$, the reduct of $\mathcal{P}$ w.r.t. $J$ is defined as

An interpretation $J$ is a stable model of a program $\mathcal{P}$ if $J$ is a subset-minimal C-model of $\mathcal{P}^{J}$. The set of all stable models of $\mathcal{P}$ is denoted by $\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{SM}$}}$. A program $\mathcal{P}$ is coherent if $\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{SM}$}}\neq\emptyset$, and incoherent otherwise.

HT-models are semantic structures that can be seen as three-valued interpretations. In particular, we call a pair of interpretations $X=\langle I,J\rangle$ such that $I\subseteq J$ a three-valued interpretation. Each atom $\mathsf{p}$ is assigned one of three truth values in $X$: $X(\mathsf{p})=\mathsf{T}$ if $\mathsf{p}\in I$; $X(\mathsf{p})=\mathsf{U}$ if $\mathsf{p}\in J\setminus I$; $X(\mathsf{p})=\mathsf{F}$ if $\mathsf{p}\in\mathcal{L}\setminus J$. The set of all three-valued interpretations is denoted by $\mathscr{X}$. A three-valued interpretation $\langle I,J\rangle$ is an HT-model of a rule $\pi$ if $J\mathrel{\mid}\joinrel=\pi$ and $I\mathrel{\mid}\joinrel=\pi^{J}$. The set of all HT-models of a rule $\pi$ is denoted by $\llbracket\hskip 0.86108pt\pi\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$ and for any program $\mathcal{P}$, $\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}=\bigcap_{\pi\in\mathcal{P}}\llbracket\hskip 0.86108pt\pi\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$. Note that $J$ is a stable model of $\mathcal{P}$ if and only if $\langle J,J\rangle\in\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$ and for all $I\subsetneq J$, $\langle I,J\rangle\notin\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$. Also, $J\in\llbracket\mathcal{P}\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{C}$}}$ if and only if $\langle J,J\rangle\in\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$. We write $(I,J)\mathrel{\mid}\joinrel=\mathcal{P}$ if $(I,J)\in\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$. We say that $\mathcal{P}$ is strongly equivalent to $\mathcal{Q}$, denoted by $\mathcal{P}\equiv_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}\mathcal{Q}$, if $\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}=\llbracket\hskip 0.86108pt\mathcal{Q}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$, and that $\mathcal{P}$ strongly entails $\mathcal{Q}$, denoted by $\mathcal{P}\mathrel{\mid}\joinrel=_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}\mathcal{Q}$, if $\llbracket\hskip 0.86108pt\mathcal{P}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}\subseteq\llbracket\hskip 0.86108pt\mathcal{Q}\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}$. A rule $\pi$ is tautological if $\llbracket\hskip 0.86108pt\pi\hskip 0.86108pt\rrbracket_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{HT}$}}=\mathscr{X}$. It follows from the results of Inoue and Sakama (2004) and Cabalar et al. (2007) that a rule $\pi$ is tautological if $B(\pi)\cap H(\pi)\neq\emptyset$ or $B(\pi)^{+}\cap B(\pi)^{-}\neq\emptyset$.

The class of programs defined above can be extended to allow for a second form of negation, dubbed strong negation. In a nutshell, $\mathcal{L}$ is extended to also include, for each of its original atoms $\mathsf{p}$, its (strong) negation $\lnot\mathsf{p}$. Elements of this extended $\mathcal{L}$ are dubbed objective literals and we use the following notation to refer to complementary objective literals: $\overline{\mathsf{p}}=\lnot\mathsf{p}$ and $\overline{\lnot\mathsf{p}}=\mathsf{p}$ for any atom $\mathsf{p}$. Each atom $\mathsf{p}$ is interpreted separately of (though still consistently with) its strong negation $\lnot\mathsf{p}$. Each interpretation naturally corresponds to a consistent subset of the extended set $\mathcal{L}$. More formally, an (extended) interpretation is a subset of $\mathcal{L}$ that does not contain both $l$ and $\overline{l}$ for any objective literal $l$. Note that this is in contrast with the definition of answer-set by Gelfond and Lifschitz (1991), which allows for certain programs to have their semantics be characterised by the so-called contradictory answer-set $\mathcal{L}$.

To simplify notation, first-order atoms with variables are often used in program rules. Such rules should be seen as a shortcut corresponding to the set of rules obtained by replacing the variables with constants to form atoms in $\mathcal{L}$, in all possible ways.

An update is typically described as an operation that brings a knowledge base up to date when the world described by it changes, whereas a revision is typically described as an operation that deals with incorporating new better knowledge about a world that did not change (Keller and Winslett 1985; Winslett 1990; Katsuno and Mendelzon 1991). From a generic perspective, both forms of belief change operators — update and revision — were studied within the context of propositional logic.

Propositional belief change operators, either for update ($\mathbin{\diamond}$) or for revision ($\mathbin{\circ}$), take two propositional formulas, representing the original knowledge base and its update, as arguments, and return a formula representing the updated knowledge base. Any such operator $\mathbin{\ast}\in\{\mathbin{\diamond},\mathbin{\circ}\}$ is inductively generalised to finite sequences $\langle\phi_{i}\rangle_{i<n}$ of propositional formulas as follows: $\raisebox{-1.0pt}{{\Large$\ast$}}\langle\phi_{0}\rangle=\phi_{0}$ and $\raisebox{-1.0pt}{{\Large$\ast$}}\langle\phi_{i}\rangle_{i<n+1}=(\raisebox{-1.0pt}{{\Large$\ast$}}\langle\phi_{i}\rangle_{i<n})\mathbin{\ast}\phi_{n}$, $n>0$. To further specify the desired properties of belief change operators, Katsuno and Mendelzon (1989; 1991) proposed two sets of postulates — one for revision and one for update. Following the original order of presentation, we will first briefly review the postulates for revision, and then those for update. Even though these postulate have been mostly absent from the literature in updates of answer-set programs, more so during the era of syntax-based updates, they took a more prominent role during the era of semantic-based updates, and will be revisited in Section 6.

We start with the following six postulates for a belief revision operator $\mathbin{\circ}$ and formulas $\phi$, $\psi$, $\mu$, $\nu$, proposed by Katsuno and Mendelzon (1989), which correspond to the AGM postulates for the case of propositional logic.

1. (BR1)

   $\phi\mathbin{\circ}\mu\mathrel{\mid}\joinrel=\mu$.

2. (BR2)

   If $\llbracket\hskip 0.86108pt\phi\land\mu\hskip 0.86108pt\rrbracket\neq\emptyset$, then $\phi\mathbin{\circ}\mu\equiv\phi\land\mu$.

3. (BR3)

   If $\llbracket\hskip 0.86108pt\mu\hskip 0.86108pt\rrbracket\neq\emptyset$, then $\llbracket\hskip 0.86108pt\phi\mathbin{\circ}\mu\hskip 0.86108pt\rrbracket\neq\emptyset$.

4. (BR4)

   If $\phi\equiv\psi$ and $\mu\equiv\nu$, then $\phi\mathbin{\circ}\mu\equiv\psi\mathbin{\circ}\nu$.

5. (BR5)

   $(\phi\mathbin{\circ}\mu)\land\nu\mathrel{\mid}\joinrel=\phi\mathbin{\circ}(\mu\land\nu)$.

6. (BR6)

   If $\llbracket\hskip 0.86108pt(\phi\mathbin{\circ}\mu)\land\nu\hskip 0.86108pt\rrbracket\neq\emptyset$, then $\phi\mathbin{\circ}(\mu\land\nu)\mathrel{\mid}\joinrel=(\phi\mathbin{\circ}\mu)\land\nu$.

Most of these postulates can be given a simple intuitive reading. For instance, (BR1) requires that information from the revision be retained in the revised belief base. This is also frequently referred to as the principle of primacy of new information (Dalal 1988). Postulate (BR2) requires that whenever the original formula and the revision are jointly consistent, the result corresponds to their conjunction. Postulate (BR3) requires that whenever the formula used for revision is satisfiable, then so should be the result of the revision. Postulate (BR4) encodes independence of syntax. Postulates (BR5) and (BR6) require that revision should be accomplished with minimal change.

The main idea behind these postulates is formally captured by the notion of a belief revision operator characterised by an order assignment.

A set of natural conditions on the assigned orders is captured by the following notion of a faithful order assignment.

The representation theorem of Katsuno and Mendelzon (1989) states that operators characterised by faithful total preorder assignments over the set of all formulas are exactly those that satisfy the KM revision postulates.

Whereas according to Katsuno and Mendelzon (1991), revision is used when we are obtaining new information about a static world, updates consists of bringing a knowledge base up to date when the world described by it changes. To characterise updates, Katsuno and Mendelzon (1991) proposed the following eight postulates for a belief update operator $\mathbin{\diamond}$ and formulas $\phi$, $\psi$, $\mu$, $\nu$:

1. (BU1)

   $\phi\mathbin{\diamond}\mu\mathrel{\mid}\joinrel=\mu$.

2. (BU2)

   If $\phi\mathrel{\mid}\joinrel=\mu$, then $\phi\mathbin{\diamond}\mu\equiv\phi$.

3. (BU3)

   If $\llbracket\hskip 0.86108pt\phi\hskip 0.86108pt\rrbracket\neq\emptyset$ and $\llbracket\hskip 0.86108pt\mu\hskip 0.86108pt\rrbracket\neq\emptyset$, then $\llbracket\hskip 0.86108pt\phi\mathbin{\diamond}\mu\hskip 0.86108pt\rrbracket\neq\emptyset$.

4. (BU4)

   If $\phi\equiv\psi$ and $\mu\equiv\nu$, then $\phi\mathbin{\diamond}\mu\equiv\psi\mathbin{\diamond}\nu$.

5. (BU5)

   $(\phi\mathbin{\diamond}\mu)\land\nu\mathrel{\mid}\joinrel=\phi\mathbin{\diamond}(\mu\land\nu)$.

6. (BU6)

   If $\phi\mathbin{\diamond}\mu\mathrel{\mid}\joinrel=\nu$ and $\phi\mathbin{\diamond}\nu\mathrel{\mid}\joinrel=\mu$, then $\phi\mathbin{\diamond}\mu\equiv\phi\mathbin{\diamond}\nu$.

7. (BU7)

   If $\phi$ is complete, then $(\phi\mathbin{\diamond}\mu)\land(\phi\mathbin{\diamond}\nu)\mathrel{\mid}\joinrel=\phi\mathbin{\diamond}(\mu\lor\nu)$.

8. (BU8)

   $(\phi\lor\psi)\mathbin{\diamond}\mu\equiv(\phi\mathbin{\diamond}\mu)\lor(\psi\mathbin{\diamond}\mu)$.

Postulates (BU1)–(BU5) correspond to postulates (BR1)–(BR5). However, when $\phi$ is consistent, then (BU2) is weaker than (BR2). The property expressed by (BU8) is at the heart of belief updates: Alternative models of the original belief base $\phi$ or $\psi$ are treated as possible real states of the modelled world. Each of these models is updated independently of the others to make it consistent with the update $\mu$, obtaining a new set of interpretations — the models of the updated belief base. Based on this view of updates, Katsuno and Mendelzon (1991) proved an important representation theorem that makes it possible to constructively characterise and evaluate every operator $\mathbin{\diamond}$ that satisfies postulates (BU1) – (BU8). The main idea, based on postulate (BU8), is formally captured by the notion of a belief update operator characterised by an order assignment.

A natural condition on the assigned orders is that every interpretation be the closest to itself, captured by the following notion of a faithful order assignment.

The representation theorem of Katsuno and Mendelzon (1991) states that operators characterised by faithful order assignments over $\mathscr{I}$ are exactly those that satisfy the KM update postulates.

Katsuno and Mendelzon’s result provides a framework for belief update operators, each specified on the semantic level by strict preorders assigned to each propositional interpretation. The most influential instance of this framework is the possible models approach by Winslett (1988), based on minimising the set of atoms whose truth value changes when an interpretation is updated. Formally, for all interpretations $I$, $J$ and $K$, the strict preorder $<^{I}_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{W}$}}$ is defined as follows: $J<^{I}_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{W}$}}K$ if and only if $(J\div I)\subsetneq(K\div I)$, where $\div$ denotes set-theoretic symmetric difference. The operator $\mathbin{\mathbin{\diamond}_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{W}$}}}$ by Winslett, unique up to equivalence of its inputs and output, thus satisfies the following equation:

Note that it follows from Theorem 6 that $\mathbin{\mathbin{\diamond}_{\raisebox{-1.0pt}{$\scriptscriptstyle\mathsf{W}$}}}$ satisfies postulates (BU1) – (BU8).

The first authors to address the issue of updates and logic programs using the stable model semantics were Marek and Truszczynski (1994; 1998), although not as a means to update logic program. Instead, they used a rule based language, and a semantics similar to the stable models semantics, to specify the updates of a database.

The underlying idea was that the rules would specify constraints that had to be satisfied by a database. Then, given an initial database and a set of rules, Marek and Truszczynski (1994; 1998) defined a semantics that assigns a set of databases that are the justified result of the update.

In a nutshell, a database $DB^{\prime}$ is considered to be a justified update of a database $DB$ by a program $U$ if $DB^{\prime}$, viewed as an interpretation, is a model of $U$, and no other database $DB^{\prime\prime}$, that is also a model of $U$, is closer to $DB$ than $DB^{\prime}$.

Procedurally, this notion of justified update corresponds to following the common-sense law of inertia, whereby only those elements that need to be changed due to the update specification are actually changed, the remaining staying the same, in line with the ideas proposed by Winslett (1988).

Representing databases as interpretations, update programs as logic programs, and with $\div$ denoting set-theoretic symmetric difference, as before, the set of interpretations resulting from updating $I$ by $\mathcal{U}$ is given by

Subsequently, Przymusinski and Turner (1995; 1997) showed how the framework proposed by Marek and Truszczynski (1994; 1998) could be captured by logic programming under the stable models semantics, by encoding the initial database as a set of facts, the rules proposed by Marek and Truszczynski (1994; 1998) as rules of logic programming, and by adding additional rules encoding the common-sense law of inertia, so that the stable models of the resulting logic program would correspond to the justified updates of the initial database.

It was Alferes and Pereira (1996) who first proposed to use a logic program to update another logic program, under the stable model semantics. Following the possible models approach proposed by Winslett (1988), a knowledge base $DB^{\prime}$ is considered to be the update of a knowledge base $DB$ by $U$ if each model of $DB^{\prime}$ is an update of a model of $DB$ by $U$.

According to this approach, dubbed the model update approach, the problem of finding an update of a logic program $\mathcal{P}$ is reduced to the problem of individually finding updates of each of its stable models $I$. Each stable model would be updated following the ideas proposed by Marek and Truszczynski (1994; 1998), i.e., following the common-sense law of inertia, or minimal change.

Just like Przymusinski and Turner (1995; 1997), Alferes and Pereira (1996) proposed an encoding of the problem of updating a program $\mathcal{P}$ by a program $\mathcal{U}$ into logic programming, producing another logic program, written in an extended language, whose stable models correspond to the updates of each of the stable models of $\mathcal{P}$ by $\mathcal{U}$.

According to Alferes and Pereira (1996), the update of a program $\mathcal{P}$ by a program $\mathcal{U}$ is characterised by the following set of interpretations:

As it turns out, when we take a closer look at this semantics, we soon realise that things do not behave exactly as one might expect.

The undesirable behaviour illustrated by the previous example was first observed by Leite and Pereira (1998), leading to the beginning of the second era.

The reason for the problem illustrated by the example at the end of the previous section is that modifications on the level of individual stable models, akin to model-based belief update operators, are unable to capture the essential relationships between literals encoded in rules. This was first argued by Leite and Pereira (1998), who took a closer look at Newton’s first law, also known as the law of inertia, which states that “every body remains at rest or moves with constant velocity in a straight line, unless it is compelled to change that state by an unbalanced force acting upon it” (Newtono 1726).¹¹1The original text of Newton is as follows: “Corpus omne perseverare in statu suo quiescendi vel movendi uniformiter in directum, nisi quatenus illud a viribus impressis cogitur statum suum mutare.”. In their discussion, Leite and Pereira pointed out that the common-sense interpretation of this law as “things keep as they are unless some kind of force is applied to them” is true, but does not exhaust its meaning. It is the result of all applied forces that governs the outcome. Take a body to which several forces are applied, and which is in a state of equilibrium due to those forces cancelling out. Later, one of those forces is removed and the body starts to move. The same kind of behaviour presents itself when updating programs. Before obtaining the truth value, by inertia, of those elements not directly affected by the update program, one should verify whether the truth of such elements is not indirectly affected by the updating of other elements or, in other words, whether there is still some rule that supports such truth.

To rectify this problem, a number of approaches were proposed. Despite being based on fundamentally different principles and methods when compared to their model update counterparts, they all take into account the syntactic rule-based form of the programs involved.

This section provides an overview of existing rule update semantics, pointing at some of the technical as well as semantic differences between them, often relying on examples to show how these semantics are interrelated.

Rule update semantics typically deal only with ground non-disjunctive rules and some do not allow for default negation in their heads. While some of them follow the belief update tradition and construct an updated program given the original program and its update, others only assign a set of stable models to a pair or sequence of programs where each represents an update of the preceding ones. In order to compare these semantics, we adopt the latter, less restrictive point of view. The “input” of a rule update semantics is thus defined as follows:

In order to avoid issues with rules that are repeated in multiple components of a DLP, we assume throughout this section that every rule is uniquely identified in all set-theoretic operations. This could be formalised by assigning a unique name to each rule and performing operations on names instead of on the rules themselves.

The set of stable models assigned to dynamic logic programs under a particular update semantics will be denoted as follows:

Whenever an approach is defined through a rule update operator, such an operator is understood as a function that assigns a program to each pair of programs. A rule update operator $\mathbin{\oplus}$ is extended to DLPs as follows: $\mathop{\bigoplus}\langle\mathcal{P}_{0}\rangle=\mathcal{P}_{0}$; $\mathop{\bigoplus}\langle\mathcal{P}_{i}\rangle_{i<n+1}=(\mathop{\bigoplus}\langle\mathcal{P}_{i}\rangle_{i<n})\mathbin{\oplus}\mathcal{P}_{n}$, $n>0$. Note that such an operator naturally induces a rule update semantics $\textsf{S}_{\mathbin{\oplus}}$: given a DLP $\boldsymbol{P}$, the $\textsf{S}_{\mathbin{\oplus}}$-models of $\boldsymbol{P}$ are the stable models of $\mathop{\bigoplus}\boldsymbol{P}$. In the rest of this paper, we exercise a slight abuse of notation by referring to the operators and their associated update semantics interchangeably.

We first discuss a major group of semantics based on the causal rejection principle (Leite and Pereira 1998; Buccafurri et al. 1999; Alferes et al. 2000; Eiter et al. 2002; Alferes et al. 2005; Osorio and Cuevas 2007), followed by semantics based on preferences (Zhang 2006; Delgrande et al. 2007). We then proceed to discuss semantics that bear some characteristics of revision rather than update (Sakama and Inoue 2003; Osorio and Zepeda 2007; Delgrande 2010) and touch upon approaches that manipulate dependencies on default assumptions induced by rules (Šefránek 2011; Krümpelmann and Kern-Isberner 2010; Krümpelmann 2012). Towards the end of this section, we formulate some fundamental properties of rule update semantics.

The use and effect of integrity constraints within the semantics presented in this section has not received significant attention in the literature. Whereas most semantics are only defined for programs without integrity constraints, often pointing to the fact that one can replace the integrity constraint $\leftarrow B(\pi).$ with the rule $a_{\pi}\leftarrow\mathop{\sim\!}a_{\pi},B(\pi).$, where $a_{\pi}$ is a new atom, with the same effect, other semantics are defined for programs with integrity constraints, but without any specific provisions regarding their role. Since all these semantics that were defined for programs with integrity constraints are preserved under the above transformation that eliminates them, in this section we will restrict the definition of semantics to only consider DLPs without integrity constraints.