Earlier in Chapter 3 we discussed several results and properties of AnsProlog* programs that are useful in analyzing and step-by-step building of these programs. In this chapter we consider some broader properties that help answer questions such as: (a) how difficult is it to compute answer sets of various sub-classes of AnsProlog*? (b) how expressive are the various sub-classes of AnsProlog*? (c) does the use of AnsProlog* lead to compact representation or can it be compiled to a more tractable representation? and (d) what is the relationship between AnsProlog* and other knowledge representation formalisms?

The answers to these questions are important in many ways. For example, if we know the complexity of a problem that we want to solve then the answer to (a) will tell us which particular subset of AnsProlog* will be most efficient, and the answer to (b) will tell us the most restricted subset that we can use to represent that problem. With respect to (c) we will discuss results that show that AnsProlog* leads to a compact representation. This clarifies the misconception that since many AnsProlog* classes belong to a higher complexity class, they are not very useful. For specifications where AnsProlog* leads to (exponentially) compact representation the fact that they are computationally harder is canceled out and they become preferable because compact representation means that the programmer has to write less. So the burden is shifted from the programmer to the computer, which is often desirable.

In this chapter we present several small AnsProlog* programs corresponding to several declarative problem solving modules or knowledge representation and reasoning aspects. Although in general we may have intermingling of the declarative problem solving, and the knowledge representation and reasoning aspects, they can be differentiated as follows.

Normally a problem solving task is to find solutions of a problem. A declarative way to do that is to declaratively enumerate the possible solutions and the tests such that the answer sets of the resulting program correspond to the solutions of the problem. The declarative problem solving modules that we consider in this chapter include modules that enforce simple constraints, modules that enumerate interpretations with respect to a set of atoms, modules that uniquely choose from a set of possibilities, modules that encode propositional satisfiability, modules that represent closed first-order queries, modules that check satisfiability of quantified boolean formulas with up to two quantifiers, modules that assign a linear ordering between a set of objects, modules that can represent various aggregations of facts (such as minimization, maximization, sum and average), modules that encode classical disjunction conclusions, modules that encode exclusive-or conclusions, and modules that encode cardinality and weight constraints.

By knowledge representation and reasoning aspects we mean representing particular benchmark aspects of nonmonotonic and common-sense reasoning that we want to be encoded by AnsProlog* programs.

So far in the book we have considered sub-classes of AnsProlog* which have been well-studied in the literature and two additional extensions AnsPrologsm and AnsPrologdlv which are the input language of the answer set computing systems Smodels and dlv. There have been several additional proposals for extending AnsProlog*, which are not that well-studied. Also, there have been many alternative proposals to characterize programs in the syntax of AnsProlog* and its sub-classes. In this chapter we give a brief overview of the above two aspects.

Some of the extensions that we consider are: (i) enriching the rules by allowing not in the head of rules, (ii) allowing nesting in the head and body of rules; (iii) allowing additional operators such as knowledge and belief operators; (iv) enriching the framework by allowing abduction; (v) allowing explicit specification of intent to use domain closure and its impact on the universal query problem; (vi) allowing set constructs; and (vii) allowing specification preferences between rules of a program.

In regard to alternative characterizations of programs in the syntax of AnsProlog* and its sub-classes, we focus mostly on AnsProlog and AnsProlog¬ syntax, and the well-founded semantics. In the process we define notions such as the 3-valued stable models, and stable classes which are related to both the well-founded characterization and the answer sets. We also briefly discuss the framework of argumentation which can be used in defining both answer sets and the well-founded characterization of programs in AnsProlog syntax.

In this chapter we discuss four algorithms for computing answer sets of ground AnsProlog* programs. The first three algorithms compute answer sets of ground AnsProlog programs while the fourth algorithm computes answer sets of ground AnsPrologor programs. In Chapter 8 we will discuss several implemented systems that compute answer sets and use algorithms from this chapter.

Recall that for ground AnsProlog and AnsPrologor programs π answer sets are finite sets of atoms and are subsets of HBMπ. In other words answer sets are particular (Herbrand) interpretations of π which satisfy additional properties. Intuitively, for an answer set A of π all atoms in A are viewed as true with respect to A, and all atoms not in A are viewed as false with respect to A. Most answer set computing algorithms – including the algorithms in this chapter – search in the space of partial interpretations, where in a partial interpretation some atoms have the truth value true, some others have the truth value false and the remaining are considered to be neither true nor false. In the first three algorithms in this chapter the partial interpretations are 3-valued and are referred to as 3-valued interpretations, while in the fourth algorithm the partial interpretation that is used is 4-valued. Recall that we introduced 3-valued interpretations in Section 6.6.9, and that in 3-valued interpretations the atoms which are neither true not false have the truth value unknown.

In this chapter we present several fundamental results that are useful in analyzing and step-by-step building of AnsProlog* Programs, viewed both as stand alone programs and as functions. To analyze AnsProlog* programs we define and describe several properties such as categoricity (presence of unique answer sets), coherence (presence of at least one answer set), computability (answer set computation being recursive), filter-abducibility (abductive assimilation of observations using filtering), language independence (independence between answer sets of a program and the language), language tolerance (preservation of the meaning of a program with respect to the original language when the language is enlarged), compilabity to first-order theory, amenabity to removal of or, and restricted monotonicity (exhibition of monotonicity with respect to a select set of literals).

We also define several subclasses of AnsProlog* programs such as stratified, locally stratified, acyclic, tight, signed, head cycle free and several conditions on AnsProlog* rules such as well-moded and state results about which AnsProlog* programs have what properties. We present several results that relate answer sets of an AnsProlog* program to its rules. We develop the notion of splitting and show how the notions of stratification, local stratification, and splitting can be used in step-by-step computation of answer sets.

For step-by-step building of AnsProlog* programs we develop the notion of conservative extension – where a program preserves its original meaning after additional rules are added to it, and present conditions for programs that exhibit this property.

Representing knowledge and reasoning with it are important components of an intelligent system, and are two important facets of Artificial Intelligence. Another important expectation from intelligent systems is their ability to accept high level requests – as opposed to detailed step-by-step instructions, and their knowledge and reasoning ability are used to figure out the detailed steps that need to be taken. To have this ability intelligent systems must have a declarative interface whose input language must be based on logic.

Thus the author considers the all-round development of a suitable declarative knowledge representation language to be a fundamental component of knowledge based intelligence, perhaps similar to the role of the language of calculus to mathematics, and physics. Taking the calculus analogy further, it is important that a large support structure is developed around the language, similar to the integration and derivation formulas and the various theorems around calculus.

Although several languages have been proposed for knowledge representation, the language of AnsProlog* – logic programming with the answer set semantics, stands out in terms of the size and variety of the support structure developed around it. The support structure includes both implementations and use of the implementations in developing applications, and theoretical results for both analyzing and step-by-step building of theories (or programs) in this language. The support structure and the desirable properties of the language are also a testimony to the appropriateness of the language for knowledge representation, reasoning, and declarative problem solving.

Chapter 2 introduced several methods using message passing as a mechanism for effective belief updating in BNs. The λ – π message passing method along the arcs of a BN produces exact posteriors only in tree-structured BNs. Loop cutset conditioning requires converting a nontree BN into multiple tree-structured BNs and carrying out λ – π message passing in each of them. The stochastic simulation can be applied directly to a nontree BN to compute approximate posteriors but requires massive message passing in the BN. In this chapter, we focus on concise message passing and will drop the word concise when there is no confusion. We explore the opportunities presented by reorganizing the DAG structure of a BN into a cluster graph structure. The objective is to develop an alternative exact method that uses concise message passing in a single cluster graph structure for belief updating with nontree BNs. A cluster graph consists of an interconnected set of clusters. Each cluster is a subset of nodes (variables) in the original BN. Message passing is performed between adjacent clusters in the cluster graph. We investigate under what conditions such message passing leads to correct belief updating.

Section 3.2 introduces cluster graphs. A set of conventions on how a cluster graph constrains message passing is outlined in Section 3.3.

In Chapter 7, we developed algorithms to compile a given MSBN into an LJF, and in Chapter 8, we described multiagent belief updating by message passing. We have not discussed how an MSBN is constructed. In this chapter, we address issues related to the construction of MSBNs. In particular, we study how to integrate an MSBN-based multiagent system from agents developed by independent vendors. As detailed in Chapter 6, an MSBN is characterized by a set of technical conditions. Because independently developed subnets may not satisfy these conditions collectively, automatic verification is required to avoid the “garbage in and garbage out” scenario. The verification process becomes subtle when agents are built by independent vendors and the vendors' know-how needs to be protected. We develop a set of distributed algorithms that verify the integrity of an integrated multiagent system against the technical requirements of an MSBN.

The motivations for multiagent distributed verification are presented in Section 9.2. Section 9.3 addresses the verification of subdomain division among agents. The concept of the interface graph is introduced to capture the knowledge of the system integrator about the public aspects of multiple agents. A simple method to verify the subdomain division using the interface graph is presented. Constructing the hypertree of the MSBN at the logical level once the subdomain division is validated is also described.

Chapter 4 discussed the conversion of the DAG structure of a BN into a junction tree. In a BN, the strength of probabilistic dependence between variables is encoded by conditional probability distributions. This quantitative knowledge is encoded in a junction tree model in terms of probability distributions over clusters. For flexibility, these distributions are often unnormalized and are termed potentials. This chapter addresses conversion of the conditional probability distributions of a BN into potentials in a junction tree model and how to perform belief updating by passing potentials as concise messages in a junction tree.

Section 5.2 defines basic operations over potentials: product, quotient, and marginal. Important properties of mixed operations are discussed, including associativity, order independence, and reversibility. These basic and mixed operations form the basis of message manipulation during concise message passing. Initializing of potentials in a junction tree according to the Bayesian network from which it is derived is then considered in Section 5.3. Section 5.4 presents an algorithm for message passing over a separator in a junction tree and discusses the algorithm's consequences. Extending this algorithm, Section 5.5 addresses belief updating by message passing in a junction tree model and formally establishes the correctness of the resultant belief. Processing observations is described in Section 5.6.

Guide to Chapter 5

Given a BN, its DAG structure provides the qualitative knowledge about the dependence among domain variables.

Chapters 2 through 5 studied exact probabilistic reasoning using a junction tree representation converted from a Bayesian network. The single-agent paradigm is followed in the study. Under this paradigm, a single computational entity, an agent, has access to a BN over a problem domain, converts the BN into a JT, acquires observations from the domain, reasons about the state of the domain by concise message passing over the JT, and takes actions accordingly. Such a paradigm has its limitations: A problem domain may be too complex, and thus building a single agent capable of being in charge of the reasoning task for the entire domain becomes too difficult. Examples of complex domains include designing intricate machines such as an aircraft and monitoring and troubleshooting complicated mechanisms such as chemical processes. The problem domain may spread over a large geographical area, and thus transmitting observations from many regions to a central location for processing is undesirable owing to communications cost, delay, and unreliability.

This and subsequent chapters consider the uncertain reasoning task under the multiagent paradigm in which a set of cooperating computational agents takes charge of the reasoning task of a large and complex uncertain problem domain. This chapter deals with the knowledge representation. A set of five basic assumptions is introduced to describe some ideal knowledge representation formalisms for multiagent uncertain reasoning. These assumptions are shown to give rise to a particular knowledge representation formalism termed multiply sectioned Bayesian networks (MSBNs).

This book investigates opportunities for building intelligent decision support systems offered by multiagent, distributed probabilistic reasoning. Probabilistic reasoning with graphical models, known as Bayesian networks or belief networks, has become an active field of research and practice in artificial intelligence, operations research, and statistics in the last two decades. Inspired by the success of Bayesian networks and other graphical dependence models under the centralized and single-agent paradigm, this book extends them to representation formalisms under the distributed and multiagent paradigm. The major technical challenges to such an endeavor are identified and the results from a decade's research are presented. The framework developed allows distributed representation of uncertain knowledge on a large and complex environment embedded in multiple cooperative agents and effective, exact, and distributed probabilistic inference.

Under the single-agent paradigm, many exact or approximate methods have been proposed for probabilistic reasoning using graphical models. Not all of them admit effective extension into the multiagent paradigm. Concise message passing in a compiled, treelike graphical structure has emerged from a decade's research as one class of methods that extends well into the multiagent paradigm. How to structure multiple agents' diverse knowledge on a complex environment as a set of coherent probabilistic graphical models, how to compile these models into graphical structures that support concise message passing, and how to perform concise message passing to accomplish tasks in model verification, model compilation, and distributed inference are the foci of the book. The advantages of concise message passing over alternative methods are also analyzed.

To act in a complex problem domain, a decision maker needs to know the current state of the domain in order to choose the most appropriate action. In a domain about which the decision maker has only uncertain knowledge and partial observations, it is often impossible to estimate the state of the domain with certainty. We introduce Bayesian networks as a concise graphical representation of a decision maker's probabilistic knowledge of an uncertain domain. We raise the issue of how to use such knowledge to estimate the current state of the domain effectively. To accomplish this task, the idea of message passing in graphical models is illustrated with several alternative methods. Subsequent chapters will present representational and computational techniques to address the limitation of these methods.

The basics of Bayesian probability theory are reviewed in Section 2.2. This is followed in Section 2.3 by a demonstration of the intractability of traditional belief updating using joint probability distributions. The necessary background in graph theory is then provided in Section 2.4. Section 2.5 introduces Bayesian networks as a concise graphical model for probabilistic knowledge. In Section 2.6, the fundamental idea of local computation and message passing in modern probabilistic inference using graphical models is illustrated using so-called λ – π message passing in tree-structured models. The limitation of λ – π message passing is discussed followed by the presentation of an alternative exact inference method, loop cutset conditioning, in Section 2.7 and an alternative approximate inference method, forward stochastic sampling, in Section 2.8.

In Chapters 6 through 9, we studied in detail why a set of agents over a large and complex domain should be organized into an MSBN and how. We studied how they can perform probabilistic reasoning exactly, effectively, and distributively. In this chapter, we discuss other important issues that have not yet been addressed but will merit research effort in the near future.

Multiagent Reasoning in Dynamic Domains

Practical problem domains can be static or dynamic. In a static domain, each domain variable takes a value from its space and will not change its value with time. Hence, at what instant in time an agent observes the variable makes no difference. On the other hand, in a dynamic domain, a variable may take different values from its space at different times. The temperature of a house changes after heating is turned on. The pressure of a sealed boiler at a chemical plant increases after the liquid inside boils. A patient suffers from a disease and recovers after the proper treatment. A device in a piece of equipment behaves normally until it wears out. Dynamic domains are more general, and a static domain can be viewed as a snapshot of a dynamic domain at a particular instant in time or within a time period in which the changes of variable values are ignorable.

A Bayesian network can be used to model static and dynamic domains.