Multiagent Dynamic Reasoning About Belief and Trust Stanislav Ustymenko

Florida State University Libraries

Electronic Theses, Treatises and Dissertations The Graduate School

2008 Multiagent Dynamic Reasoning About Belief and Trust Stanislav Ustymenko

Follow this and additional works at the FSU Digital Library. For more information, please contact [email protected] FLORIDA STATE UNIVERSITY

COLLEGE OF ARTS AND SCIENCES

MULTIAGENT DYNAMIC REASONING ABOUT BELIEF AND TRUST

STANISLAV USTYMENKO

A Dissertation submitted to the Department of Computer Science in partial fulﬁllment of the requirements for the degree of Doctor of Philosophy

Degree Awarded: Spring Semester, 2008 The members of the Committee approve the Dissertation of Stanislav Ustymenko defended on March 26, 2008.

Daniel G. Schwartz Professor Directing Dissertation

Jon Bertot Outside Committee Member

Lois Hawkes Committee Member

Theodore P. Baker Committee Member

Gregory Riccardi Committee Member

The Oﬃce of Graduate Studies has veriﬁed and approved the above named committee members.

ii ACKNOWLEDGEMENTS

I would ﬁrst like to acknowledge my gratitude to my committee members. I also thank my lovely wife, Lyudmyla, for her love, patience and support.

iii TABLE OF CONTENTS

List of Tables ...... vi

List of Figures ...... vii

Abstract ...... viii

1. INTRODUCTION ...... 1 1.1 Problems and Motivation ...... 3 1.2 Approach ...... 5 1.3 Dissertation Overview ...... 7

2. MULTIAGENT ARCHITECTURE ...... 8 2.1 System Overview ...... 8 2.2 Taxonomic Knowledge ...... 11 2.3 Multiagent Environment ...... 13 2.4 Web of Trust ...... 14 2.5 Belief Revision ...... 16 2.6 Information System ...... 20

3. RELATED WORK ...... 22 3.1 Ontologies ...... 22 3.2 Truth Maintenance and Belief Revision ...... 28 3.3 Communities of Practice ...... 29 3.4 Software Agents and Multiagent Systems ...... 31

4. A LOGIC FOR BELIEF AND TRUST ...... 33 4.1 Introduction ...... 33 4.2 Operational Context ...... 34 4.3 Formal Language ...... 35 4.4 Dynamic Reasoning and Belief Revision ...... 37 4.5 Semantics ...... 40 4.6 Reasoning ...... 44 4.7 Controlling Trust Inferences ...... 48 4.8 Illustration ...... 51

5. TASK-ORIENTED REASONING ...... 53

iv 5.1 Agent’s Knowledge Base ...... 53 5.2 Conceptual Structures and Notations ...... 56 5.3 Reasoning Processes ...... 57

6. IMPLEMENTATION CONSIDERATIONS ...... 70 6.1 Domain Model ...... 70 6.2 Object-Oriented Decomposition ...... 72 6.3 Data Model ...... 76 6.4 Metadata design patterns ...... 78 6.5 External Representation ...... 85

7. CONCLUSION ...... 93

APPENDIX: Publications ...... 95

A. Publications ...... 95

REFERENCES ...... 97

BIOGRAPHICAL SKETCH ...... 105

v LIST OF TABLES

4.1 Scheme for combining belief and trust...... 46

4.2 Scheme for belief revision...... 47

5.1 Inferring new document classiﬁcations...... 56

6.1 Assigning responsibility to classes...... 76

6.2 Additional data elements...... 91

vi LIST OF FIGURES

2.1 Main actors in the multiagent system ...... 9

2.2 Decision making architecture ...... 12

2.3 Example knowledge base ...... 19

3.1 Example of an ontology ...... 23

3.2 Ontology Spectrum ...... 25

3.3 Agent interacting with its environment (from [RN05]) ...... 30

4.1 Agent conﬁguration demonstrating trust convergence ...... 48

6.1 Top-level domain objects ...... 71

6.2 Classes representing elements of KB ...... 72

6.3 First iteration database model ...... 77

6.4 GoF Composite pattern (from [G95])) ...... 81

6.5 Applying the Composite pattern ...... 82

6.6 History pattern ...... 83

6.7 Combining patterns ...... 85

6.8 Partial model of SKOS vocabulary ...... 90

vii ABSTRACT

In this dissertation we design a system that allows Semantic Web agents to reason within what has come to be known as the Web of Trust. We integrated reasoning about belief and trust, so agents can reason about information from diﬀerent sources and deal with contradictions. Software agents interact to support users who publish, share and search for documents in a distributed repository. Each agent maintains an individualized topic taxonomy for the user it represents, updating it with information obtained from other agents. Additionally, an agent maintains and updates trust relationships with other agents. When new information leads to a contradiction, the agent performs a belief revision process informed by a degree of belief in a statement and a degree of trust an agent has for the information source.

The system described has several key characteristics. First, we define a formal language with well-defined semantics within which an agent can express the relevant conditions of belief and trust, and a set of inference rules. The language uses symbolic labels for belief and trust intervals to facilitate expressing inexact statements about subjective epistemic states. Second, an agent’s belief set at a given point in time is modeled using a Dynamic Reasoning System (DRS). This allows the agent’s knowledge acquisition and belief revision processes to be expressed as activities that take place in time. Third, we explicitly describe reasoning processes, creating algorithms for acquiring new information and for belief revision. Fourth, we design a general architecture for system implementation. An object-oriented model presents classes and methods implementing the formal model. The database model is flexible and allows for future extensions. Finally, an external representation for system data is presented based on open Semantic Web standards.

viii CHAPTER 1

INTRODUCTION

This dissertation provides a detailed design for a multiagent system that reasons with explicit notions of belief and trust. The dissertation shows that contradictory information can be practically and meaningfully combined to help users search large repositories. This provides a valuable step towards implementing the Web of Trust on the Semantic Web. My motivation stems from the need to improve knowledge collaboration by introducing better search and browsing tools for public repositories on the Semantic Web. The resulting system is a distributed online repository of digital documents. Users deﬁne hierarchical taxonomies of topics to index and search for documents in a global repository, as well as describe the documents the user makes known or available to others. A software agent that represents a particular user maintains those taxonomies in its belief set. The agent can receive statements from other agents and incorporate them into their belief sets. To resolve any resulting contradictions, the agent relies on explicitly stated trust relationships that together form a social network, the Web of Trust. This research involved the following activities:

• Deﬁne the problem of community-based taxonomy maintenance in precise terms, making the solution tractable.

• Develop a logic-based system that allows for expressing subjective conditions of belief and trust. By assigning labels to belief and trust intervals, this system allows for eﬃcient calculation and is suitable for expressing imprecise epistemic conditions.

• Develop computational procedures for adding new statements to the belief set. Proce- dures for performing belief revision were also developed.

1 • Design an object-oriented model for the system. The functionality in computational procedures I developed has been assigned to methods in a class hierarchy, relying on inheritance and polymorphism to improve simplicity and extensibility.

• Define a flexible database schema to accommodate the belief set. We show how design patterns can be used to refactor a database model in an effort to implement nonfunctional requirements.

• Research existing ontologies and use them to create an external representation for the data in the system. Knowledge published using well-known public vocabularies can be used by other agents on the Semantic Web.

The following are the main contributions of this work:

• A formal logic for the Web of Trust is developed. To this end, we create a formal language with well-deﬁned semantics within which such a participant (or agent) can express the relevant conditions of belief and trust, and outline some key techniques for reasoning with these expressions. The aim in this is to make the language and reasoning system more intuitive for the human user. An explicit delineation of the context within which the language and reasoning techniques are to be applied provides is provided.

• The concept of a Dynamic Reasoning System [S97] is used to explicitly address reasoning as an activity which is taking place in time. We introduce the formal notion of a belief set as a partial model for a mental state of an agent. A belief set contains a set of axioms and propositions received by the agent from the environment. The agent uses inference rules to add new propositions to the set. The belief set contains, and the agent is consciously aware of, only those propositions received from the environment or inferred as of a particular discrete point in time. Thus, an agent does not have the property of logical omniscience and can, for example, harbor inconsistent beliefs until an inconsistency is discovered through inference. This allows, and requires, one to deﬁne rules for belief revision. Such rules are triggered when a contradictory proposition is entered into the belief set.

2 • Rules for belief combination within the framework of a Dynamic Reasoning System are defined. These rules are patterned after the likelihood combination rules defined in [S97]. Belief combination rules are applied when, based on different sets of evidence, the same proposition is assigned different degrees of belief. The rules allow the agent to combine the various belief degrees into a single degree of belief for that proposition. Belief revision also is invoked in response to a contradiction (when normal reasoning derives falsity). In this case a belief revision procedure is employed to rationally modify the belief set, removing falsity and preventing its reintroduction during future reasoning steps.

• Procedures are deﬁned to give an agent means to act towards a particular goal, i.e. a way to plan its reasoning task to serve a useful purpose. Here, we use the bibliographic taxonomy merging activity as an example.

• Design speciﬁcations are deﬁned for a proof-of-concept collaborative document repository management system. The design includes data structures, algorithms, classes and agents and is aimed at demonstrating practicality of the ideas proposed. It will also serve as an example of using established software and data engineering methodologies for knowledge-based systems development.

This work presents a novel combination of approaches. First, an agent’s behavior is justiﬁed by relying on philosophically plausible rationality postulates. Second, it employs a Web of Trust infrastructure to assess the reliability of data and reject less supported knowledge to maintain consistency. Finally, an agent uses only linguistic labels to represent intervals of degrees of belief of trust, making the system more transparent for human users.

1.1 Problems and Motivation

The Semantic Web [BL98] is a vision of a new generation of the World Wide Web that will enable computational agents to process data that have well-defined formal semantics. Agents can use reasoning to infer new information from statements located on different Web sites. Just like the current Web, the Semantic Web makes no attempt to centralize publishing, effectively allowing anyone to publish any statement. Thus judging reliability of information becomes a practical requirement.

3 One of the basic techniques that underlie the Semantic Web is the use of ontologies, machine-understandable formal conceptualizations of a certain domain. Ontologies promise to help users navigate the vast amounts of information that digital collections provide. They provide semantics for metadata associated with digital documents or services, allowing intelligent data retrieval and combination. Ontology-based systems are developed utilizing research in databases, Web information systems, and knowledge representation. As an example, consider an archive of publicly available resources updated by a community of knowledge workers (e.g., a preprint archive of scientific papers). Indexing information in a digital archive requires extensive metadata schemas, enabling accurate categorization for navigation and search. Such a metadata system would include concepts organized in a taxonomic hierarchy, thesaurus, or more complex knowledge structure utilizing ontology semantics. One obstacle for utilizing ontology-bases techniques for large and/or evolving archives, such as digital repositories of research papers, is defining such an taxonomy of concepts so as to satisfy the needs of the majority of users, who might have conflicting perspectives on overlapping areas of inquiry. Ideally, metadata created should reflect perspectives of different groups while spanning all the content and recognizing links between alternative conceptualizations. At the same time the system should maximize the quality of the taxonomy. Our position is that the task of constructing a comprehensive taxonomy is best left to the evolving community of users to carry out. We describe a Web-based system which allows users, individually and through collaboration, to define taxonomies to classify documents in a collection. Users will form online communities around domains of interest, contributing to taxonomy engineering through discussions and collaborative editing. The resulting taxonomies then can be combined on overlapping concepts and used to improve search in the repository. A user’s association with taxonomies will provide the context necessary for personalizing his or her search and browsing experience identifying items of the user’s particular interest. The collaborative environment can also be used to create communities of practice supporting informal knowledge exchange. A sufficiently expressive concept taxonomy embodies a knowledge structure that reflects the real world. We treat the taxonomy as a knowledge base expressed in a formal language that allows inference and can be used by computational agents that act on behalf of a user to

4 assist in browsing, query, and search. We require the agent’s knowledge base to be consistent. We also require that the agent use as much information as possible, meaning that he must merge knowledge bases provided by diﬀerent users. If the merging is to be performed non- critically, the consistency requirement can be violated due to the unrestricted distributed nature of the Semantic Web. The Semantic Web vision contains a component called the Web of Trust [RAD03] (not related to the similar term in cryptology), consisting of the trust relationships held between its participants. In terms of this, the degree to which participant A believes what is believed by participant B depends on the degree to which A trusts B. In the present research, we propose a formal language with well-deﬁned semantics within which such a participant (or agent) can express the relevant conditions of belief and trust, and outline some key techniques for reasoning with these expressions. 1.2 Approach

Alchurron, Gärdenfors and Makinson proposed a formal model of epistemic dynamics (for an overview, see [G88]). Now known as the AGM model, this defines a formal concept of belief set. Briefly, a belief set is a set of propositions that is closed with respect to some rules of inference, and as such is essentially equivalent to a formal logical theory. The model defines three kinds of formal operations on belief sets, namely, contraction, expansion and revision. The set of all possible operations is then constrained by defining rationality postulates. Thus, AGM formulates a sensible set of criteria that an intelligent belief revision process must satisfy. Among chief contributions of AGM paradigm is the understanding that an agent needs extralogical criteria in order to perform rational belief revision. To be applicable to the problem at hand, the AGM framework [G88, G92b] needs modifications. First, AGM contains a so-called success postulate, which asserts that the result of belief revision always contains the new statement. This completely ignores the necessity of dealing with unreliable information. Boutilier, Friedman and Halpern [BFH96] propose semantics for studying a wider class of revision functions not necessarily employing the success postulate. AGM belief revision then becomes a special case of their model. This model has the potential to provide a theoretical background suitable for our goals. Clearly, when trust information is available, it must influence the agent’s willingness to give up beliefs. Galliers [G92a] proposes a model for autonomous belief revision that takes

5 into account the reliability of the source of information. However, Galliers’ formalism does not account for the social network structure of the Web of Trust and requires preset explicit reliability labels. In [S97], Schwartz presents the notion of a dynamic reasoning system. In this formalism, reasoning is portrayed explicitly as a process that takes place in time. The objective is to provide a framework for modeling an agent’s reasoning processes. In this framework, each application of a logical inference rule is assumed to occur in one discrete time step, and the contents of a derivation path at each time step are propositions representing the agent’s knowledge base (or belief set) as of that time. The derivation path additionally stores information regarding the source or justification for each proposition in the derivation path. We use the DRS to define a discrete belief revision process. Abstract AGM belief operators are replaced with computational procedures whose design is informed by similar rationality considerations. In [US06], we propose a formal logic with well-defined semantics for reasoning about the conditions of belief and trust in a Web of Trust environment. It uses linguistic, rather than numeric, measures of belief (in the spirit of Zadeh’s linguistic variables [Z75]), allowing for more intuitive user interactions. When used in an appropriate operational context, the system allows deducing and revising trust statements about other agents and using those to reason about the reliability of statements, both communicated and inferred. Thus the formalism presented there might be useful in constructing belief revision models in the AGM tradition. We propose utilizing the linguistic degrees of trust and belief for constructing plausibility ranking for beliefs in the agents’ knowledge bases. Following Galliers [G92a], we reject a success postulate and allow an agent the option to accept or not to accept the new information. Discarded information is retained in the agent’s memory and identified as a proposition that is not believed. Agents are flexible with regard to the degree with which they choose to follow a perceived public opinion of their trusted peers or to protect their own core set of beliefs. The agent’s goals (in the present context, user’s search goals and browsing behavior in the repository) also might influence the belief revision strategy chosen.

6 1.3 Dissertation Overview

Chapter 2 presents the overall model for the system. This identifies knowledge elements the system manipulates. It addresses representing taxonomies using first-order logic, gives an overview of an agent’s functionality and the associated multiagent community, and introduces the belief revision concepts. In closing, the chapter briefly discusses requirements for the information system implementation. Chapter 3 surveys previous work that serves as a basis and context for this dissertation. It discusses ontology-based technologies and applications, work in the area of belief revision and nonmonotonic reasoning, research into communities of practice and their influence on knowledge management and the Web and, finally, software agents and multiagent systems. Chapter 4 develops a logic for reasoning with belief and trust. It describes the operational context for the logical system and introduce the syntax, semantics, axioms and inference rules. It also shows why some external heuristics that prescribe the order of inference are crucial for reasoning in the web of trust. Chapter 5 is devoted to detailing the computational procedures for reasoning in the multiagent environment presented in Chapter 3, using the ideas developed in Chapter 4. It specifies the content of the belief set of an agent storing taxonomic data and trust information. Restricting the form of statements that comprise the belief set is instrumental in defining simple reasoning procedures aimed at achieving the system’s goals. Chapter 6 of this work is dedicated to implementation considerations. Section 6.1 presents the domain model for the system, expressing the foregoing abstract models in object- oriented terms. Section 6.2 goes into the detailed object-oriented decomposition of processes developed in Chapter 5. Section 6.3 presents a flexible logical data model for the system, using object-oriented design patterns. Finally, Section 6.4 reviews existing metadata schemes and shows how they can be used to facilitate interoperability.

7 CHAPTER 2

MULTIAGENT ARCHITECTURE

2.1 System Overview

This Chapter gives a broad overview of a proposed system. The overall system comprises automated agents that act on behalf of the human users. Software agents are broadly defined as software entities capable of getting information from their environment, reacting to it, communicating with other agents, and achieving a goal of performing some complex task on behalf of their users. To perform this task, agents must acquire an understanding of their environment, and, to effectively communicate, they must subscribe to a common language with agreed upon semantics. The main actors in the system are human users and computational (software) agents. Each agent represents one user, and each user has one and only one agent (unless a user has a reason to have two or more agents with inconsistent beliefs). As we will see, software agents interact within an artificial network of trust relations (the web of trust) that approximate attitudes each user have towards other users. Similarly, we introduce information artifacts agents manipulate, namely documents, topic categories and relations between them. A belief set of an agent aims to approximate user’s epistemic attitudes (knowledge and belief) towards these artifacts. (see Figure 2.1) . In our model, one agent represent one user of the system. Agents act as both information suppliers and consumers. As a consumer, an agent’s goal is to find documents relevant to a user’s interests. As an information supplier, agents make their own documents available for other agents. We assume that it is in the best interests of the human users to make their documents easily searchable, and that they will provide rich metadata to make it so. The users of our system are knowledge workers. They engage in consuming, producing and disseminating knowledge. Tangible unit of knowledge is called a document. There is no

8 Figure 2.1: Main actors in the multiagent system

requirement that the document is in fact a text-based ﬁle available electronically. A paper, a book, a movie, painting or sculpture can be considered document. As far as information system is concerned, a document is anything that can be uniquely identiﬁed and referenced and is treated as an atomic informational entity. For the remainder of this work, we will also use the term ”document” for document records and also for document constants that represent documents in our formal system (see Section 5.1). The user has mental attitudes towards documents and other users. We refer to these attitudes as knowledge, belief and trust. Mental attitudes change over time. We refer to the set of such attitudes at a given time as user’s mental state. References to documents a user

9 is aware of, as well as a topic taxonomy that reflects user’s beliefs, are included in his/hers mental state. Users move from one mental state to another by performing cognitive actions: they can either acquire a new belief from another trusted individual or derive it through some inference step. We can think of these actions as occurring sequentially. Agent’s inference activity can be represented as a finite set of discrete time steps, each associated with some cognitive action. To facilitate search and browsing, a user associate documents with categories or topics: sets of documents that share some common theme. He creates a taxonomy by defining relations between topics. The most common type of relation is a subtype-supertype relation. A software agent models mental state through its belief set. A belief set is a set of statements in some formal language, designed to express mental attitudes towards facts. A logic satisfying this requirement is developed in Chapter 4. We can identify three kinds of beliefs that need to be represented in a belief set:

• Topic taxonomy, expressed as a set of logic-based statements with associated belief attitudes. Examples of the types of statements suﬃcient for expressing taxonomy beliefs are listed in the next section.

• Set of document references, together with statements linking documents and topics.

• Set of statements reﬂecting agent‘s trust relationships with other agents.

At any given time, a human mind can harbor inconsistent beliefs. Inconsistency might not be apparent until, through cognitive actions, a person arrives at an absurd conclusion. When this occurs, rational thinker re-examines his beliefs, rejecting those that are less supported or otherwise less entrenched. Artiﬁcial mind and belief set of an agent should be able to support such behavior. The Dynamic Reasoning System [S97] provides suitable abstraction for enabling dynamic evolution of a belief set (see Section 4.6). On each time step, an agent is free to choose a cognitive action among legal inference rules and other agents’ beliefs to acquire. In eﬀect, an agent chooses his new belief set. This choice is guided by considerations not completely determined by rules of logical inference: agent‘s goals and desires. Gardenfors [G88], describing a dynamic theory of agents‘ beliefs (known as AGM framework of belief revision) shows that, even in his abstract model of belief sets closed under inference, belief revision requires adopting extralogical principles, which he calls

10 rationality postulates (discussed further in Section 2.4). Doyle’s classic Truth Maintenance System [D79], providing mechanisms for knowledge representation and supporting logical consistency, relies on external reasoning mechanism to guide agent’s problem solving process. In our agent system, logical inference is supported using Dynamic Reasoning System. Figure 2.2 shows the general structure of agent’s reasoning process. A Dynamic Reasoning System contains agent’s belief set, which contains axioms of a formal system adopted. Inference rules give tools for belief set evolution. Logical statements are decorated with additional information that help represent belief evolution as a dynamic, time-dependent process. A subsystem that controls agent’s behavior manipulates the DRS to achieve agent’s goals. Here, we ﬁnd procedures that agent uses to choose the direction of his belief set evolution. Agent’s activities governed by this subsystem are as follows:

• Task-oriented reasoning - agent’s actions aimed at fulﬁlling its purpose and bringing direct beneﬁt to the user.

• Belief revision - agent’s actions designed to maintaining and restoring belief set’s consistency.

• Trust maintenance - agent’s actions aimed at discovering new agents as sources of potential new knowledge.

In a restricted domain, meaningful task-oriented behavior can be described by creating procedures to handle new information coming from outside. In chapter 5, we provide a detailed description of such algorithms. 2.2 Taxonomic Knowledge

We use first-order logic as a basis for our bibliographic metadata scheme. Documents will be represented as individual constants (names) denoted by alphanumeric identifiers starting with a lowercase letter. For the purposes of this treatment we call them simply docu- ment1, document2, etc. Document categories, or topics, are denoted by unary predicates, e.g., Logic(x), Philosophy(x), Mathematics(x), ArtificialIntelligence(x). Thus, the formula ArtificialIntelligence(document1) postulates that document1 belongs to the topic Artificial Intelligence.

11 Figure 2.2: Decision making architecture

12 Users will deﬁne taxonomic relationships using ﬁrst-order logic. The four allowable types of relationships are illustrated by the following examples:

• Subtypes: ∀x(Logic(x) → Math(x))

• Disjointness: ∀x(Math(x) →¬P hilosophy(x))

• Or-Deﬁnition: ∀x(T opic(x) → Arts(x) ∨ Sciences(x))

• And-Deﬁnition: ∀x(Biochemistry(x) ↔ Biology(x) ∧ Chemistry(x))

A full description of a document provided by a user, thus, includes all formulas where said document is present as a named individual. Additionally, it includes all beliefs of a publishing user that describe any topics the document belongs to. Ultimately, formulas related to a particular document might include a signiﬁcant portion of an agent’s published taxonomy. In the real world, the document’s metadata would also include non-taxonomic information, e.g. author information, funding sources, institutional aﬃliation etc. However, for the purpose of this exposition, we ignore such information. 2.3 Multiagent Environment

Each agent in our world maintains two data structures: its belief set, used for requesting documents, and public metadata of documents exposed by the user it represents. We assume that our agents are sincere and open: they share all their beliefs concerning topic taxonomy with the entire agent community. This helps other agents to classify documents the agent publishes. Thus, all published document descriptions are available from their owners and are globally public. We can represent this as either the existence of a global knowledge repository or the ability of agents to provide knowledge upon query. We can assume, without loss of expressivity, that individual and predicate names are globally unique. Agents’ belief sets represent individual mental attitudes of corresponding agents (see above Section 2.1). To support diverse perspectives, we impose no requirements concerning global consistency - we expect that formulas that are attributed to diﬀerent agents can and will contain contradictions. Moreover, we do not require that, at any given time, an agent’s view of a taxonomy be consistent, although this can be seen as a goal of each agent’s belief revision process. An agent’s actions include the following:

13 • Responding to queries for documents

• Exposing a new document created or discovered by the user. This includes classifying the document into one or more of the taxonomic categories. This action introduces a new named individual into the domain description, eﬀectively expanding the language.

• Getting a previously unknown document into the agent’s belief set. The new document is among documents exposed by some other agent.

• Discovering facts about taxonomic classiﬁcation of a particular document. An agent requests taxonomic facts from other agents, with the goal to create a complete description of the document. In this process, the agent modiﬁes its taxonomic beliefs.

• Inferring new beliefs from previously acquired beliefs. This action may be triggered by any of the previous actions.

• Modifying currently held beliefs to remove a contradiction. This action is triggered when a reasoning step results in deriving falsity. In that event, a belief revision process is initiated, removing beliefs that lead to the contradiction.

2.4 Web of Trust

Along with beliefs regarding the bibliographic domain, agents maintain beliefs regarding other agents. We assume that a human user provides an agent with an initial list of known agents for an agent to communicate with, along with a level of trust bestowed on statements those agents make. These statements form an oriented weighted graph of familiarity relationships between agents, or a social network. In a context of the Semantic Web, such a network, is often referred to as a part of the Web of Trust [BHL01]. More generally, the Web of Trust is set of data and techniques on the Web that allows users deduce the trustworthiness of the previously unknown information source. A component of this is an older notion of cryptographic infrastructure (also called the Web of Trust) that ensures the authenticity of the message, using asymmetric encryption. After the source of the information was established, an agent assesses its reliability. The level of belief in an acquired statement depends on the degree of belief of the statement in an initial agent’s belief set and on a level of trust between two agents, using a rule for

14 combining belief and trust. To expand their list of familiar agents, agents are allowed to discover new agents from the neighbor’s knowledge base. For this action, an agent utilizes a separate rule for trust combination. Finally, an agent might acquire differing degrees of belief in a statement or trust in an agent. In such a case, a form of belief revision is employed to choose the agent’s attitude forward a statement or an agent. Another form of belief revision is employed when an agent derives a contradiction. Proposing useful procedures for all cases mentioned is among the goals of this research (Chapters 4 and 5). The term ”trust” can be understood differently. In general, trust is a judgment by an agent of quality of the information that come from another agent. We adopt the behavioral understanding of trust: the level of trust corresponds to the degree to which an agent is willing to act upon an information from another agent. In case of agents’ views on bibliographic taxonomies, willingness of agent a to adjust its belief in accordance with agent b’s opinion can reflect both a’s assertion of b’s sincerity and competence (genuine trust) and the perceived degree of similarity between a’s and b’s points of view. We don’t attempt to separate these two components, thus in this specific case, ”trust” may mean ”agreeability”. Our use of the term ”trust” is consistent with the work by Golbeck and Hendler [GH04], [G05], [KG06], [G07]. In developing their notions of reputation and trust, they apply it to collaborative e-mail filtering, movie and music recommender systems and other social network applications. There are several approaches to trust assessment. Zhang, Yu ant Irwin [ZYI05] present a classification scheme for trust functions, according to four dimensions:

• Subjective vs. Objective. Objective trust arises when quality of agent’s information can be related to the reality or truth that is independent on agents’ opinions. And thus, with an objective function, agent a’s trust in agent b and agent c’s trust in b should be equal. Our work focus on individual beliefs, and thus we adopt subjective scheme.

• Transaction-Based vs. Opinion-Based. In transaction-based systems, agents infer trust based on the observable behavior of other agents, while opinion-based systems only rely on opinions. In this work, an opinion-based system is considered. Transaction-based component may be added in future. For example, agent a may keep track of how often information from agent b is conﬁrmed by a’s own beliefs and those of a’s trusted peers,

15 how often b changes its beliefs, causing a to go through the belief revision process, etc. This information may then be used to adjust the level of trust in b.

• Complete Information vs. Localized Information. A global trust function uses the complete trust graph to compute trust values for all agents. Localized trust function relies on the information from agent’s ”neighbors”. Our approach aims at deﬁning a localized search process.

• Rank-Based vs. Threshold-Based. Threshold-based functions arrive at a single (numeric) value as a characteristic of trust, while rank-based ones return value that is only meaningful in comparison with those of the other agents. The latter is useful when users are interested in relative trusts in two or more agents, i. e. when an agents needs to choose among opinions of others. Our system is closer to what [ZYI05] characterize as threshold-based. 2.5 Belief Revision

Agents use their belief sets to satisfy user requests for documents. Regardless of the specific query mechanism (information retrieval or taxonomy browsing),the agent relies on the quality of the taxonomy and the completeness of document information in its belief set. To be able to use information provided by other users and agents, an agent must continuously acquire document descriptions from other agents. Such acquisition can introduce contradictions into belief set. When dealing with contradictions, an agent will have to abandon some beliefs. The AGM framework [G88] defines rationality criteria or ”integrity constraints” for abandoning beliefs that can be deemed justified. In informal terms, those constraints include:

• Belief change should keep the epistemic state (belief set) consistent.

• Any statement logically entailed by statements in the belief set should be included in the belief set.

• Loss of information should be kept to a minimum. This principle is referred to as a principle of informational economy or, more narrowly, principle of conservation.

16 • Beliefs that are in some sense “more important” should be retained in favor of those “less important.”

AGM then deﬁnes, for an epistemic state K and epistemic input α, belief change operators + transitioning one epistemic state into another, namely Belief Expansion (K → Kα ), Belief − ∗ Contraction K → Kα and Belief Revision K → Kα. Then, from the rationality criteria described above, formal rationality postulates are derived, constraining the classes of possible change operators. For example, eight AGM postulates for revision are as follows (where K⊥ refers to an absurd belief set that contains all possible formulas): K∗1 For any input α and any belief set (closure) ∗ K, Kα is a belief set ∗ ∗ K 2 α ∈ Kα (success) ∗ ∗ + K 3 Kα ⊆ Kα (inclusion) ∗ + ∗ K 4 If ¬α 6∈ K, then Kα ⊆ Kα (preservation) ∗ ∗ K 5 K α = K⊥ iﬀ ⊢¬α (vacuity) ∗ ∗ ∗ K 6 If α ↔ β, then Kα = Kβ (extensionality) ∗ ∗ ∗ + K 7 Kα∨β ⊆ (Kα)β (superexpansion) ∗ ∗ ∗ + ∗ K 8 If ¬β 6∈ Kα, then (Kα)β ⊆ Kα∧β (subexpansion) Similar postulates are formulated for Belief Expansion and Belief Contraction. As it turns out, the expansion operator is uniquely determined by the rationality postulate: namely, the expanded set is a closure of the union of an initial set and a new formula, K+α = Cn(K ∪ {α}), where Cn stands for closure in respect to inference. Revision and contraction, in turn, are connected using Levi’s identity (see [G88]):

∗ − + Kα =(Kα )α or, alternatively, Harper’s identity:

− ∗ Kα = K ∩ Kα Therefore, only one of the contraction or revision operators need be deﬁned. Abstract ways to construct such operators are proposed, with representation theorems proving that classes of operators so constructed are equivalent to the class of operators that conform to the postulates. One of the constructions introduces the notion of epistemic entrenchment, an ordering over the set of all formulas (or, equivalently, over the set of possible worlds). Intuitively, this ordering represents a preference ordering over formulas in the belief set. Integrity constraints thus proposed require a belief set to be closed under implication, containing all logical consequences of the agents’ beliefs. While theoretically appealing, this

17 requirement does not lend itself to efficient computational implementation. We replace this potentially infinite knowledge structure with a derivation path, a finite sequence of statements that an agent is aware of at a given moment in time. Instead of belief change operators, we concentrate on describing the process of belief evolution in a multiagent environment. Thus, we replace second criterion with the requirement that this process be logically sound. We do not require completeness, although it would be a desirable property. Instead, we intend to show only that the process we describe allows agents to achieve their practical goals. Similarly, consistency requirements are replaced with a desire for the process to, eventually, reach consistency. Thus, at any given time and assuming absence of further inputs, an agent should reach a consistent state in a finite number of steps. The success postulate K∗2 assumes reliable sources of epistemic inputs. In our open environment, reliability is not guaranteed; in fact, judging the trustworthiness of sources and individual sentences is one of the goals of this research. Therefore, we must define our own notion of success, the one that does not give undue preference to new information. We understand preservation in the sense that the process of acquiring new information should not diminish the quality of the agents’ belief sets. Let’s consider an example. Assume that two agents have beliefs partially presented in Figure 2.3. Using first-order logic, beliefs of the agents are:

Agent 1 Agent 2 ∀xRoot(x) ∀xRoot(x) ∀x(Science(x) → Root(x)) ∀x(Science(x) → Root(x)) ∀x(Mathematics(x) → Science(x)) ∀x(Humanities(x) → Root(x)) ∀x(CS(x) → Science(x)) ∀x(Humanities(x) →¬Science(x)) ∀x(Logic(x) → Mathematics(x)) ∀x(P hilosophy(x) → Humanities(x)) ∀x(AI(x) → Logic(x)) ∀x(Logic(x) → P hilosophy(x)) ∀x(AI(x) → CS(x)) ∀x(AI(x) → Logic(x)) AI(document1) AI(document3) AI(document2)

Suppose that Agent 1 acquires the description of document3 from Agent 2. This description naturally contains all the taxonomic knowledge presented. The resulting knowledge base will lead to contradiction: document 3 belongs to both Science and Humanities, two categories that are declared disjoint. Thus, the agent must disbelieve at least one sentence in his knowledge base. The agent’s choice of the culprit formula might

18 Figure 2.3: Example knowledge base

include any of:

1. ∀xHumanities(x) →¬Science(x)

2. ∀xP hilosophy(x) → Humanities(x)

3. ∀xLogic(x) → P hilosophy(x)

4. ∀xAI(x) → Logic(x)

After carefully examining the results of such a revision, we see that, in each case, we lose potentially useful knowledge. To deﬁne rational criteria for such belief revision, we must adopt some form of a principle of informational economy - choosing beliefs that are the least valuable according to some reasonable criteria. Deﬁning such criteria and describing a corresponding belief revision mechanism are two of the goals of this research (see Chapter 5).

19 2.6 Information System

As a final product of this research, a model for the architecture of a software system supporting the collaborative digital library management has been created. The proposed architecture demonstrates the practical applicability of the concepts and techniques discussed. The system design was created using combination of agent-oriented and object-oriented approaches. The simplest system architecture for a collaborative document repository consists of: (i) a central database to store knowledge, (ii) business logic implementing multiagent system behavior, and (iii) a Web Service-based interface for an outside client to communicate with the system. Alternatively, one can design a distributed, peer-to-peer software system to implement the same conceptual model. A distributed architecture will additionally contain protocol specifications for information exchange. At the center of the software specification lies the data model for the application domain. Section 2.1 presents a conceptual vocabulary of taxonomic knowledge, represented using first-order logic. Our goal is to create a schema that supports this vocabulary, allows for a straightforward physical implementation using mature technology (e.g., relational database, XML storage, or ontology management system). From the previous discussion we can derive two major requirements for the model of the bibliographic domain:

• Personiﬁcation. Knowledge elements must be explicitly associated with agents. Our data model contains all the knowledge of the multiagent system, so that every agent has access to the knowledge of other agents. At the other hand, each individual knowledge base (or belief set) is clearly identiﬁed.

• Dynamics. The belief revision mechanisms mentioned above rely on explicit represen- tations of agent’s belief evolution in time.

Our domain model implements these requirements by explicitly representing users (agents) and by adding a timestamp to each taxonomy element. Thus, all historic data is always present in the system. All knowledge elements are identified both by the timestamp and the user. At any given time, different users might have different views to the same model. The view is affected by the user’s group membership and relationships between groups. This allows for great flexibility and is a great asset in a collaborative environment where global

20 consensus is unlikely or undesirable. (We assume this is true for the bibliographic system we describe). To function as a component of the wider Semantic Web infrastructure, the system should support well-defined metadata vocabularies for interoperability. To achieve this, the data must be exportable to de-facto standard RDF/S [MM04] and OWL [MH04] format. Web services are created to export taxonomy data using SKOS RDF schema [MB07]. Additional bibliographic data will conform to Dublin Core [ANSI06] vocabulary. Social network data is exposed as FOAF graphs [D04]. The internal pattern based metadata schema is sufficiently rich in semantics to yield useful mappings to the vocabularies mentioned, while providing adequate flexibility for supporting the information system’s object-oriented architecture and reasoning services. A complete mapping of the data model’s elements into the established dictionaries will be provided. Such services can facilitate incorporation of the information accumulated in the system into general-purpose Semantic Web search tools, e.g. Swoogle [S06]. Similarly, an extension to our system may facilitate opportunistic expansion of the system’s knowledge base using RDF crawling.

21 CHAPTER 3

RELATED WORK

3.1 Ontologies

3.1.1 Deﬁnition

An ontology can be defined as a formal, explicit conceptualization of a domain of discourse, defining concepts and relationships within the domain. Ontologies are at the core of an emerging Semantic Web [BL98] and are often described using Knowledge Representation techniques: frames, predicates, or description logics [B03]. The defining characteristic of an ontology language is the use of formal semantics that allow machine processing and inference of implicit assumptions. Two examples are OntoLingua [FHR96] and Web Ontology Language (OWL) [HPH03, MH04]. (It is said that OWL refers to the owl from “Winnie the Pooh”, who spelled his name ‘WOL’.) Concepts in an ontology form a class hierarchy. Subclasses inherit properties of su- perclasses. An ontology also defines relationships between concepts. Figure 3.1 depicts a sample fragment for a hypothetical ontology, which can be used for classifying the collection of documents related to military and civilian vehicles (from the Net-PI project, [D03a]). It can express, for example, that a Tank is a kind of Vehicle, that it has a part called a Gun, that as a Vehicle it can be driven by the Driver, who, in turn, is a kind of Person. It can also state different terms that relate to those concepts. This information could help a repository to deliver more accurate search results [MHN98]. A specific ontology is a model for a certain domain of discourse. It carries knowledge aimed at establishing a language to facilitate machine understanding of metadata.

22 Figure 3.1: Example of an ontology

3.1.2 Ontology applications

According to Uschold and Jasper [UJ99], applications for ontologies and related knowledge structures generally fall into the following categories:

• Neutral authoring - knowledge artifacts are created in one ﬁxed form or language and then translated on demand;

• Ontology as specification - create an ontology for a given domain and then use it for a specification for one or more software systems. Precisely defined, a rich ontology can greatly reduce ambiguity and enable interoperability between software systems and ease maintenance through better documentation;

• Common access to information - enable information access by multiple agents (software or people) by ensuring common understanding of terms and formats of values;

• Ontology-driven search - using ontology for searching an information repository, to improve quality of search results. Ontology can reduce ambiguity of search terms and increase relevance, thus enabling information sharing and reuse.

23 A much discussed application area for ontologies is software agents (see, e.g., [H01]). Ontologies can serve as the contractual agreement between agents acting as information providers and consumers, allowing reasonable autonomy and application independence without the inconvenience of having to coordinate ad-hoc operational semantics for isolated heterogeneous software components. Similar considerations apply to the popular technology of Web Services [DOS03]. Web Services are software components that can be dynamically used by other software (or other services). A syntactic basis for reuse is provided by the new XML-based Simple Object Access Protocol (SOAP). Services can describe their capability using WSDL (Web Service Description Language). It opens the theoretical possibility of automatic service composition on-demand, to answer a speciﬁc query. Ontologies, especially web-accessible, formal ontologies expressed in a standardized language, can help achieve this goal by giving services a shared semantics [D03].

3.1.3 Classiﬁcation of ontologies

Ontologies can range in expressivity and formality and are expressed in some specific ontology language. These languages are usually computer-processable but can vary in the amount and formality of semantics they are able to express. One classification of ontologies according to level of semantics is known as the “ontology spectrum” [DOS03]. Another classification dimension is according to formality of the constructs used. Gruber [G95] identifies formal, semiformal and informal ontologies. Formal ontologies are the most useful when machine inference is heavily used, but are tremendously hard to construct for real-world domains with thousands of objects and relations. Most automatic and semiautomatic methods yield informal or semi-formal ontologies. Ontology languages differ with respect to the underlying semantic model they support. While all languages support class hierarchy taxonomies and primitives for defining classes (types) and relationships (also sometimes called “properties” or “attributes”, depending on the representational metaphor used), other features vary. Informal languages (Taxonomies, Topic Maps, or UML, which is considered by some as an ontology language [U99]) adhere to weaker, human-oriented semantics, while formal languages borrow their underlying mechanics from the Knowledge Representation field.

24 Figure 3.2: Ontology Spectrum

3.1.4 Languages and semantics for ontologies

Early languages, such as CycL [L90], Conceptual Graphs [S84], and KIF [KIF], use predicate logics of varying representational power. SHOE, [H01] an HTML-based language implemented at the University of Maryland as a proof-of-concept Web ontology language, has its semantics expressed in Datalog, a decidable subset of ﬁrst-order predicate logic. Another major inﬂuence on ontology language evolution was the KR (Knowledge Rep- resentation) work on frame-based systems and semantic networks. Protege [N01], a popular open-source ontology modeling environment developed at the Knowledge Systems Lab of Stanford University, is based upon Semantic Networks, but additionally has reasoning plug- ins, both rule-based and logic-based. Ontolingua [FHR96] is a frame-based ontology system. Semantic networks use a graph-based data model and thus are intuitive for ontology purposes. Semantic Networks are a powerful paradigm, but in and of themselves they lack formal

25 semantics and therefore are open to inconsistent interpretation. There are several ways to prescribe formal semantics for them. One of the most popular approaches is a family of formal languages called description Logics (DL) [B03]. A DL language is a formal system with strictly deﬁned syntax. Syntactic categories of a typical DL are concepts and roles. Concepts and roles are combined into expressions by a small set of logical connectors to state facts about derivative concepts. Simple and combined concepts are then used to state facts about individuals. These languages are given an intuitive set-theoretic semantics. In a given interpretation, concept symbols are interpreted as sets of objects, i.e., subsets of the interpretation domain, and role symbols are interpreted as binary relations (sets of ordered pairs of objects) on the interpretation domain. Individual symbols, naturally, are interpreted as individual members of the interpretation domain. Thus when it is said that an individual is a member of a concept, this more exactly means that it is a member of the set that represents that concept. Description Logics underlie many implemented systems. CLASSIC [B89a] is a popular description logic system and language, developed at AT&T by Deborah McGuinness. A newer ontology language, DAML-O [DFH03] speciﬁes a description-logic-based semantics. The World Wide Web Consortium’s ontology language for the upcoming Semantic Web, OWL [HPH03, MH04] is based on work on DAML and has a description logic interpretation. This currently has the status of a W3C recommendation. It can be said that description- logic-based languages are the leading paradigm for ontology semantics.

3.1.5 Reasoning

Any knowledge representation systems’ power lays in the ability to deduce facts that are not explicitly stated. Thus, there is a need for reasoning services. Many reasoners designed for Description Logics can be used for ontologies. Examples are CLASSIC [B89a], FaCT [H98], and Racer [HM01]. Reasoning operations they usually provide:

• Subsumption - a concept A is said to subsume a concept B with respect to a given set of axioms if, for every interpretation of the axioms, B is a subset of A.

• Classiﬁcation - a subsumption hierarchy of all named concepts in the given ontology.

• Consistency check - a way to determine if a concept is consistent, meaning that it can contain individuals given the restrictions expressed in the ontology (i.e. a model for the

26 concept exists). This service can also be applied to individuals (i.e., determine whether an individual ﬁtting some description can exist) and to entire ontologies (whether the ontology as a whole has a model).

• Inclusion check - determine if an individual is a member of a concept in all models of the ontology.

Other reasoning services can also be useful for many applications. A least common subsumer (LCS) for two concepts is defined as a concept that is a super-class for both concepts in all interpretations and a subset for all other common super-classes. This notion can be defined for an arbitrary set of concepts. It can also be applied to individuals with respect to the concepts of which those individuals are members. Some reasoners (e.g., CLASSIC) provide computation of the least common subsumer. LCSs can be used to define a notion of similarity for concepts and individuals. Let a, b and c be ontological instances (individual members of some concepts). Then let B be the most specific concept that is common to both a and b (LCS for a and b), and let C be the most specific concept that is common for both a and c. Then, if C properly subsumes B, it could be said that a is more similar to b than it is to c. This corresponds to the intuitive set-theoretic idea of similarity and can be used as a benchmark for more efficient heuristic measures. This can be used to implement query by example, namely, retrieval of all objects similar to a user-supplied list of examples [MHN98]. CLASSIC (mentioned in the foregoing) is designed to be practical for real-world applications, with a high-level API written in C++ (this is a recent implementation called NeoClassic; the original CLASSIC was written in Lisp), and has a formal language with a description logics semantics. It implements subsumption and classification reasoning services, as well as an algorithm for the least common subsumer calculation. The DL language CLASSIC was made deliberately more restrictive to allow for polynomial-time inferences. FaCT (Fast Classification of Terminologies), developed at the University of Manchester, is the client-server DL-based reasoning software optimized for classification and satisfiability [H98]. It is written in Common Lisp and is available for free as source code and binaries. FaCT uses the SHIQ description logic, which is more expressive than CLASSIC. A Java- based CORBA interface makes it easy to use FaCT in applications.

27 3.2 Truth Maintenance and Belief Revision

The problem of knowledge base integration with conflicting data is essentially equivalent to belief revision. One of the most influential paradigms in this area is the AGM theory of belief revision [G88, G92], mentioned before (see page 8). The classic AGM theory is not constructive: it operates with axiomatic notions of belief revision functions operating on deductively closed (ant thus possibly infinite) belief sets. More constructive approaches have been investigated. Gärdenfors et al. [G88, G92] introduce the epistemic entrenchment relation (formally, a total preorder) that orders statements in an agent’s belief set according to their “importance”. Equivalently, the ranking is defined on the semantic level among “possible worlds” described by belief sets. This ordering is used in constructing belief revision functions. In effect, when faced with a contradiction, the agent gives up the least entrenched one of the two contradictory formulas. It is shown that this approach is equivalent to AGM postulates. Additionally, representation of belief sets using finite belief bases - sets of axioms from which agents’ beliefs can be deduced - has been studied. The AGM theory of belief revision is usually described as representing a coherence theory, maintaining that the agent retains its belief as long as it logically coheres with agent’s other beliefs. The other main approach to belief revision is the foundational approach, where an agent holds beliefs only as long as it has satisfactory support. A prototypical example of the foundational approach is Doyle’s classical truth maintenance system [D97]. For many years proponents of mainstream AI have argued that belief revision should be regarded as distinct from nonmonotonic reasoning. Briefly, reasoning is regarded as nonmonotonic when the acquisition of new information leads one to go back and retract prior assumptions. A detailed overview of the four leading approaches to nonmonotonic reasoning may be found in [S97]. In recent years, however, it appears to have become the consensus opinion that these styles of reasoning can be regarded as varieties of belief revision, and [S97] in fact showed how each of these four styles of nonmonotonic reasoning can be defined within the dynamic reasoning systems framework. Thus our treatment of belief revision can be seen as encompassing these well-known forms of nonmonotonic reasoning as well. Schwartz’s Dynamic Reasoning System [S97] framework allows one to portray belief

28 revision as a form of back tracking along the lines of the “truth maintenance,” or “reason maintenance,” systems devised by Doyle [D79]. If at some point in time a contradictory proposition is entered into the path, then this triggers a process (typically human assisted) of working backwards through the path, following the information stored in the labels, looking for “culprit” formulas that may be held responsible for having led to the contradiction. Some of these formulas are then removed from the set of currently held beliefs, so as to eliminate the contradiction, and one uses the formula labels once again to forward chain through all deductions that originated from these formulas and remove them from the current belief set as well. This process can obviously give rise to complexity issues, but it is nonetheless both theoretically feasible and ﬁnitary. 3.3 Communities of Practice

Lave and Wenger [LW91] developed a model of situated learning. According to them, learning occurs among peers during casual, daily interactions within communities of practice. Communities of practice are informal and ad hoc social entities that emerge within and across organizations, usually without explicit purpose or conscious effort. Apprenticeship relationships give us an illustration of such communal learning. Moreover, new learning that occurs in communities of practice is properly thought of as existing in the context of a corresponding community of practice, rather than by itself. This theory led [Wegn04] to various techniques aimed at identifying, analyzing and cultivating communities of practice to improve an organizations ability to utilize benefits of situated learning (learning that occur during routine social interactions). The informal and ad hoc knowledge transfer processes can be assessed and managed to achieve an organization’s goals, in effect by helping to cultivate human capital. This view of informal communities was adopted in the knowledge management domain [HK02]. Virtual communities emerged in the early days of global networks, using early technologies such as Bulletin Board Systems, USENET newsgroups, FIDOnet and e-mail lists. Nowadays, such activities are supported by Web discussion boards, Weblogs, and chat rooms. The high-profile success of the open source movement (eg., [SF07] and others) raised awareness about community-based knowledge collaboration phenomena. As an example of a Web-based collaboration environment, consider two open-source related web communities: the Slashdot news service [SD07] and the free open source developers portal, Sourceforge

29 Figure 3.3: Agent interacting with its environment (from [RN05])

[SF07]. Both websites support community building through discussions and rely on user- supplied content. To date, online communities like Slashdot and Sourceforge provide the main contribution to the open source and free software movement, enabling coordinat- ing software development, documentation authoring, education, publicity and evangelism. Decentralized, community-based Internet-centered development was characterized as the Bazaar way [R01]. Wikipedia [LC01] is a free Web encyclopedia based on voluntary contributions from tens of thousands of authors worldwide. The Wiki mechanism allows any user to edit content and structure of the encyclopedia, while tracking changes so that malicious editing can be rapidly undone. As a result of the eﬀorts of Wikipedia enthusiasts, the encyclopedia is now one of the most popular sites on the Internet, boasting around 5 million unique visitors per month [V05]. Constant attention from this thriving community keeps information complete, up- to-date and surprisingly accurate, making it a valuable information resource for the general population. Accuracy is maintained by leveraging the millions of eyeballs eﬀect that is apparent in Open Source software development [R01].

30 3.4 Software Agents and Multiagent Systems

The notion of an artificial agent received a substantial attention in the literature. In general, an agent is an artificial object that acts on behalf of a human user. In performing their tasks, agents communicate with their (artificial) environment, human user, and other agents (Figure 3.3). Woolbridge and Jenkins [WJ95] list the defining characteristics of agents in the following way: “... a hardware or (more usually) software-based computer system that enjoys the following properties:

• autonomy: agents operate without the direct intervention of humans or others, and have some kind of control over their actions and internal state;

• social ability: agents interact with other agents (and possibly humans) via some kind of agent-communication language;

• reactivity: agents perceive their environment (which may be the world, a user via a graphical user interface, a collection of other agents, the INTERNET, or perhaps all of these combined), and respond in a timely fashion to changes that occur in it;

• pro-activeness: agents do not simply act in response to their environment, they are able to exhibit goal-directed behavior by taking the initiative.”

Agents reason about their environment, and their behavior is determined by their internal state, along with their perception of the environment. Logical frameworks for exploring epistemic states have been proposed by many AI researchers. In the context of intelligent agents, Rao and Georgeff [RG91] have developed the BDI framework, a family of agent specification languages dealing with belief, desire, and intent. They defined both logical formalisms incorporating said concepts as first-class objects and an abstract architecture for agent systems that is based on such formalism. The logical formalism is based on a time-dependent possible worlds semantics. The need to address increasingly complex applications leads to research into systems that consist of multiple agents. In general, “multiagent systems are computational systems in which several semi-autonomous agents interact or work together to perform some set of tasks or satisfy some set of goals” [S98]. Computational agents that constitute a multiagent

31 system may be homogeneous as well as heterogeneous. Each agent acts autonomously to achieve common goals or individual goals. Some of the potential advantages of multi-agent systems include:

• Open information systems can contain multiple autonomous agents. These agents will act on behalf of speciﬁc users or organizations and will have their individual purposes. Users can create agents to satisfy a speciﬁc need in a dynamic fashion, and these agents will function autonomously, communicating with others as needed.

• Complex problems that can not be solved by individual agents can utilize services of multiple agents with diverse capabilities and purposes. Multiagent systems allow the use of the mediator-based approach to information systems.

• Multi-agent systems can support distributed collaborative problem solving by agent collections that dynamically organize themselves.

• Multi-agent systems can be seen as a design paradigm that extends the object- oriented approach. They can lead to more modular, extensible architectures of complex information systems.

32 CHAPTER 4

A LOGIC FOR BELIEF AND TRUST

4.1 Introduction

A community of participants (or agents) in an environment like the Semantic Web forms a social network, where participants can establish trust relationships. These relationships can influence agents’ reasoning processes. For our purposes, we may adopt as a definition of trust the subjective measure of the quality of information originating from the given person. The notion of the Web of Trust is an integral part of the Semantic Web vision [BL98]. Semantic annotations published on the Web are to be identified using digital signatures to prove authenticity. Reasoning about trust, however, is not covered by the current standards. Richardson, Agrawal and Domingos [RAD03] study computational models of trust expressed as numerical weights in a graph representing a social network. We adopt a similar model as an inspiration for our logic semantics. Golbeck and Hendler [GH04, G05] study a behavior of a similar model of real-world social networks and explore its applications for web filtering and recommender systems. Any computational notion of trust should have certain intuitively desirable properties [RAD03]. Trust must have some degree of transitivity: having A trust B and B trust C must imply a certain degree of trust between A and C. We usually think of trust as being asymmetric:A trusts B does not imply B trusts A. And, of course, trust is highly individual and is part of the individual belief system of an agent. Existing proposals and implemented systems treat trust as a numerical value, either having discrete integer levels or being a real value in the interval [0,1]. Numerical representation is advantageous for computational agents, as it allows defining a clear algebra for computing trust values. However, the Semantic Web depends on humans providing initial data, and computational agents must be able to communicate with users that tend to describe their

33 trust preferences in inexact terms. It is not realistic to expect a user to give exact numeric values for trust and belief: “My trust in Bob is 0.7”. More likely, a human user would be inclined to use more vague category: “I have fairly high trust in Bob”. Similar remarks apply to expressions of belief. One more naturally says “I strongly believe P ” than “I believe P to the degree 0.7”. Such vague statements can be thought as corresponding to intervals of trust statements. To enable communication, all agents must us and understand the same labels for categories like ”strongly believe”. Allowing humans to express their opinions in linguistic terms and have those terms be intelligible to computational agents requires that such terms be provided with a computational semantics. Zadeh’s notion of linguistic variable [Z75] can be employed to help satisfy this requirements. Briefly, a linguistic variable is a variable that takes its values among a set of linguistic terms, where those terms are in turn provided some number-theoretic interpretation. In this manner, linguistic variables allow qualitative reasoning based on a number-theoretic semantics. As mentioned in Section 2.3, Gärdenfors [G92] introduces the epistemic entrenchment relation that orders statements in an agent’s knowledge base. Then, when faced with a contradiction, the agent gives up the least entrenched one of the two contradictory formula. Clearly, when trust information is available, it must influence the agent’s willingness to give up beliefs. Thus the formalism presented here might be useful in constructing belief revision models in this same tradition. In this work, we propose a propositional system for addressing Trust and Belief as two specific linguistic variables. It is modeled after a two-leveled logic system for agent-oriented epistemic reasoning presented by Schwartz in [S03]. That system dealt with subjective notions of knowledge and belief, where knowledge is taken as absolute, or unequivocal, belief. Here this same notion of belief is combined with a notion of trust for purposes of addressing the foregoing issues regarding agents acting on the Semantic Web. The objective is to devise a computational reasoning system that captures the natural interactions between trust and belief. 4.2 Operational Context

We are given a community of agents, each of which is assumed to have a personal knowledge base consisting of expressions of belief and trust. Belief expressions are of the form “a

34 believes proposition P to some degree B”, and trust expression are of the form “a trusts b to some degree T ”. An agent’s personal knowledge base changes over time. For a given agent a, the changes that may occur at any given time step include the following: (i) a asserts a degree of belief in some new proposition P , i.e., one not currently in his knowledge base. (ii) a applies an inference rule to some belief proposition currently in his knowledge base to derive a proposition expressing a logical combination of his beliefs and adds this proposition to his knowledge base. (iii) a asserts a degree of trust in some new agent b, i.e., one not currently in his knowledge base. (iv) a applies an inference rule to some trust propositions currently in his knowledge base to derive a proposition expressing a logical combination of his trust relations and adds this proposition to his knowledge base. (v) a acquires from some other agent b an expression asserting b’s degree of trust on some other agent c (as above, it again is assumed that a already is acquainted with b and that a’s knowledge base contains an expression of a’s trust in b). (vi) Each occurrence of type (v) is immediately followed by a’s applying some rule to combine his personal trust in b with b’s asserted trust in c, to conclude his own degree of trust in c. (vii) After a step of type (vi), if c already occurs in a’s knowledge base, some rule is applied to combine the former degree of trust with the new one. (viii) a acquires from some other agent b an expression asserting b’s belief in some proposition P (here it is assumed that a already is acquainted with b and that a’s knowledge base contains an expression of a’s trust in b). (ix) Each occurrence of type (viii) is immediately followed by a’s applying some rule to combine his personal trust in b with b’s asserted belief in P , to conclude his own degree of belief in P . (x) After a step of type (ix), if P already occurs in a’s knowledge base, some rule is applied to combine the former degree of belief with the new one. 4.3 Formal Language

Let us adopt the following notations:

35 B4 unequivocally believes B3 strongly believes B2 fairly confidently believes B1 somewhat believes B0 neither believes nor disbelieves B−1 somewhat disbelieves B−2 fairly confidently disbelieves B−3 strongly disbelieves B−4 unequivocally disbelieves These are taken to express various grades of strength in the agent’s disposition towards believing in a given proposition. In particular, B0 expresses uncertainty, either in the sense that the agent has information to both support and refute the proposition in question, or in the sense that the agent suffers from a complete lack of information regarding the truth or falsehood of the proposition. Distinguishing between these two varieties of uncertainly requires a richer system than the one being considered here. Negative values represent disbelief: a belief that a given statement is false. Both the number of these notations and their interpretations are, of course, to a large extent arbitrary. In order for the following formalism to maintain its coherence, it is only necessary that the subscripting of the belief qualifiers be symmetrical about 0. Thus the above selection should be viewed as being merely for purposes of illustrating a general methodology. The semantics (Section 3), however, implicitly also requires that B0 represent a position of complete equivocation (uncertainty) and that the topmost and bottommost qualifiers represent positions of complete conviction (certainty). Similarly, let us define the following notation for trust:

T4 for total trust T3 for strong trust T2 for medium trust T1 for low trust T0 for no trust Here, trust is treated as a positive value. No trust can mean either justiﬁed distrust or lack of information. If we would allow for a negative trust values, in parallel with deﬁnitions for belief above, a negative trust in an agent would mean a positive belief in a negation of any statement coming from an agent. ”Highly distrusted” agent would consistently report an exact opposite to the truth. That would make the ”distrusted” agent just as reliable and useful as a ”trusted” agent. This interpretation runs contrary to the intuition.

36 The language L for our system is deﬁned as follows. As symbols we shall have: the propositional variables p1, p2,..., the logical connectives ¬, ∨, ∧, →,¬ ˙ , ∨˙ , ∧˙ ,→ ˙ , the left and right parentheses “(” and “)”, the belief operators B4,..., B−4, the trust predicates T4,..., T−4, and the agent constants a1, a2,.... The formulas for L will be the combined members of the following:

F1 = {p1, p2,...} 1 F2 = F1 ∪ {¬P, (P ∨ Q), (P ∧ Q), (P → Q)|P,Q ∈ F1 ∪ F2}

F3 = {Bi(a, P )|P ∈ F2, i = −4,..., 4 and a ∈ {a1, a2,...}}

F4 = F3 ∪ {(¬ ˙ P ), (P ∨˙ Q), (P ∧˙ Q), (P →˙ Q)|P,Q ∈ F4}

F5 = {Ti(a, b)|i = −4,..., 4 and a, b ∈ {a1, a2,...}}

F6 = F5 ∪ {(¬ ˙ P ), (P ∨˙ Q), (P ∧˙ Q), (P →˙ Q)|P,Q ∈ F6}

As in ordinary propositional calculus, the propositional variables are used to represent statements about the world, and the formulas in F2 represent the logical combinations of these that can be constructed in the usual ways using the given un-dotted logical connectives.

Let us call these lower-level formulas. The formulas in F3 are used to express the condition that an agent a has some degree of belief Bi in a lower-level statement P . The formulas in

F4 are then the logical combinations of these constructed in the usual ways using the given dotted connectives. Similarly, the formulas in F5 are used to express and agent’s conditions of trust in a lower-level statement, and the formulas in F6 are their logical combinations. The members of latter four sets may be called upper-level formulas. Evidently, these are encodings of statements about lower-level formulas and will have their own associated logic. The precise meanings of the various connectives, both un-dotted and dotted, as well as the meanings of the belief and trust modiﬁers, are provided in the section below. 4.4 Dynamic Reasoning and Belief Revision

The classical (propositional) notion of belief set [e.g., G88] models it as an (often inﬁnite) set of formulas of the underlying logical language. In our view, a belief set should be ﬁnite and should represent the agent’s knowledge and beliefs at a given point in time. Moreover, each formula in such a belief set should contain information indicating how if was obtained

1 This notation abbreviates the usual inductive deﬁnition, in this case the smallest class of formulas containing F1 together with all formulas that can be built up from formulas in F1 in the two prescribed ways.

37 and whether it has been used in subsequent deductions, thereby enabling both backtracking and forward chaining through reasoning paths for so-called “reason maintenance”. To this end, in [S97] there was deﬁned the notion of a dynamic reasoning system (DRS), which explicitly portrays reasoning as an activity that takes place in time. This is obtained from the conventional notion of formal logical system by lending special semantic status to the concept of a derivation path (i.e., a proof). Introduction of new knowledge or beliefs into the path occurs in two ways: either new propositions are added in the form of axioms, or some propositions are derived from earlier ones by means of an inference rule. In either case, the action is regarded as occurring in a discrete time step, and the new proposition is labeled with a time stamp (an integer) indicating the step at which this occurred. Moreover, for propositions entered into the path as a result of rule applications, the label additionally contains a record of which inference rule was used and which propositions were employed as premises. At any given time, the contents of the path is regarded is being the sum total of the agent’s knowledge and beliefs as of that time. Thus we here take this path as being the agent’s belief set as of that time. This is to be contrasted with other systems of belief revision, which assume that the agent additionally knows all the logical consequences of the basic belief set. Such systems are said to exhibit “logical omniscience.” For an in-depth analysis of this issue, together with a manner of addressing it, see the paper by Fagin, Halpern, Moses, and Vardi [F95]. For complete details of the notion of a DRS, please see [S97]. A brief outline is as follows. A labeled formula is deﬁned as a pair (P, λ), where P ∈ L, where L is a logical language, and the label λ is an ordered 4-tuple (index, from, to, status), where:

1. index is a non-negative integer, the index, representing the formulas position in the belief set.

2. from is a from list, containing information about how the formula came to be entered into the belief set. Either it was received from an outside source (obtained from some other agent or through interaction with its environment), in which case the from list contains the token rec, or it was derived from some formulas occurring earlier in the belief set, in which case the from list contains the name of the derivation rule and the indices of the formulas used as premises in the derivation. The types of formulas that

38 can be received are understood to include both axioms of the propositional calculus and statements about the agents environment (sometimes distinguished as “logical” and ”nonlogical” axioms).

3. to is a to list, containing the indices of all formulas in the belief set for which the given formula served as a premise in the indexed formula’s derivations.

4. status is a status indicator, taking values on or oﬀ, indicating whether the belief represented by the formula is currently held, i.e., whether the formula may or may not be used in any future derivations. Whenever a formula is initially entered into the belief set, its status is on.

For a given agent, let us denote the agent’s belief set at time step i by Λi. Let Λ0 = ∅.

Thus the agent initially has no knowledge or beliefs. Then, given Λi, for i ≥ 0, Λi+1 can be obtained in any of the following ways:

1. A new formula is received from an outside source,

2. A formula is derived from some formulas in Λi by means of an inference rule,

3. A formula in Λi has its status changed from on to oﬀ.

Changing a formula’s status from on to off occurs during a reason maintenance process that is invoked whenever an inconsistency, i.e., a formula of the form (P ∧˙ ¬˙ P, λ) is entered into the agent’s belief set. The objective of reason maintenance is to remove this inconsistency. This has two phases. First one starts back tracking from the inconsistency, using the from lists in the formula labels, looking for the “culprit” formulas that occurred earlier and which led to the inconsistency. A decision then must be made to turn the status of at least one of these formulas to “off”. Then one forward chains from this formula, using the to lists, to find all formulas whose derivations stemmed from the culprit formula, and likewise turns their status to “off”. This will include the inconsistent formula that triggered the reason maintenance process. Which culprit formula to deactivate can be determined by the various culprits’ degrees of belief, to wit, remove the one that is least believed. It case the culprits are all believed equally, one can be chosen at random. Alternatively, an agent can remove the culprit formula that

39 is the least important according to a reasonable criteria. One such criteria is a cumulative belief level of formulas derived from the culprit. This criteria provides a ﬁnite version of epistemic entrenchment relation. This model of agent-oriented reasoning reﬂects that view that, at any given time, the agent’s beliefs may harbor an inconsistency, but the agent does not become aware of this unless an inconsistent formula is explicitly entered into its belief set. This, in our opinion, is a realistic model of natural human reasoning. Humans can comfortably maintain inconsistent beliefs for long periods of time without ever realizing this. But once they become consciously aware of a contradiction, they typically rethink their position and modify their beliefs so that the contradiction is removed. 4.5 Semantics

The semantics for F1 and F2 involves belief mappings β, associating the formulas in these collections with numbers in the interval [−1, 1]. Then formulas in F3 are assigned truth values deﬁned in terms of the belief mappings. In this respect, the semantics follows [S03], with the exceptions (i) that the valuation function now has an agent constant as an argument, and (ii) we have used [−1, 1] in place of the interval [0, 1]. We chose [−1, 1] here so that belief notions will interact more naturally with trust. Let A be the set of all individual constants.

Then a belief mapping β : A × F2 → [−1, 1] has the following properties:

β(a, P ) ∈ [−1, 1] β(a, ¬P )= −β(a, P ) β(a, P ∨ Q) = max[β(a, P ),β(a, Q)] β(a, P ∧ Q) = min[β(a, P ),β(a, Q)] β(a, P → Q) = min[1, 1 − β(a, P )+ β(a, Q)]

The value β(a, P ) represents the degree to which agent a believes proposition p. In order to define truth valuations for the formulas in F3, first define some belief intervals according to

β4 = [1, 1] (singleton 1) 5 β3 = [ 7 , 1) 3 5 β2 = [ 7 , 7 ) 1 3 β1 = [ 7 , 7 )

40 1 1 β0 =(− 7 , 7 ) 3 1 − β 1 =(− 7 , − 7 ) 5 3 − β 2 =(− 7 , − 7 ] 5 − β 3 =(−1, − 7 ]

β−4 = [−1, −1] (singleton −1)

Then let the truth values for formulas in F3 be given by

v(Bi(a, P )) = T iﬀ β(a, P ) ∈ βi

This captures the notion that the assertion that an agent a holds P with (linguistic) degree of belief Bi can be represented by the assertion that a would place his (her, its) numeric degree of belief in P somewhere in the interval βi. In this manner, a linguistic term is interpreted as a range of numeric values. Note that it is not assumed that any agent actually assigns such a numeric value. The foregoing reference to a value β(a, P ) serves only to deﬁne the mathematical relationship between the linguistic term and its numeric range. In actual practice, the agent need only specify the interval label. Then the underlying reasoning can be performed as computations on the interval associated with that term. Besides easing computations, using pre-deﬁned symbols can ease communication in a multi-agent environment.

For formulas in F4, we can extend v by setting

v(¬ ˙ P )= T iff v(P )= F v(P ∨˙ Q)= T iff either v(P )= T or v(Q)= T v(P ∧˙ Q)= T iff both v(P )= T and v(Q)= T v(P →˙ Q)= F iff v(P )= F and v(Q)= T

It is shown in [S03] that this semantics leads to an intuitively plausible logic for belief. The formulas of the form T (a, b) are taken as expressing the degree of trust that agent a has in the beliefs of agent b. To provide a semantics for F5, ﬁrst deﬁne some trust intervals according to

τ4 = [1, 1] (singleton 1) 2 τ3 = [ 3 , 1) 1 2 τ2 =( 3 , 3 ) 1 τ1 = (0, 3 ]

41 τ0 = [0, 0] (singleton 0)

The relationship between linguistic degrees of trust and their associated intervals is analogous to that described above for the linguistic degrees of belief. The trust mapping τ : A × A → [0, 1] has the following properties:

τ(a, b) ∈ [0, 1]

if τ(a, b) ∈Ti and τ(b, c) ∈Tj,

then τ(a, c) ∈Tmin(i,j)

The latter constraint is satisﬁed simply by requiring

τ(a, c)= min[τ(a, b), τ(b, c)] and this is arguably the most natural choice. There are, of course, other equally plausible formulations of transitivity for trust, e.g., τ(a, c)= τ(a, b) × τ(b, c) This, however, will not satisfy the given constraint. The reason the given constraint is desirable is that it ensures that certain formulas of interest will be true under the resulting semantics, and this in turn ensures that certain logical deductions remain valid. These are discussed in the section below. Careful examination reveals a problem with the above deﬁnition of τ 2. Given any three agents a, b, and c, deﬁnition would require τ(a, c)= min[τ(a, b), τ(b, c)], that, in turn, implies τ(a, c) ≤ τ(a, b) τ(a, c) ≤ τ(b, c)

At the same time. the following is also required: τ(a, b)= min[τ(a, c), τ(c, b)], τ(a, b) ≤ τ(a, c) τ(a, b) ≤ τ(c, b) τ(b, c)= min[τ(b, a), τ(a, c)], τ(b, c) ≤ τ(b, a) τ(b, c) ≤ τ(a, c)

2This observation was made by my committee member, Dr. Theodore P. Baker

42 From these, it follows that τ(a, c)= τ(a, b)= τ(b, c) and, thus, τ is a constant function. In fact, any rule aimed at enforcing transitivity will lead to the same result. Thus, any nontrivial model for trust that satisfy requirements in section 4.1 is inherently contradictory. To solve this problem, we apply the idea that underlies the Dynamic Reasoning System and separate the conflicting trust values in time. The partial mapping τ((a, b),t) represents an agent’s trust relationship at the discrete time step t. It is defined only for select pairs of agents and time steps. With this mapping in mind, an agent is free to use the following expression to produce new values from previously defined ones: τ((a, c),t′′)= min[τ((a, b),t), τ((b, c),t′)],t′′ > t,t′′ >t′,

This expression should not be interpreted as universally quantified rule. For any system at any given point, there cam be agents a, b, c and corresponding time stamps for which this expression is false. It can occur when an agent didn’t perform an inference step yet, user entered new value overriding old inference, or there exist different potential inference paths leading to different values fot In this last case an agent can take action to reconcile its beliefs, as soon as it becomes aware of the contradiction. To apply this semantics, we consider labeled formulas (P, λ), where P ∈ F5 ∪ F6. Given such a trust mapping τλ, the above mapping v can be extended to labeled formulas in F5 by setting

v((Ti(a, b), λ)) = T iﬀ τ((a, b),t) ∈ τi, where t is the timestamp recorded in λ

′ ′′ ′ ′′ This can be extended to labeled formulas in F6. Given that λ, λ , λ are valid labels, t,t ,t are timestamps recorded in the corresponding labels and t>t′,t>t′′: v((¬ ˙ P, λ)) = T iff v((P, λ′)) = F v((P ∨˙ Q, λ)) = T iff either v((P, λ′)) = T or v((Q, λ′′)) = T v((P ∧˙ Q, λ)) = T iff both v((P, λ′)) = T and v((Q, λ′′)) = T v((P →˙ Q, λ)) = F iff v((P, λ′)) = F and v((Q, λ′′)) = T

This semantics solves the problem referred to above and allows for deﬁning a rule for reasoning with trust (see Section 4.5). Inference rules are invoked dynamically within a framework of Dynamic Reasoning System (see Section 4.7). As was mentioned in Section 2.1, the choice and order of inference applications are important and are determined by goals an agent seeks to achieve. Section 4.6 describes how a speciﬁc heuristic choice of trust inference steps is made to avoid a system converging to a state where all agents have the same degree of trust in each other and hence most of the information on trust provided by

43 users is lost. Other inference steps are invoked in order deﬁned by the operational context (Section 4.1) and further detailed in procedures for task-oriented reasoning (Chapter 5)

4.6 Reasoning

Given the foregoing language and semantics, the next task is to precisely deﬁne the various operations (i)-(x) described in Section 4.3 and explore the validity of these operations with respect to the semantics. With regard to the applications of propositional calculus described in (ii), it is straightforward to verify that the axioms and rules of propositional calculus are valid for the belief expressions in F4. More exactly, all formulas in F4 having the forms

(P →˙ (Q→˙ P )) ((P →˙ (Q→˙ R))→ ˙ ((P →˙ Q)→ ˙ (P →˙ R))) (((¬ ˙ P )→ ˙ (¬ ˙ Q))→ ˙ (Q→˙ P )) are tautologies, and Modus Ponens (from P and P →˙ Q, infer Q) is valid in the sense that, if P and P →˙ Q are tautologies, then Q will be a tautology. This axiomatization of the propositional calculus is from [H88]. Similar remarks apply to the applications of the propositional calculus referred to in (iv), for reasoning with expressions of trust. In addition to the principles of propositional calculus, it was veriﬁed in [S03] that the semantics also validates all formulas in F4 having the forms

Bi(a, P )∧B˙ j(a, Q)→B ˙ min[i,j](a, P ∧ Q)

Bi(a, P )∧B˙ j(a, Q)→B ˙ max[i,j](a, P ∨ Q) for all i and j. It was argued in [S03] that this provides an intuitively plausible manner for reasoning about beliefs. These, together with Modus Ponens, provide additional inference rules for reasoning about expressions of belief.

To model evolution of agent’s beliefs, we place the statements from F3 − F6 into the Dynamic Reasoning System. This allows us to express, below, rules for trust combination and belief evolution. As discussed above, application of an inference rule occurs at the time step i, so for two integers j, k < i, Modus Ponens will read

From (P, λj) and (P →˙ Q, λk), infer (Q, λi)

44 The above implies that other components of λi are set accordingly, i.e. from-list contains j and k, status is set to on, and to-lists of the premises are updated with the index i. In the following, we will skip the label if doing so does not lead to confusion.

For dealing with trust expressions, it is easily veriﬁed that all labeled formulas in F6 having the form

(Ti(a, b)∧T˙ j(b, c)→T ˙ min[i,j](a, c), λ) are justified by the semantics. This is a direct consequence of the constraints imposed in the definition of the trust mapping τ. Thus, this together with Modus Ponens can be used to provide the desired inference rule. Specifically, choosing appropriate time indexes,

′ ′′ v((Ti(a, b), λ )) = T and v((Tj(b, c), λ )) = T ⇒ ′ ′′ τ((a, b),t ) ∈ τi and τ((b, c),t ) ∈ τj ⇒

τ((a, c),t) ∈ τmin[i,j] ⇒

v((Tmin(i,j)(a, c), λ)= T

We claim that this embodies an intuitively plausible manner of reasoning about conditions of trust. The kind of rule referenced in (vii) may be referred to as trust revision. Here one is given two conditions of trust that an agent holds with respect to another agent, Ti(a, b) and

Tj(a, b), and is required to combine these in some way to produce a condition Tk(a, b). Thus it is required to specify how to determine k as a function of i and j. As described in the Operational Context, this rule would only be invoked in response to having just invoked a rule of the kind referenced in (vi). Thus it may be assumed that Ti(a, b) is the older assertion and that Tj(b, c) is the newer one that has been just derived. There are several alternative means for dealing with this situation. An “optimistic” approach would be to retain the proposition with the maximal trust, i.e., set k = max(i, j). A “pessimistic” one would be to similarly use the min. And a “most recently used” approach would be to delete the older proposition and retain the newer one. The rule referenced in (ix) entails combining expressions of belief and trust. Here intuition seems to prescribe that a multiplication rule is most appropriate. To wit, for agents a and b, and formula P , one should have

β(a, P )= τ(a, b) × β(b, P )

45 Table 4.1: Scheme for combining belief and trust.

43210 −1 −2 −3 −4 4 43210 −1 −2 −3 −4 3 33210 −1 −2 −3 −3 2 22110 −1 −1 −2 −2 1 11000 0 0 −1 −1 0 00000 0 0 0 0

Adhering to this formula is problematic, however, given the desire to have the user deal only with linguistic belief values. If one applies this formula to the lower and upper end points, respectively, of two intervals τi and βj, the results do not describe any one belief interval, but rather describe an interval that overlaps at least two such intervals. Thus the resulting algebra based on linguistic values is not closed with respect to this rule of combination. To remedy this, we have constructed Table 1 by applying this formula to the midpoints of the trust and belief intervals corresponding to each given row i and column j, and entering into cell (i, j) the belief interval to which the resulting product belongs. Then, in accordance with Table 1, our rule becomes

From Ti(a, b) and Bj(b, P ), infer Bk(a, P ) where k is the entry in row i and column j. A rule of the kind referenced in (x) may be referred to as belief revision. For this we adapt a technique for “likelihood combination” developed in [S97]. Here one is given two conditions of belief that an agent holds with respect to the same proposition, Bi(a, P ) and

Bj(a, P ), and is required to combine these in some way to produce a condition Bk(a, P ) that represents the overall eﬀect of the two degrees of belief. Thus it is required to specify how to determine k as a function of i and j. As described in the Operational Context, this rule would only be invoked in response to having just invoked a rule of the kind referenced in

(ix). Thus it may be assumed that Bi(a, P ) is the older assertion and that Bj(a, P ) is the newer one that has been just derived. In this case there may be various diﬀerent rules that are intuitively plausible. One that we will propose here is given by Table 4.2. This is

From Bi(a, P ) and Bj(a, P ), infer Bk(a, P )

46 Table 4.2: Scheme for belief revision.

4 3 2 1 0 −1 −2 −3 −4 4 4 4 4 4 4 4 4 4 ∗ 3 4 3 3 3 3 3 3 0 −4 2 4 3 2 2 2 2 0 −3 −4 1 4 3 2 1 1 0 −2 −3 −4 0 4 3 2 1 0 −1 −2 −3 −4 −1 4 3 2 0 −1 −1 −2 −3 −4 −2 4 3 0 −2 −2 −2 −2 −3 −4 −3 4 0 −3 −3 −3 −3 −3 −3 −4 −4 ∗ −4 −4 −4 −4 −4 −4 −4 −4

where k is the entry in row i and column j. The asterix symbols in the upper right and lower left corners are taken as representing contradiction. How these are dealt with is discussed in Section 4.6. Let us refer to each choice of i, j, k in Table 4.2 as giving an instance of the belief revision rule, and let us denote the three corresponding occurrences of P by P i, P j, and P k. Then all rule instances, excepting the two yielding contradiction, will be valid with respect to any i j k belief mapping β that satisﬁes: if β(a, P )= ri and β(a, P )= rj, then rk = β(a, P ) is

undefined if (ri = 1 and rj =0) or (rj = 1 and ri = 0) 1 if (ri = 1 and rj =0)6 or (rj = 1 and ri =6 0) 0 if (ri = 0 and rj =1)6 or (rj = 0 and ri =6 1) 1 max[ri, rj] if ri, rj ≥ 2 1 min[ri, rj] if ri, rj ≤ 2 (ri + rj)/2 otherwise The intuition underlying this scheme is that the values 1 and 0 should be dominant. More exactly, except for the contradictory situations, if either value is 1 or 0, then that value 1 dominates the combination; if both values lean toward 1 or both toward 0 (relative to 2 ), then the value closest to that extremity dominates; otherwise the values are regarded as partly confirming and partly disconfirming, and so serve to cancel each other out. Last we must specify how Modus Ponens is to be applied to premises with belief qualifications (formulas in F3). For this it is natural to treat the premises as if they are being combined with the logical conjunction. Thus Modus Ponens in this context becomes:

From Bi(a, P ) and Bj(a, P → Q), infer Bmin(i,j)(a, Q)

47 Figure 4.1: Agent conﬁguration demonstrating trust convergence

It is a consequence of the foregoing semantics that that all formulas in F2 having the form of tautologies of the propositional calculus have the belief value 1. Thus every agent will have unequivocal belief (B4) in all formulas having these forms.

4.7 Controlling Trust Inferences

Agents in our model are not simply variables in trust and belief statements. As we stated in Section 2.1, agents are active entities that perform cognitive actions. Agents maintain their belief sets, get statements from other agents and perform inferences in order to advance their individual goals. Accordingly, we will attribute inference activity to a speciﬁc agent. If no agent is speciﬁed as the one performing inference, we will assume that the inference is performed by agent a. Establishing trust relationships with previously unknown agents is among the goals that the agent may have. Agents and trust relations form a graph (or web of trust). In this graph, statements Ti(a, b) represent an edge, and agent b is a direct descendant of agent a. We can see this aspect of agent’s behavior as traversing the graph, inferring statements of the form

Ti(a, x) and adding them to agent a‘s belief set, so they can later be used to acquire new beliefs from other agents. Unguided applications of the trust inference rule presented in Section 4.5 (see p. 42) can lead to undesired results. Let a, b, and c be three agents with associated trust relations as shown at Figure 4.1. Consider the derivation path (abbreviated):

48 (1) T1(a, b) premise (2) T2(b, c) premise (3) T3(b, a) premise (4) T3(c, b) premise (5) T1(a, b)∧T˙ 2(b, c)→T ˙ 1(a, c) axiom (6) T1(a, c) (1),(2),(5) (7) T3(b, a)∧T˙ 1(a, c)→T ˙ 1(b, c) axiom (8) T1(b, c) (3),(6),(7) (9) T3(c, b)∧T˙ 1(b, c)→T ˙ 1(c, a) axiom (10) T1(c, a) (4),(8),(9) (11) T1(b, c)∧T˙ 1(c, a)→T ˙ 1(b, a) axiom (12) T1(b, a) (8),(10),(11) (13) T1(c, a)∧T˙ 1(a, b)→T ˙ 1(c, b) axiom (14) T1(c, b) (8),(12),(13) As can be seen, circular application of the trust inference resulted in all agents holding the same level of trust in one another, T1. As mentioned in section 4.4, this amounts to a loss of information provided by users. The root cause of such undesirable results is the fact that a directed graph that represents the Web of Trust is allowed to have loops. In order to remedy this, we need to introduce an extralogical procedure for an agent to pursue its goals while preventing this type of reasoning. Assume that the agent a has the goal to establish trust relations Ti(a, x) with all agents that are reachable from a. A procedure that guides the inference process so that no inference paths contain loops applies a technique for building a tree from an initial directed graph, namely, the well-known Breadth-First Search (BFS) algorithm [K68]. Where queue is a ﬁrst-in, ﬁrst-out abstract container:

Algorithm BFS

For an agent a:

1. Push agent a onto queue

2. Pull agent x from the queue

3. Mark x visited

4. For all of x’s direct descendants y that are not yet visited:

• If no statement Ti(a, y), from Ti(a, x) and Tk(x, y), infer Tk(a, y)

49 • Put agent y onto the queue

5. If the queue is empty, quit

6. Repeat from Step 2

Let us consider our initial example. We start with agent a and do the reasoning according to BFS: Iteration Queue Inferred statement Immediate descendants Visited 0 { a } b 1 { b } a, c a 2 { c } T1(a, c) b a, b 3 {} halt a, b, c

As we see, agent a infers T1(a, c) and stops, avoiding circular inference and not losing any information. The fact that it did not infer T1(c, a) is not a problem, since agent a does not use this statement in inferring its beliefs. Agent c, running the same algorithm, will infer

T1(c, a). Breadth-first search is known to follow the shortest path between the start and goal node and for avoiding loops. This procedure also offers additional benefits:

• All inferences produce statements useful for the agent, namely of the form Ti(a, x).

• The total number of inferences is lower. In general case and for unit-length graphs, BFS is optimal.

• BFS guarantees the shortest inference path. As Schwartz noticed in [S97], chaining implication leads to belief levels quickly converging to uncertainty. Shorter paths preserve more information.

In a multiagent system, agents run their inference processes in parallel. Thus, a trust statement that agent a acquires from agent b may be derived by the latter through some inference path. Unless agents exchange full path information, agent a is unaware of the path agent b took and thus can not be sure his new inference path does not contain a loop. A simple way to deal with this issue is to limit the application of BFS by only considering trust statements supplied to agents by their respective users, i.e., ignoring statements those agents have inferred from other statements. This solves the problem, but it can result in loss of performance, as an agent will be forced to repeat derivation paths already considered

50 by other agents. A more sophisticated algorithm that suggests itself here is one based on network routing protocols, which calculate the shortest paths between nodes in a network, where the network can change dynamically. Various protocols have been proposed and used for this (e.g., RIP, IGRP and OSPF protocol standards, cf. [H88a]). Whether any of these can be adapted to the present task has been reserved for future research. 4.8 Illustration

The manner in which the foregoing inference rules are to be used can be illustrated by some examples. Suppose that the belief sets for agents a, b, and c contain the formulas shown in the following table.

Agent a Agent b Agent c T2(a, b) T3(b, c) B3(c, P1 → P2) B2(b, P1)

We assume that an agent is free to add formulas from any other agent’s belief set. Here the goal of agent a is to determine his own attitude towards P2, i.e., to derive a formula of the form Bi(a, P2). His reasoning steps might proceed as follows:

1. Acquire formula B2(b, P1) from agent b.

2. Combine T2(a, b) and B2(b, P1) using Table 1 to obtain the belief B2(a, P1).

3. Acquire trust statement T3(b, c) from agent b.

4. Using the principles of classical logic, combine T2(a, b) and T3(b, c) to obtain T2(a, b)∧T˙ 3(b, c).

5. Assert the axiom T2(a, b)∧T˙ 3(b, c)→T ˙ min[2,3](a, c).

6. Apply Modus Ponens and the min operator to obtain T2(a, c). Thus a has medium trust in c.

7. Acquire formula B3(c, P1 → P2) from c.

8. Combine T2(a, c) and B3(c, P1 → P2) using Table 4.1 to obtain B2(a, P1 → P2),

9. Apply the above mentioned modiﬁed version of Modus Ponens to B2(a, P1) and

B2(a, P1 → P2) to obtain B2(a, P2). Thus a fairly conﬁdently believes P2.

51 Now let’s assume the some other agent d postulates a diﬀerent level of belief in P2, say

B1. Then the agents now have belief sets as shown in the following table.

Agent a Agent b Agent c Agent d T2(a, b) T3(b, c) B3(c, P1 → P2) B−1(d, P2) T2(a, c) B2(b, P1) T3(c, d) B2(a, P2)

In this case, agent a may revise his degree of belief in P2 in the following manner.

1. Acquire the trust formula T3(c, d) from agent c.

2. Using the same methods as described above, combine T2(a, c) and T3(c, d) to get T2(a, d) (medium trust).

3. Acquire formula B1(d, P2) from agent d.

4. Use Table 4.1 to combine B−2(d, P2) and T2(a, d) to get B−1(a, P2). At this point, a

has two diﬀerent belief assertions regarding P2.

5. Perform a belief revision step: From B1(a, P2) and the previously obtained B2(a, P2),

use Table 4.2 to derive the new belief statement B2(a, P2). This leads to the belief sets

Agent a Agent b Agent c Agent d T2(a, b) T3(b, c) B3(c, P1 → P2) B−2(d, P2) T2(a, c) B2(b, P1) T3(c, d) T2(a, d) B2(a, P2)

For illustrative purposes, we have removed the old beliefs from the above table. Ina implementation, the agent would retain those beliefs, but turn their status to off. This would help tracing the justifications for beliefs and prevent an agent from re-acquiring them, thus making belief revision a finitary process.

52 CHAPTER 5

TASK-ORIENTED REASONING

5.1 Agent’s Knowledge Base

The agent’s knowledge base includes the following:

• A Dynamic Reasoning System (DRS), containing taxonomic knowledge of the agent in the form of a derivation path at a given point in time.

• A taxonomy tree, containing a topic hierarchy calculated using the DRS. This will serve as an index, helping to guide the inference process.

• A list of documents. A document record will link to all the topics to which the document belongs.

• Trust information. A list of all currently held trust relationships of a particular agent.

For a formal representation system, we require a logic that enables us to speak about individual documents. To this end we now extend the propositional calculus for belief and trust presented in Section 4 to a ﬁrst-order predicate calculus. This follows somewhat the line of development in [S07], but, whereas that work concerns only belief conditions, the present treatment additionally incorporates the notion of trust.

F1 = {p(t1, ..., tn)| p is an n-ary predicate symbol, n ≥ 1, and the ti are terms}

F2 = F1 ∪ {¬P, (P ∨ Q), (P ∧ Q), (P → Q)|P,Q ∈ F1 ∪ F2}

F3 = {Bi(a, P )|P ∈ F2, i = −4,..., 4 and a ∈ {a1, a2,...}}

F4 = F3 ∪ {(¬ ˙ P ), (P ∨˙ Q), (P ∧˙ Q), (P →˙ Q)|P,Q ∈ F4}

F5 = {Ti(a, b)|i = −4,..., 4 and a, b ∈ {a1, a2,...}}

F6 = F5 ∪ {(¬ ˙ P ), (P ∨˙ Q), (P ∧˙ Q), (P →˙ Q)|P,Q ∈ F6}

53 The following statement forms will constitute axiom schemas for our system. Where

A, B, C ∈ F6 and a is an agent constant, (S1) A→˙ (B→A˙ ) (S2) (A→˙ (B→C˙ ))→ ˙ ((A→B˙ )→ ˙ (A→C˙ )) (S3) (¬A ˙ →˙ ¬B˙ )→ ˙ (B→A˙ ))

(S4) B4(a, A → (B → A))

(S5) B4(a, (A → (B→C)) → ((A→B) → (A→C))

(S6) B4(a, ¬A → ¬B) → (B → A)) (S7) A→˙ A(y/x), if y does not occur in A (S8) A→˙ A(c/x), where c is a constant symbol

(S9) Bi(a, P )∧B˙ j(a, Q)→B ˙ min[i,j](a, P ∧ Q)

(S10) Bi(a, P )∧B˙ j(a, Q)→B ˙ max[i,j](a, P ∨ Q)

(S11) Ti(a, b)∧T˙ j(b, c)→T ˙ min[i,j](a, c) In addition, the following rules of inference are deﬁned:

(R1) Instantiation: From schema S infer S(P1,...,Pn/A1,...,An), assuming the substi- tution results in a formula of the language. (R2) Modus ponens: From A and A→B˙ , infer B.

(R3) Modiﬁed modus ponens: From BiP and BjP → Q, infer Bmin[i,j]Q.

(R4) Trust Application: From Ti(a, b) and Bj(b, P ), infer Bk(a, P ), where k is a value in a cell [i, j] of Table 4.1.

(R5) Belief Combination From Bi(a, P ) and Bj(a, P ), infer Bk(a, P ) where k is a value in a cell [i, j] of Table 4.2. Axiom schemes S1, S2, and S3, together with R2, comprise an axiomatization of the classical propositional calculus, taken from [H88]. Axiom schemes S4 through S8, are adapted from the additional axioms required for ﬁrst-order predicate calculus, also as found in [H88]. Axiom schemas S9, S10, and S11, and inference rules R3, R4 and R5 encode the same propositions and rules regarding belief and trust as discussed in Section 4.5. Thus the same arguments regarding their soundness and intuitive validity reapply in the present context.

To simplify our notation, we will use BiP as an abbreviation for Bi(a, P ), where a is the name of the agent doing the reasoning. To represent the contents of an agent’s knowledge base, we choose the following types of statements:

54 1. Subtypes: Bi(p1(x) → p2(x))

2. Disjointness: Bi(p1(x) →¬p2(x))

3. Or-Deﬁnition: Bi(p1(x) → p2(x) ∨ p3(x))

4. And-Deﬁnition: Bi(p1(x) ↔ (p2(x) ∧ p3(x))

5. Document Classiﬁcation: Bip1(doc1), Bi¬p1(doc1)

6. Trust relationship: Ti(a1, a2)

These types of statements provide means to define a rich taxonomy. Or- and And- Definitions statements can be allowed to have more than two predicates on the right-hand side with trivial changes to algorithms. In the following, we will refer to statements of forms 1–4 as taxonomy statements. Statements having forms 5 re positive or negative document classification statements. We will refer to statements of form 6 as trust statements. The goal of the system is to provide accurate classification of documents. An additional desire is for the system to automatically detect and, preferably, remove sources of any contradictory classifications. There is no direct need to infer new taxonomy statements. Thus, we can concentrate on inferences that result in new document classifications. For example, a subtype statement can be exploited in the following manner:

(1) Bi(p1(x) → p2(x)) premise (2) Bjp1(doc1) premise • (3) Bi((p1(x) → p2(x))→B ˙ i(p1(doc1) → p2(doc1))) (S8), (R1) (4) Bi(p1(doc1) → p2(doc1)) (1),(3),(R2) (5) Bmin[i,j]p2(doc1) (2),(4),(R3)

Since all such arguments will follow this same pattern, in practice, the system may skip steps 3-5 and go directly from premises to the conclusion. Other taxonomy statements lead to the similar inference processes as shown in Table 5.1.

55 Table 5.1: Inferring new document classiﬁcations.

Premise 1 Premise(s) 2 Conclusion Bi(p1(x) → p2(x)) Bjp1(doc1) Bmin[i,j]p2(doc1) Bi(p2(x) → p1(x))) Bj¬p1(doc1) Bmin[i,j]¬p2(doc1) Bi(p1(x) →¬p2(x)) Bjp1(doc1) Bmin[i,j]¬p2(doc1) Bi(p1(x) →¬p2(x)) Bjp2(doc1) Bmin[i,j]¬p1(doc1) Bi(p1(x) ↔ p2(x) ∨ p3(x)) Bjp1(doc1), Bk¬p3(doc1) Bmin[i,j,k]p2(doc1) Bi(p1(x) ↔ p2(x) ∨ p3(x)) Bjp2(doc1) Bmin[i,j]p1(doc1) Bi(p1(x) ↔ p2(x)) ∧ p3(x)) Bjp1(doc1) Bmin[i,j]p2(doc1), Bmin[i,j]p3(doc1) Bi(p1(x) ↔ p2(x) ∧ p3(x)) Bjp2(doc1), Bkp3(doc1) Bmin[i,j,k]p1(doc1) Bi(p1(x) ↔ p2(x) ∧ p3(x)) Bj¬p2(doc1) Bmin[i,j]¬p1(doc1)

5.2 Conceptual Structures and Notations

The agent’s knowledge base, KB, is an ordered set of labeled formulas (P, λ), as outlined in Section 4.6. It is initially empty. While the reasoning process runs, new statements are inserted into the knowledge base. To reiterate, a statement’s label contains the sets from and to, an integer index (marking the statement’s position in the knowledge base and thereby acting as a timestamp), and a status indicator. The following sets of objects can be obtained from the knowledge base:

1. Documents: the set of all document constants appearing in the KB

2. Predicates: the set of all predicate symbols appearing in the KB

3. Agents: the set of all other agents known to the agent, represented by trust statements in the KB.

The following additional notations are used:

• KB.maxindex, for the maximum index value used in the KB

• where P is a statement of the form BiQ, P.BeliefLevel = i

• λ.from, λ.to, λ.index, λ.status are the four elements of the label λ

• where P is a statement, P.Predicates is the list of predicates used in P

56 • where p is a predicate, p.Statements = {P : p ∈ P.Predicates}, i.e., the list of statements where p is used

• where doc is a document constant, doc.positivePredicates = {p1 ∈ Predicates : ∃Bi, λ :

(Bip1(doc1), λ) ∈ KB}

• where doc is a document constant, doc.negativePredicates = {p1 ∈ Predicates : ∃Bi, λ :

(Bi¬p1(doc1), λ) ∈ KB}

• where doc is a document constant, doc.Predicates = doc.Predicates∪doc.negativePredicates

• where p1 is a predicate, p1 .Documents = {(P, λ): P = Bip1(doc1) for some i and some document constan

• where a and b are agents, TrustLevel(a, b) = i : Ti(a, b) ∈ KB

• CombinedBelief(i,j), value in the cell [i,j] of Table 4.2, representing the result of belief combination.

• TrustBelief(i,j), value in the cell [i,j] of Table 4.1, representing the result of combining other agent’s belief with the trust in that agent

Finally, when we assert a statement, we mean that the statement is currently believed by the agent: P =true denotes ∃λ :(P, λ) ∈ KB AND λ.status = on.

5.3 Reasoning Processes

An agent’s actions lead to maintaining a quality knowledge base. The purpose of the system is to classify available documents, inferring all possible statements of the form Bip1(doc1) and

Bj¬p2(doc2). Reasoning in the system is triggered when there is new information that needs to be assimilated, coming either from the user or from the outside agent. The particular response depends on the type of statement an agent receives.

5.3.1 Operations on the knowledge base

To support the purpose of an agent, we deﬁne several procedures aimed at maintaining the knowledge base. We here present several subroutines, which are then used by the main routines presented in Section 5.3.2.

57 - Adding a statement: addStatement, Procedure 1. This algorithm encapsulates the insertion of a new statement into knowledge base. The procedure accepts two arguments: a new statement St = (P, λ) and a list from, representing source of the information. The following actions are performed:

• Correct values are assigned to elements of a label λ. This includes the index value, status, to and from sets

• If the statement is derived, labels of premise statements are updated, adding the new statement to appropriate to sets

• Statement St is appended to the KB set.

Procedure 1: addNewStatement

Data: knowledge base KB Input: Statement St =(P, λ), Set from Result: updated KB begin λ.index := KB.maxindex + 1; λ.from := from; λ.to := empty; foreach (P1, λ1) ∈ from do λ1.to := λ1.to ∪ {St}; KB=KB ∪{St}; return St; end

- Determining a statement’s ancestors: getAncestors, Procedure 2. A statement’s ancestors are those statements that are encountered in the derivation of the statement. Procedure 2 takes a labeled statement (presumably already in the knowledge base) and returns a list of its ancestors. It uses a recursive deﬁnition of an ancestor: for St = (P, λ),

1. Statement S1 ∈ λ.from is an ancestor.

2. If S1 is an ancestor of St and S2 is an ancestor of S1, S2 is ancestor of St.

58 Procedure 2: getAncestors

Data: knowledge base KB Input: Statement St = (P, λ) Result: ancestors set begin res := {St}; if λ.from = { outside source } then return {St}; else foreach St1 ∈ λ.from do res := res ∪ getAncestors(St1); return res; end

3. No other statement is an ancestor of St.

- Determining a statement’s descendants: getDescendants, Procedure 3. Similarly, descendants for a statement St are all statements that depend on St, meaning their derivation path includes St. The procedure is similar to getAncestors. - Deleting a statement: deleteStatement, Procedure 4. This routine is called when a particular statement is no longer believed. The following steps are performed:

1. Statement’s status is set to oﬀ.

2. The list of statement’s descendants is obtained, using getDescendants.

3. For each statement in the list of descendants, the status is turned to oﬀ.

- Combining beliefs: beliefCombination, Procedure 5. This procedure is called whenever an agent encounters two statements expressing the same document classiﬁcation but with diﬀerent belief levels. Two statements are passed to the procedure as arguments. To reach the new belief level for the statement, the agent applies a belief combination rule as described in Section 4.5. The following steps are followed to adjust the knowledge base:

1. The value in Table 4.1 is used to determine the combined belief level, k.

59 Procedure 3: getDescendants

Data: knowledge base KB Input: Statement St = (P, λ) Result: Set descendants begin Set res = { St }; if λ.to = empty then return {St}; else foreach Statement St1 ∈ St.to do res := res ∪ getDescendants(St1); return res; end

Procedure 4: deleteStatement

Data: knowledge base KB Input: Statement St =(P, λ) Result: updated KB begin λ.status := oﬀ; foreach Statement St1 ∈ getDescendants(St) do deleteStatement(St1) end

2. The resulting value is compared with the two existing belief values.

3. If the new belief level is the same as the belief level of one of arguments, the other argument is removed using the deleteStatement procedure. The remaining statement is the result of the belief combination.

4. If the new belief level diﬀers from belief levels of both arguments, both arguments are removed using the deleteStatement procedure. Then, a new statement with the new belief level k is added to the KB using the addNewStatement procedure.

- Contradiction Removal: removeContradiction, Procedure 6. When a reasoning

60 Procedure 5: beliefCombination

Data: knowledge base KB

Input: Statement St1=(Bi(p(doc1), λ1), St2=(Bj(p1(doc1), λ2), i =6 j Result: updated KB, resulting statement St begin k := CombinedBelief(i,j); St := null; if i = k then St := St1; deleteStatement(St2); else if j = k then St := St2; deleteStatement(St1); else deleteStatement(St1); deleteStatement(St2); from := {St1, St2}; St := addNewStatement((Bk(p1(doc1), from); return St; end procedure discovers a contradiction, another belief revision process is triggered. We have set up the reasoning in such a way that a discovered contradiction will always take the form

B4(T opic1(doc1)) ∧B−4(T opic1(doc1)) or, equivalently, B4(T opic1(doc1) ∧ (¬T opic1(doc1))). The system will respond by removing (using deleteStatement) one taxonomic statement from the ancestors of the contradiction deemed least believed. In case there is more than one culprit with same belief level, the system will choose the statement whose ancestors have the least cumulative belief level, as determined by the following procedure leastValuable. - Least valuable statement leastValuable, Procedure 7. A subroutine for belief revision process, this procedure chooses the least valuable statement from the set Candidates passed to it. Statement P is more valuable than statement Q if the sum of belief levels of the ancestors of P is greater than the sum of belief levels of the ancestors of Q. The use of leastValuable helps the belief revision process achieve a form of informational economy. An agent strives to keep statements that are most ﬁrmly believed. If belief levels

61 Procedure 6: removeContradiction

Data: knowledge base KB Input: Statement St1=(P 1, λ1), St2=(P 2, λ2)

Note: P 1 and P 2 are contradictory document classifications, B4(T opic1(doc1)) and B−4(T opic1(doc1)) Result: updated KB begin culprits := getAncestors(St1) ∪ getAncestors(St2); to remove := ∅; cutoff := +∞; foreach St =(P, λ) ∈ culprits do if P.BeliefLevel < cutoff then cutoff := P.BeliefLevel; to remove := { St }; else if P.BeliefLevel = cutoff then to remove = to remove∪ { St };

deleteStatement(leastV aluable(toRemove)) end of two or more culprits are equal, the agent discards the statement that causes the least amount of statements to be disbelieved.

5.3.2 Purposeful reasoning

The principal inference process is triggered when there is a new statement for an agent to assimilate. This new statement comes either from the authorized user or from a trusted agent. In each case, an agent takes appropriate action, depending on the type of statement being processed. Procedure 8, triggerReasoning, represents the main entrance point of the process. When reacting to new input, the system will:

• Turn the input statement into a labeled tuple.

• If the input statement comes from another agent, combine that agent’s belief level and a present agent’s trust level in an agent, to obtain the present agent’s belief value for the statement.

62 Procedure 7: leastValuable

Data: knowledge base KB Input: Candidates ⊂ KB Result: least valuable statements among Candidates begin cutoff := ∞; foreach St ∈ Candidates do value := 0; cand := null; foreach St =(P, λ) ∈ getAncestors(Candidates) do value := value + P.BeliefLevel; if value < cutoff then cutoff := value; cand := St; return cand end

• Add the new statement to the Dynamic Reasoning System, invoking appropriate reasoning to compute consequences.

Procedure 9, newDocumentClassification, is invoked when an agent is given new document classification, identifying a specific document doc1 with a specific predicate symbol p1. Two auxiliary procedures, addPositiveConsequences and addNegativeConsequences, are used to deal with specific inference cases (see Table 5.1). The computational process can best be described as a recursive walk through the taxonomy. Steps are as follows:

• Check if the system already contains an identical statement. If it does, end procedure.

• Append the statement to the Dynamic Reasoning System list, using addNewStatement routine.

• If a conﬂicting belief level for the same classiﬁcation exists, invoke beliefCombination .

• If a contradiction is identiﬁed, call removeContradiction.

• Call addPositiveConsequences or addNegativeConsequences to infer further document classiﬁcations.

63 Procedure 8: triggerReasoning

Data: knowledge base KB Input: input statement Input , source Result: updated KB St =(P, λ) := new statement; P := Input; λ.from = es; if source = trusted agent then trust := Agents[source].TrustLevel; belief := P.BeliefLevel; P.BeliefLevel := TrustBelief(belief, trust); switch P do case taxonomic statement newT axonomyStatement(St, λ.from); case document classiﬁcation newDocumentClassification(St, λ.from); case trust statement newTrustStatement(St, λ.from);

Procedure 10, addPositiveConsequences and Procedure 11, addNegativeConsequences, encapsulate logical inference. Given an argument statement of the form Bip1(doc1) or

Bi¬p1(doc1), these procedures iterate through the list of taxonomic statements that contain the predicate symbol p1. If a taxonomic statement, combined with the argument, yields a new inferred statement, the procedures call newDocumentClassification with the inferred statement as an argument. Since Procedure 9 calls Procedures 10 and 11, we have an indirect recursive process traversing the taxonomy tree searching for possible inferences. The taxonomy tree that will guide the reasoning process is not explicitly represented in the knowledge base. In that tree, the nodes of the tree are all predicate and document literals in the system, while statements form the links. For the described inference procedure to be effective, we rely on an assumption that sets like P red.Statements are derived efficiently. In an implemented system, for example, an agent can store information on all predicates and document constants in a statement object, and each predicate symbol object can be associated with the list of all statements containing that symbol.

64 Procedure 9: newDocumentClassiﬁcation

Data: knowledge base KB

Input: input statement, St Bip1(doc1) , Set from Result: updated KB begin if St already in the KB then return ; addNewStatement(St,from); if this classiﬁcation exists with diﬀerent belief level, St1 ∈ KB then newSt := beliefCombination(St,St1); if newSt = St OR newSt = St1 then return ; else St := newSt; if contradicting statement St1 ∈ KB then beliefRevision(St,St1); if St1 ∈ KB then Note: new statement just got rejected; return ;

if St = Bip1(doc1) then addPositiveConsequences(St,from); else addNegativeConsequences(St,from); end

Adding new taxonomic statements also leads to computing new document classiﬁcations. Procedure 12, newTaxonomyStatement, shows the appropriate process. The basic algorithm involves the following:

• Add the new statement to the DRS.

• Based on the type of statement, identify document classiﬁcations that can lead to new inferences (see Table 5.1).

• For each such classiﬁcation statement, apply an appropriate rule.

• Invoke newDocumentClassiﬁcation for newly inferred statements.

65 Procedure 10: addPositiveConcequences

Data: knowledge base KB

Input: input statement, Bip1(doc1) Result: updated KB begin foreach St ∈ p1.Statements do fro := { St, Bip1(doc1) } switch St do case Bj(p1(x) → p2(x)) newDocumentClassification(Bmin(i,j)p2(doc1),fro)

case Bj(p1(x) →¬p2(x)) OR Bj(p2(x) →¬p1(x))) newDocumentClassification(Bmin(i,j)¬p2(doc1),fro)

case Bj(∀x(p1(x) → p2(x) ∨ p3(x)),fro) if Bk¬p3(doc1) then fro := fro ∨Bk¬p3(doc1) newDocumentClassification(Bmin(i,j,k)p2(doc1),fro)

if Bk¬p2(doc1) then fro := fro ∨Bk¬p2(doc1) newDocumentClassification(Bmin(i,j,k)p3(doc1),for)

case Bj(p1(x) ↔ (p2(x) ∧ p3(x))) newDocumentClassification(Bmin(i,j)p2(doc1),fro) newDocumentClassification(Bmin(i,j)p3(doc1),fro)

case Bj(p2(x) ↔ (p1(x) ∧ p3(x)) if Bkp3(doc1) then fro := fro ∨Bkp3(doc1) newDocumentClassification(Bmin(i,j,k)p2(doc1),fro)

end

As before, we rely on an assumption that the set of documents associated with a given predicate can be derived eﬃciently. This can be achieved by the use of appropriate data structures. Along with taxonomic information, an agent also maintains trust relations with other agents. We adopt a simplifying assumption that an agent only receives new statements from trusted agents. We also assume that change in trust in a particular agent does not automatically lead to a belief revision process involving all previously adopted knowledge.

66 Procedure 11: addNegativeConsequences

Data: knowledge base KB

Input: input statement, Bi¬p1(doc1) Result: updated KB begin foreach St ∈ p1.Statements do Set fro := { St, Bi¬p1(doc1) } switch St do case Bj(p2(x) → p1(x)) newDocumentClassification(Bmin(i,j)¬p2(doc1),fro)

case Bj(p2(x) → p1(x) ∨ p3(x)) if Bkp2(doc1) then fro := fro ∨Bkp2(doc1) newDocumentClassification(Bmin(i,j,k)p3(doc1),fro)

case Bj(p1(x) ↔ (p2(x) ∧ p3(x))) if Bkp3(doc1) then fro := fro ∨Bkp3(doc1) newDocumentClassification(Bmin(i,j,k)¬p2(doc1),fro)

if Bkp2(doc1) then fro := fro ∨Bkp2(doc1) newDocumentClassification(Bmin(i,j,k)¬p3(doc1),fro)

case Bj(p2(x) ↔ (p1(x) ∧ p3(x)))) newDocumentClassification(Bmin(i,j)¬p2(doc1),fro)

end

If such trust revision is desired by users, then one can invoke an algorithm similar to belief revision procedures deﬁned above. Procedure 13, newTrustStatement, takes an acquired trust statement as input. We assume that a denotes the agent doing reasoning. Given a previously unknown statement

Ti(a1, a2) and assuming that the statement of the form Tj(a, a1) is already in the KB, the procedure arrives at the new statement Tmin[i,j](a, a2). This conclusion follows from (S11) and Modus Ponens.

67 Procedure 12: newTaxonomyStatement

Data: knowledge base KB Input: input statement St, Set from Result: updated KB begin addNewStatement(St, from) switch St do case Bj(p1(x) → p2(x)) foreach doc1 where Bjp1(doc1) do fro := { St, Bjp1(doc1) } newDocumentClassification(Bmin(i,j)p2(doc1),fro)

foreach doc1 where Bj¬p2(doc1) do fro := { St, Bj¬p2(doc1) } newDocumentClassification(Bmin(i,j)¬p1(doc1),fro)

case Bj(p1(x) →¬p2(x)) foreach doc1 where Bjp1(doc1) do fro := { St, Bjp1(doc1)

newDocumentClassification(Bmin(i,j)¬p2(doc1),fro)

foreach doc1 where Bjp2(doc1) do fro := { St, Bjp2(doc1) } newDocumentClassification(Bmin(i,j)¬p1(doc1),fro)

case Bj(p2(x) → p1(x) ∨ p3(x)) foreach doc1 where Bjp1(doc1) and Bk¬p3(doc1) do fro := { St, Bjp1(doc1), Bk¬p2(doc1) } newDocumentClassification(Bmin(i,j,k)p3(doc1),fro)

case Bj(p2(x) ↔ p1(x) ∧ p3(x)) foreach doc1 where Bj¬p3(doc1) or Bj¬p1(doc1) do fro := { St, Bj¬p1(doc1) (or Bj¬p3(doc1)) } newDocumentClassification(Bmin(i,j,k)¬p2(doc1),fro)

foreach doc1 where Bjp1(doc1) do fro := { St, Bj¬p1(doc1) } newDocumentClassification(Bmin(i,j)¬p2(doc1),fro) newDocumentClassification(Bmin(i,j)¬p3(doc1),fro) end

68 Procedure 13: newTrustStatement

Data: knowledge base KB

Input: input statement St = Ti(a1, a2), Set from Result: updated KB begin addNewStatement(St, {ec}); trust level = min(i,TrustLevel(a, a1); addNewStatement(Ttrust level(a, a2), {St})); end

69 CHAPTER 6

IMPLEMENTATION CONSIDERATIONS

To illustrate the feasibility of our approach, we present a general architecture for a possible implementation for a collaborative bibliographic database. We start with the domain model, reiterating the foregoing abstract model above in object-oriented terms. Then, we propose an object-oriented decomposition for implementation of the algorithms described in Chapter 5. We follow by presenting the data model to support storage needs for a system. Finally, we propose an ontology to export the data as RDF datasets. 6.1 Domain Model

The following entities form a vocabulary of the bibliographic domain:

• Document - represents a single bibliographical entry. In the formal logical model presented in Chapter 5, documents were represented by individual constants.

• Topic - represents a category of documents. The logical model used unary predicate symbols for topics.

• Agent - represents a user of the system. Agents have a dual role:

1. To serve as a representation of a reasoning process, encapsulating the single knowledge base and reasoning process.

2. To act as labels in link and document records, identifying the source of information.

• Statement - represents a unit of knowledge in a knowledge base. In accordance with the discussion in Chapter 5, we have:

70 Figure 6.1: Top-level domain objects

– TaxonomyLink - representing a relationship between topics, corresponding to taxonomic statements. There are several types of such links, corresponding to the diﬀerent types of statements the knowledge base supports:

∗ Subtype link ∗ Disjoint (or Negation) link ∗ Or-deﬁnition link ∗ And-deﬁnition link

– TrustLink - a link between agents, representing a trust relation

– DocumentClassiﬁcation - linking a document and topic

Figure 6.1 provides a snapshot of the associations that exist between the entities enumerated.

71 Figure 6.2: Classes representing elements of KB

6.2 Object-Oriented Decomposition

In this section, we develop a more detailed object-oriented model for the system. The main goal is to support the reasoning processes described in Section 5, providing the most natural functional decomposition between classes. We also discuss the data structures that are needed to support eﬀective execution of the algorithms. The following objects represent entities in an agent’s knowledge base:

• StoredEntity. This is the base class for all knowledge base elements. The code deﬁned in this class supports a mechanism for permanent storage of the information.

• Agent. This class will represent a user in his role of information supplier and consumer. An agent object is identiﬁed by its symbolic label and is linked to an object storing user-speciﬁc information (login account, session info, etc.) not discussed here.

72 • Document. This class represents a speciﬁc bibliographic resource: a paper, a book, technical report, news article, media ﬁle, or Web resource. The only data element essential for reasoning support is, again, the document’s symbolic label. From the user’s point of view, relevant document data include:

– Title

– Author

– Document type

– Publisher

– Publication venue

– Date of publication

– ... and other bibliographic information.

Additionally, a document object will contain links to all document classification statements (positive or negative) that exist in the agent’s knowledge base. It will achieve this by having an associative array of references to the KB’s document classification statements. This will help reasoning procedures to run in a reasonable time. For example, when a new document classification is introduced, an agent will be able to determine if there is a need for a belief combination or belief revision step in linear time.

• Statement. Objects of this type will represent labeled statements in the agent’s knowledge base. The following data is common for all subtypes of a Statement:

– Agent name

– Belief level

– Timestamp, determining statement’s position in the derivation path

– From list - list of links to statements used in deriving this statement, or the constant external source.

– To list - list of links to statements immediately derived from the statement

73 The specific content of a statement is defined in that Statement’s subclasses. A Statement class contains an abstract addToKb method, taking a knowledge base object (of the AgentKB class) as an argument. Subclasses redefine this method, implementing the agent’s behavior specific to an event of adding a statement of a given type.

• DocClassiﬁcationStatement. This class represents a document classiﬁcation state-

ment, Bip1(doc1) or Bi¬p1(doc1). Speciﬁc data elements include a ﬂag to denote the statement type (positive or negative) and a link to a Document object.

• TrustRelStatement. Represents a trust statement, Ti(a1, a2). The speciﬁc data elements include two agent labels. The belief level data member inherited from the Statement class is interpreted as a trust level.

• TaxonomyLinkStatement A superclass for classes that represent taxonomy statements (as per Section 5.2). Subtypes are deﬁned to reﬂect types of taxonomy statements:

– SubtypeStatement: for a subtype statement, Bi(p1(x) → p2(x))

– DisjointStatement: for a disjoint statement, Bi(p1(x) →¬p2(x))

– OrDefStatement: for a or-deﬁnition statement, Bi(p1(x) → p2(x) ∨ p3(x))

– AndDefStatement: for an and-deﬁnition statement, Bi(p1(x) ↔ p2(x) ∧ p3(x))

The TaxonomyLinkStatement class defines an additional method, MakeInference, taking a DocClassificationStatement object and an AgentKB object as parameters. This method is re-defined in subclasses and is intended to apply a reasoning rule of a kind defined in Table 5.1.

The reasoning process for a single agent is encapsulated in an object of the AgentKB class. Data members of this class represent domain objects as shown in Figure 6.1. Namely, the following collections are members of AgentKB:

• Agents

• Documents

74 • Statements

An AgentKB object’s responsibilities include:

• addNewStatement, deleteStatement, getAncestors, getDescendants - utility methods that support operations on the knowledge base (see Section 5.3.1).

• addAgent, addDocument, getAgent, getDocument - accessor methods for corresponding collections.

• beliefCombination - a procedure called when there is a need to reconcile two document classifications with different belief values. To support greater flexibility, the AgentKB class may delegate this operation to a separate BeliefCombinator class, implementing the Strategy design pattern [G95]. This facilitates using different belief combination strategies in addition to the one defined in Sections 4.5 and 5.3.1.

• removeContradiction - a procedure called when two contradictory document classifications are detected. An auxiliary procedure leastValuable can be defined as a private method. This method can be delegated to a ContradictionRemover class, to support multiple strategies in addition to the one defined in Section 5.3.1.

• triggerReasoning - a procedure called when a new input is available. As described in Section 5.3.2, this method will:

1. Construct the correct statement type.

2. If a statement came from an external source, determine the agent’s degree of belief in the statement.

3. Delegate further processing to the addToKB method, thus adding all the consequences for a statement to the KB. In turn, the method addToKB of the TaxonomyLinkStatement and DocClassiﬁcationStatement classes will call the TaxonomyLinkStatement.MakeInference as appropriate. In eﬀect, the switch statements that are used in the formal procedures addPositiveConse- quences, addNegativeConsequences and newTaxonomyStatement will be replaced by polymorphic calls.

75 Table 6.1: Assigning responsibility to classes.

Operation (section 5.3) Class(es) and method(s) addNewStatement AgentKB.addNewStatement deleteStatement AgentKB.deleteStatement getAncestors AgentKB.getAncestors getDescendants AgentKB.getDescendants beliefCombination AgentKB.beliefCombination; BeliefCombinator.getCombinedBelief removeContradiction AgentKB.removeContradiction; ContradictionRemover.remove leastValuable ContradictionRemover.leastValuable (private method) triggerReasoning AgentKB.triggerReasoning newDocumentClassiﬁcation DocClassiﬁcationStatement.addToKB, TaxonomyStatement.MakeInference newTaxonomyStatement TaxonomyStatement.addToKB, TaxonomyStatement.MakeInference newTrustStatement TrustRelStatement.addToKB

In addition to the operations described in Section 5.3, methods of the AgentKB class will maintain appropriate links between objects. For example, adding a new document classification statement will locate a document object and update it’s “topics” list with the entry for a new statement. Table 6.1 reflects the separation of reasoning responsibilities between classes. In addition, classes can have other responsibilities - participate in responding to queries, support database persistance mechanism, or implement data export to various text formats (including XML/RDF syntax). Appropriate methods can be defined in latter stages of system analysis and design.

6.3 Data Model

Persistent storage of structured information is usually implemented using a relational database management system. Conceptual and object-oriented models should be mapped to RDBMS tables and indexes. Figure 6.3 presents a database model that reﬂects our conceptual structure. We use a version of entity-relationship notation supported by Microsoft Visio for Windows. Arrow

76 Figure 6.3: First iteration database model

77 connectors represent database relations, Notations PK, PK1, PK2, ... mean that a given table attribute is a primary key, FK, FK1, FK2, ... denote foren keys. An attrubutecan be a foreign key and (a component of) primary key for a given table. The tables defined can be mapped to the classes introduced in Section 6.2. The Statement table corresponds to the abstract base class and contains attributes common to all types of statements in the knowledge base. Other tables representing statements have a one-to-one relationship with Statement and contain attributes specific to the subclasses. Database views can be defined to represent such derivative objects, including common Statement attributes. Statement subtypes link to other database objects: Agent, Document and Topic. Table TopicLinks is a technical table used to support many-to-many relationship between a Statement and a Topic, as required to support And-Definition and Or-Definition statements. The database model described above adequately reflects the domain and can be used when developing the software implementation. Direct mapping from objects to tables facilitates the design of object-to-relational mappings and thus the initial development process can be relatively straightforward. However, several potential problems can be readily identified:

• Adding new types of statements, classes of individual constants and predicate symbols require redesign of a database scheme. While a set of 6 statement types and associated inference algorithms presented in Chapter 5 is adequate for representing document classiﬁcations, the logical language and underlying formalism allows for deﬁning other meaningful statement types.

• Developers may want to allow a user to perform certain common operations with domain objects: create, delete, share with others, and combine in taxonomies. It is conceivable that a taxonomy can have other taxonomies as parts, though the practicality of such an approach demands additional investigation. Objects are subject to change tracking and permission management, and in this regard there is no diﬀerence between Documents, Statements, and Taxonomies. 6.4 Metadata design patterns

The object-oriented design community adopted a concept of design patterns, borrowed from the architectural design [A77]. Design patterns are semi-formal, systematic descriptions of the solutions for common design problems. They show a particular, commonly occurring,

78 problem in a specific context and then describe a proven method for solving such a problem. The goal of patterns is to increase the quality of design, namely maintainability and extensibility, by communicating best industry practices. Among the commonly used patterns in object-oriented design are Model-View-Controller for flexible user interface, and Factory, which suggests encapsulating object creation to a special class to avoid relying on the type information when creating objects in runtime. One of the best known catalogues of pattern is the book by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, titled Design Patterns: Elements of Reusable Object-Oriented Software. Often referred as the ”Gang of Four book” (or GoF), the book became common starting point when discussing patterns. GoF contains 23 popular patterns used in object-oriented software design. Below is the short description of the structural pattern Composite from the GoF, which we below adapt to our metadata schema needs.(see Figure 6.4). On this figure, we use static model UML notation. Arrow connectors denote inheritance, while diamond connectors denote aggregation.

Name: Composite Task description: Supports tree-like structures, where an object representing group of objects ca be treated like an individual object. Classic example is UNIX file system, where file directories are treated as files. Context:

• In many applications, tree-like structures arise, where groups of elements can be elements of the bigger structure.

• All element objects have similar behavior. As an example, consider a typical graphical user interface. All elements are rectangular areas drawn on the screen, and they all respond to user generated events. The same is true for frames and windows.

Participating classes:

• Component: A common superclass for Leafs and Composite, having interface that allows an object to be a component of the Composite.

• Leaf: Subclass of Component representing simple objects.

79 • Composite: A Component that .contains collection of other Components. Thanks to polymorphism, both Leaves and Composites can be components of a Composite object.

Results:

• It is easier to add new types of components.

• A client program’s architecture is simpliﬁed: the same logic can work with simple and composite objects.

• Any client that works with simple objects can also work with composites. is a requirement.

Related patterns: The GoF patterns Decorator, Flyweight and Iterator.

Metadata schemas, like software in general, have two facets. First, they are meant to naturally represent those aspects of a specific domain that are important for users. Second, they are dictated by the architecture of the software system they are part of and constrained by various technological requirements. Design patterns are meant to address the second facet, addressing nonfunctional requirements like extensibility, maintainability and performance. In [US05], we discuss the use of object-oriented design patterns in defining metadata models, using a variation of the application domain described here. We showed how two patterns, Composite and History, can be used in improving the characteristic of a data model. The two patterns are combined, resulting in the data model depicted in Figure 2.2. The two design patterns complement each other: Composite pattern allows treating taxonomy elements uniformly, while History solves change management issues for unified metadata pieces. Each pattern facilitates the other in achieving its advantages. This schema supports a dynamic metadata management system. Metadata is stored in relational database. Classes are implemented as tables. Inheritance is implemented as a one-to-one relationship. Stored procedures are used for querying Taxonomy classes, allowing merging an Entity table with an appropriate subclass table. Using object-oriented approaches and patterns has been shown to be a useful metaphor for metadata construction. Along with improving metadata architecture maintainability and extensibility, using patterns for metadata facilitates software design that uses similar

80 Figure 6.4: GoF Composite pattern (from [G95]))

principles. The envisioned system would be implemented using an object-oriented platform, e.g. Enterprise Java technologies or Microsoft .NET, and would export its functionality through a Web Service . In creating the software architecture, we use object oriented design patterns. Pattern based metadata architecture has supported an object oriented design of the software. Business logic components mapped to the taxonomy follow a classic Composite architecture, adding behavior to the data model. History pattern supports multi-user collaboration

81 Figure 6.5: Applying the Composite pattern

logic. Software components for data access can be designed using Model-View-Controller architecture, with versioning support along the lines of the ”Gang of Four” [G95] Command pattern, which is structurally similar to History. Figure 6.5 shows the data model redesigned using the Composite pattern. A knowledge base, in essence, is deﬁned as a collection of Entities. Using the vocabulary of the Composite pattern as used in the GoF book, Entity is the Component class, and Topics, Documents and Agents are Leafs. The Agent table also represents an entire taxonomy in the agent’s knowledge base, thus serving as the Composite. It is the responsibility of an Entity to deﬁne data for common functionality like versioning and access control. Mapping the resulting tables back to the domain objects is left to the business logic layer implemented either as an object-relational mapping framework or as stored procedures and views. Results from applying the Composite pattern to the data model design, both positive and negative, include:

• The database schema is visibly smaller and simpler.

• Adding new statement types does not affect the database schema. Adding new predicate classes and individual constant types may require adding new tables and business logic routines. Such system expansion does not, in principle, affect the data already in the system and thus can be achieved “on-the-fly”.

82 Figure 6.6: History pattern

• The database can handle multiple conceptual models and inference mechanisms. It does not depend on the conceptualization described in Chapter 5.

• A more sophisticated middle tier logic is required. The database loses information about permissible types of relationships between objects. Integrity checks must now be performed at the middle tier.

For addressing change management requirements, in [US05] we introduce the History design pattern (Figure 6.5). This pattern explicitly represents change by introducing the new class we call Event. It decouples changes from entities to which the changes are being made and allows managing changes as ﬁrst-class objects. The pattern is deﬁned as follows: Name: History Task description: Support versioning and change management in metadata. Context:

• Changes occur by inserting and deleting elements of metadata describing the domain or changing some elements content (e.g., textual description).

83 • Metadata consists of atomic elements. Taxonomy data is the characteristic example.

• Diﬀerent versions might co-exist.

Participating classes:

• Entity: A metadata element representing an atomic piece of metadata to manage. In the context of our application, Entity might represent a concept, a relationship, or a label.

• Subject: A metadata element representing a user-entity (e.g., a human user, a group, or a mechanical agent) initiating the change.

• HistoryEvent: A metadata element representing a change that has occurred to the model.

Results:

• Versions are defined both by the timestamp and the user. At any given time, different users might have different views to the same model. The view is affected by the users group membership and relationships between groups. This allows for flexibility and is a great asset in a collaborative environment where global consensus is unlikely or undesirable. (We assume this is true for the bibliographic system we describe.)

• Events are managed as ﬁrst-order objects.

• Querying for versions can become computationally expensive.

• While the schema gains very little in complexity, actual data can become hard for humans to analyze. This is alleviated by the availability of utility software but can potentially become a problem if human readability is a requirement.

Related patterns: The GoF pattern Command is close to History in structure and intent, although it focuses on behavior aspects not relevant to data models. Unlike History, Command does not address collaboration and multiple simultaneous versions.

84 Figure 6.7: Combining patterns

The Composite and History patterns are combined, resulting in the data model depicted in Figure 6.7. Note how the two patterns complement each other in this design: The Composite pattern allows treating taxonomy elements uniformly, while History solves change management issues for uniﬁed data elements. Each pattern facilitates the other in achieving its advantages. The resulting schema provides ﬂexibility and extensibility that is lacking from the original design.

6.5 External Representation

One of the goals of the Semantic Web is to enable software agents to exchange information, combining their functionality in unexpected ways. To allow heterogeneous agents to communicate meaningfully, they must adhere to the agreed-upon language to express information they are willing to share. In addition to the common syntax, the meaning of the data must be explicitly expressed and commonly understood. A way to achieve such interoperability involves the use of expressive languages (RDF/OWL) and deﬁning shared ontologies, as described in Chapter 3. Several existing ontologies cover domains related to bibliographic information systems. It is prudent for the system we present to adopt existing vocabularies, extending them as needed to express the full contents of its data storage.

85 RDF/XML allows using multiple vocabularies to describe a single resource. To identify an object on the Semantic Web, the Universal Resource Identifier (URI) is used. For the purpose of this chapter, we construct a simple URI scheme. Our URIs will consist of a “libagent:” prefix, followed by the resource type (document:, topic:, agent:, statement:), followed by an alphanumeric identifier that can be used to identify an object in a database. For example, libagent:document:12345 is a valid URI of a document object, provided that “1234” is a unique identifier present in the database. A complete identifier infrastructure for locating and retrieving distributed bibliography data is not covered in this dissertation. In RDF, shared vocabularies are available on the Web. An ontology is encoded as an OWL or RDF/S document and is published on a publicly known Web site. In the RDF document, ontology elements are referred to using XML namespaces, with an ontology document’s URL serving as a namespace name. Assume that we published the OWL document “http://libagent.org/schema/v1.0.1/libagent.owl”, defining all the unique types and relations we need to express the data we want to share. Then, the RDF file exported by our system will start with the tag

...

In the exported document, data elements defined in the libagent.owl ontology will be identified by the lag: namespace prefix. A Dublin Core Metadata Element Set (DC) [ANSI06] is a simple controlled vocabulary for describing information resources. It provides 15 broad elements commonly used to provide metadata for document storage. DC metadata can be expressed using HTML, XML or RDF tags. Combined with other ontologies, the DC provides a solid basis for metadata interoperability. We use DC elements to allow metadata exposed by our repository be

86 harvested and aggregated with information from other sources. A document metadata example follows: Dynamic reasoning with qualified syllogisms Abstract here

The Friend of a Friend (FOAF) [D04] vocabulary is an RDF format for representing people and their activities and relationships on the Web. FOAF has become a de-facto standard for representing social networks. Particularly relevant for our purposes are the following FOAF classes and properties:

• foaf:Agent - a class representing a natural or artiﬁcial agent, i.e. an entity that can perform actions. Our system can deﬁne a subclass of foaf:Agent in case the users need to distinguish statements made by a user from ones inferred by the system.

• foaf:Person - a subclass of an Agent that represents a person. Individuals of this class can represent users of a system and help identify individual taxonomies.

87 • foaf:knows - a property that identifies a social link between two Agents. Explicit trust declarations can imply acquaintance that can be expressed using foaf:knows. Several subproperties have been defined to identify the specific types of human relationships.

A FOAF Trust module [V02] provides a small vocabulary to express trust in FOAF ﬁles. Namely, it deﬁnes several property types to denote a level of trust:

• trustsNever (−∞)

• trustsNone (0)

• trustsMinimally (1)

• trustsAveragely (2)

• trustsHighly (3)

• trustsImplicitly (∞)

This vocabulary, together with FOAF, can successfully express trust relationships that exist in our system. To illustrate:

88 Simple Knowledge Organization Systems (SKOS) [MB07] is “an area of work developing speciﬁcations and standards to support the use of knowledge organization systems (KOS) such as thesauri, classiﬁcation schemes, subject heading systems and taxonomies within the framework of the Semantic Web”. The bulk of the data contained in our system is, in fact, topic taxonomies. We can use a subset of SKOS vocabulary to export our data:

• skos:ConceptScheme - provides a way to refer to a taxonomy as a whole. We will use this class to establish a link between a taxonomy and an agent (user).

• skos:Concept - corresponds to a topic predicate in our model.

• skos:broader, skos:narrower - expresses relations that we express as subtype statements.

The SKOS vocabulary allows expressing a subset of taxonomic information suﬃcient for exporting meaningful taxonomies, even though it is insuﬃcient to export the full set of statements that we use. The following gives an example of exported taxonomic data:

CS AI

As one can see, much of the information in the collaborative bibliographic information system can be expressed using existing, publicly available vocabularies. Exporting knowledge using known vocabularies promotes interoperability on the Semantic Web. To express

89 Figure 6.8: Partial model of SKOS vocabulary

knowledge unique to our system, we define new classes and properties. Publishing our vocabulary on the Web can enable future applications to make use of the full spectrum of knowledge generated by the collaborative system. It is necessary to define symbols to express degrees of belief. Following the FOAF trust module, we may define the following properties linking an Agent with a statement:

• lag:BelievesCompletely,

• lag:BelievesHighly,

90 Table 6.2: Additional data elements.

Name Subclass of Description lag:disjoint skos:semanticRelation Relates disjoint concepts lag:DefStatement skos:semanticRelation Superclass for Or-definition and And-Definition lag:lside, lag:rside rdf:Property Left and right sides of a statement lag:OrDefStatement lag:DefStatement Or-Definition Statement lag:AndDefStatement lag:DefStatement And-Definition Statement lag:BelievesCompletely, ... lag:DisbelievesCompletely Belief levels

• lag:BelievesAveragely,

• lag:BelievesModerately,

• lag:BelievesAmbivalent,

• lag:DisbelievesModerately, and so on.

We can use an RDF Reiﬁcation vocabulary to denote belief levels for SKOS relations:

We will also require a vocabulary to express statements other than a Subtype. A Disjoint statement can be expressed as a binary predicate and hence can be modeled using a property, which we name lag:disjoint. Trust statements are adequately expressible using a FOAF Trust module. For the two other taxonomy types, we deﬁne separate classes. For example, an Or- Deﬁnition statement might be expressed as follows:

Table 6.2 lists additional vocabulary elements we need to fully express our taxonomic data. As can be seen, one can use a very limited set of new terms, relying instead on commonly known vocabularies.

92 CHAPTER 7

CONCLUSION

Modern information systems promise easy access to vast amounts of information. The Semantic Web and Web 2.0 provide a rich information environment, allowing people and machines to collaborate and exchange information. Judging reliability of distributed information therefore becomes a necessity. The goal of this research has been to design a complete multiagent system operating on the Web of Trust by extending existing approaches to reasoning and reason maintenance to support explicit handling of belief and trust, suitable for supporting the semantic Web of Trust. Our starting point was the logic for agent-oriented epistemic reasoning proposed by Schwartz [S03]. We extended this logical framework with a support for multiple agents and the notion of trust. The result was a formal logic language, complete with a clear semantics and plausible rules for belief and trust combination. We used the previously described notion of the Dynamic Reasoning System (DRS) [S97] to provide means of modeling an agent’s inference process, allowing it to address conflicting and contradictory information. Two situations of belief revision are identified: one requiring simple belief combination to arrive at a new belief level and one that requires removing a formula that leads to a contradiction. The description of these formalisms is found in Chapter 3. As a next step, we described a potential application for our formalisms: a collaborative, multi-user bibliographic database. The defining feature of the proposed system is that the users define their own classification taxonomies and contribute their own document classifications. Human users interact with software agents that represent them. In turn, agents can get information from each other, extending users’ taxonomies and enhancing search capabilities. Agents can use trust relations to establish their individual belief levels assigned to taxonomy links and to perform necessary belief revision. We provide a high-level

93 description of the envisioned system in Chapter 2. Armed with logical formalism and problem understanding, we proceeded to introduce, in Chapter 5, a formal reasoning system capable of dealing with bibliographic taxonomies. We described an agent with a knowledge base of taxonomic data stored in a DRS. We limited our logic language to five types of statements sufficient to express rich taxonomic structures. We then defined procedures an agent may use to achieve it’s goal: to adopt new information while maintaining the quality of the knowledge base. When given new data, the agent will derive all document classifications this new information entail. It will also identify and address all evident contradictions. Procedures for belief revision are defined, implementing a discrete version of the principle of informational economy. Based on a formal agent definition, in Chapter 6 a general architecture for a possible implementation for the collaborative bibliographic database. We present a domain model for the reasoning agent. Then, we propose a more detailed object-oriented model that supports reasoning procedures defined in Chapter 5. We design a flexible database model for the system, using design patterns to support collaboration and data evolution. Finally, we show the data vocabulary that allows exporting the taxonomic data to the broader Semantic Web. The vocabulary we use heavily relies on existing, recognized ontologies. Using commonly known ontologies promotes interoperability, which is among the main goals of the Semantic Web.

94 APPENDIX A

Publications

The following papers have been presented at conferences and published in proceedings:

• Stanislav Ustymenko, Ontology-Supported Sharing and Reuse of Knowledge in Di- verse Environments, in Proceedings of 43rd Annual ACM Southeast Conference (ACMSE’05), March 18-20, 2006, Kennesaw, GA

• Stanislav Ustymenko, On Merging User-supplied Topic Ontologies on the Semantic Web, in Proceedings of 44th Annual ACM Southeast Conference (ACMSE’06), March 10-12, 2006, Melbourne, FL

• Stanislav Ustymenko, Daniel G. Schwartz, Applying Object-Oriented Metaphors and Design Patterns in Deﬁning Semantic Metadata, in Proceedings of the First on-Line conference on Metadata and Semantics Research (MTSR’05) , November 21-30, 2005

• Stanislav Ustymenko, Daniel G. Schwartz, An Agent-Oriented Logic for Reasoning about Belief and Trust, IEEE Workshop on Engineering Semantic Agent Systems, in Proceedings of 30th IEEE Annual International Computer Software and Applications Conference, pp. 321-326, September 17-21, 2006, Chicago, IL

• Stanislav Ustymenko, Daniel G. Schwartz, Online Communities and Online Repos- itories: Improving Digital Libraries by Collaborative Ontology-Based Filtering, in Proceedings of International e-Conference on Computer Science, July 01-08, 2006

Extended versions of two papers were submitted to international journals:

• Stanislav Ustymenko, Daniel Schwartz, An Agent-Oriented Logic for Belief and Trust, accepted for publication in Multiagent and Grid Systems - An International Journal.

95 • Stanislav Ustymenko, Daniel Schwartz, Applying Object-Oriented Metaphors and Design Patterns in Deﬁning Semantic Metadata Schemata, submitted for review to Applied Ontology:An Interdisciplinary Journal of Ontological Analysis and Conceptual Modeling

A paper was submitted to conference and is currently under review:

• Stanislav Ustymenko, Daniel Schwartz, Architecture For Belief Revision In Multi- Agent Intelligent Systems, submitted for review to the International Conference on Systems, Computing Sciences and Software Engineering

96 REFERENCES

[A65] Adams, E. W. 1965. The logic of conditionals, Inquiry 8: 166-97.

[A75] Adams, E. W. 1975. The Logic of Conditionals. Dordrecht: Reidel.

[A74] Adams, E. W. The logic of ”almost all”, J. Philos. Logic 3, 1974

[ADL06] ADL Sharable Courseware Object Reference Model, SCORM http://www.adlnet.org/

[A77] Alexander, C., Ishikawa, S., Silverstein, M., Jacobson, M., Fiksdahl-King, I., Angel, S. A Pattern Language. Oxford University Press, New York, 1977

[AJL02] Anderson, K. G., Jeﬀery, A., Lopatenko, S. (2002), CERIF: Past, Present and Future: An Overview. In Gaining Insight from Research Information, 6th International Conference on Current Research Information Systems, August 29-31, 2002 in Kassel, Germany [ANSI06] ANSI/NISO Z39.85 -2007 The Dublin Core Metadata Element Set, http://www.niso.org/standards/standard detail.cfm?std id=725

[A97] Antoniou, G., Nonmonotonic reasoning, MIT Press, Cambridge, MA, 1997.

[B03] Baader, F., Calvanese, D., McGuinness, D., Nardi, D., Patel-Schneider. P. (eds.) (2003), The Description Logic Handbook, Cambridge University Press, 2003.

[B90] Bacchus, F., Representing and Reasoning with Probabilistic Knowledge: A Logical Approach to Probabilities, MIT Press, Cambridge, MA 1990

[B89] Bacchus, F., Lp: A Logic for Statistical Information. in Proceedings of UAI 1989: 3-14

[B93] Bacchus, F., Grove, A., Halpern, J., Koller, D., Statistical Foundations for Default Reasoning, in Proceedings of the JCAI’93

[B01] Bechhofer, S., Horrocks, I., Goble, C., Stevens, R. OilEd: a Reason-able Ontology Editor for the Semantic Web. In Proceedings of KI2001, Joint German/Austrian conference on Artiﬁcial Intelligence, September 19-21, Vienna. Springer-Verlag LNAI Vol. 2174, pp 396–408. 2001

97 [BL98] Bernes-Lee, T., Semantic Web road map, Sept. 1998. http://www.w3.org/DesignIssues/Semantic.htm [BHL01] Bernes-Lee, T., Hendler, J., Lassila, O., The Semantic Web. Scientific American, May 2001. [B89a] Borgida, A., Brachman, R.J., McGuiness, D.L., Resnick, L.A. (1989), CLASSIC: A Structural Data Model for Objects, In: Proc. of the 1989 ACM SIGMOD International Conference on Management of Data, Portland, Oregon, May-June, 1989. [BFH96] Boutilier, C., Friedman, N., Halpern, J. Y. ”Belief revision with unreliable obser- vations”. In: Proceedings of the fifteenth national conference on Artificial Intelligence (AAAI’96),pp. 127-134. [CBH92] Cohen W.W., A. Borgida, H. Hirsh. Computing least common subsumers in description logics. Proc. AAAI-92, San Jose, California, 1992 [BG04] Brickley, D., Guha, R. V., eds., RDF Vocabulary Description Language 1.0: RDF Schema. W3C Recommendation 10 February 2004. [DOS03] Daconta, M. C., Obrst, L. J., Smith, K. T., The Semantic Web: A Guide to the Future of XML, Web Services, and Knowledge Management, Wiley, 2003. [D93] Darvishe, A. Y., A symbolic generalization of probability theory, Ph.D. Dissertation, Stanford University 1993 [DFH03] Davies, J., Fensel, D., van Harmelen, F., eds., Towards the Semantic Web: Ontology-Driven Knowledge Management. John Wiley and Sons, Ltd., 2003 [D99] Decker, S., Erdmann, M., Fensel, D., Studer, R., Ontobroker: Ontology based access to distributed and semi-structured information. In R. Meersman et al., editor, DS-8: Semantic Issues in Multimedia Systems. Kluwer, 1999. [D03] Di Noia, T., Di Sciascio, E., Donini, F. M., Mongiello, M., A system for principled matchmaking in an electronic marketplace, in Proceedings of the 12th International Conference on World Wide Web, 2003. [D04] Dodd, L., An introduction to FOAF, February 04, 2004, http://www.foaf- project.org/2004/us/about.html [D94] F. Döring, On the probabilities of conditionals, Philosophical Reviews 103 (1994) 689–700. [D03a] Douglas, I., Nowicki, C., Butler, J., Shaffer, S., Web-based collaborative analysis, reuse and sharing of human performance objects. In Interservice/Industry Training, Simulation and Education Conference (I/ITSEC), Orlando, Florida, December 2003. [D01] Douglas, I. Instructional design based on reusable learning objects: applying lessons of object oriented software engineering to learning systems design. 31st ASEE/IEEE Frontiers in Education Conference, October 10 - 13, 2001 Reno, NV

98 [D79] Doyle, J. A truth maintenance system, Artiﬁcial Intelligence 12(3) (1979) 231272.

[DP88] Dubois, D., and Prade, H., Possibility Theory: An Approach to Computerized Processing of Uncertainty (Plenum Press, New York, 1988).

[DP91a] Dubois, D., Prade, H., Conditional objects and non-monotonic reasoning, in: Proceedings of the Second International Conference on Knowledge Representation and Reasoning, KR’91, Cambridge, MA (April 22–25, 1991) 175–185.

[DP91b] Dubois, D., and Prade, H., Conditioning, nonmonotonic logic and nonstandard uncertainty models, in: I.R. Goodman, M.M. Gupta, H.T. Nguyen, and G.S. Rogers, eds., Conditional Logic in Expert Systems (Elsevier, New York, 1991) 115–158. [F95] Fagin, R., Halpern, J., Moses, Y., Vardi, M. Reasoning about knowledge, MIT Press, Cambridge, MA, 1995

[FHR96] Farquhar, A., Fikes, R., Rice, J. The Ontolingua server: A tool for collaborative ontology construction. Technical report, Stanford KSL 96-26, 1996 [FHH04] Fikes, R., Hayes, P., Horrocks, I. OWL-QL - a language for deductive query answering on the Semantic Web. J. of Web Semantics, 2(1):19-29, 2004.

[G95] Gamma, E., Helm, R., Johnson, R., Vlissides, J. Design Patterns. Elements of Reusable Object-Oriented Software. Addison Wesley, 1995 [G92a] Galliers, J. R., Autonomous belief revision and communication. In: Gardenfors, P. (ed.), Belief revision, Cambridge University Press, Cambridge (MA), pp. 220-246., 1992

[G88] Gardenfors, P., Knowledge in ﬂux: modeling the dynamics of epistemic states, MIT Press/Bradford Books, Cambridge, MA, 1988. [G92b] Gardenfors, P., Belief revision: an introduction, in Gardenfors, P., ed., Belief revision, Cambridge University Press, New York, 1992, pp. 1-28.

[G92c] Geﬀner, H., Default Reasoning: Causal and Conditional Theories, MIT Press, Cambridge MA 1992

[G85] Ginsberg, M. L., Does probability have a place in non-monotonic reasoning, in: Proceedings IJCAI-85, Los-Angeles, CA 107-110

[G87] Ginsberg, M. L., ed., Readings in Nonmonotonic Reasoning, Morgan Kaufman, Los Altos, CA, 1987

[G98] Ginsberg, M. L., Multivalued logic: a uniform approach to reasoning in artiﬁcial intelligence, Computational Intelligence 4 (1998) 265-316

[G05] Golbeck, J., Computing and Applying Trust in Web-Based Social Networks, Ph.D. Dissertation, University of Maryland, College Park, 2005.

99 [G07] Golbeck, J., Trust and Nuanced Profile Similarity in Online Social Networks. Submit- ted to ACM Transactions on the Web. [GH04] Golbeck, J., Hendler, J., Reputation network analysis for email filtering, Proceedings of the First Conference on Email and Anti-Spam, Mountain View, California. July, 2004 [G95] Gruber, T.R. Toward Principles for the Design of Ontologies Used for Knowl- edge Sharing, Int. Journal of Human-Computer Studies, Vol. 43, pp.907-928. http://citeseer.ist.psu.edu/gruber93toward.html [HM01] Haarslev, V., Moeller, R. RACER system description, in International Joint Con- ference on Automated Reasoning, IJCAR’2001, June 18-23, 2001, Siena, Italy. [H90] Halpern, J. Y., An analysis of first-order logics of probability, Artificial Intelligence 46 1990 [HS98] Hahn, U., Schnattinger. Ontology engineering via text understanding. In IFIP’98 - Proceedings of the 15th World Computer Congress, Vienna and Budapest, 1998. http://citeseer.ist.psu.edu/hahn98ontology.html [H88] Hamilton, A.G., Logic for mathematicians, Revised Edition, Cambridge University Press, Cambridge UK 1988 [H88a] Hedrick, C., Routing Information Protocol, RFC 1058, Rutgers University, June 1988. [HH01] Heflin, J. and Hendler, J., A Portrait of the Semantic Web in Action. IEEE Intelligent Systems, 16(2):54-59, 2001. [H01] Heflin, J., Towards the Semantic Web: Knowledge Representation in a Dynamic, Distributed Environment. Ph.D. Thesis, University of Maryland, College Park. 2001. [H01a] Hendler, J. Agents on the Semantic Web. Intelligent Systems, pp. 30-37 March-April 2001. [WWW01a] Hertman, I., ed., W3C Semantic Web Activity Statement [online] Available: http://www.w3.org/2001/sw/Activity (19 Dec. 2007) [WWW01b] Hertman, I. W3C Semantic Web homepage. [online], Available: http://www.w3.org/2001/sw/ (19 Dec. 2007) [H98] Horrocks, I. The FaCT system. In H. de Swart, editor, Automated Reasoning with Analytic Tableaux and Related Methods: International Conference Tableaux’98, number 1397 in Lecture Notes in Artificial Intelligence, pages 307-312. Springer-Verlag, May 1998 [HPH03] Horrocks, I., Patel-Schneider, P. F., van Harmelen, P. From SHIQ and RDF to OWL: The making of a web ontology language, Journal of Web Semantics, 1(1):7-26, 2003

100 [IMS06] IMS (Instructional Management Systems) Project from Educause. http://www.imsproject.org/ [KG06] Katz, Y., Golbeck, J., Nonmonotonic reasoning with Web-Based Social Networks, Proceedings of the Workshopon Reasoning on the Web, WWW06, Edinburgh, UK, May 2006 [KIF] KIF - Knowledge Interchange Format, http://www.csee.umbc.edu/kse/kif/

[K68] Knuth, D. E., itThe art of computer programming. Vol. 1: Fundamental Algorithms, Addison-Wesley Series in Computer Science and Information Systems, 1968

[KSL06] Wine Agent - how it works? Knowledge Systems Laboratory, Stanford University. http://www.ksl.stanford.edu/projects/wine/explanation.html

[LW91] Lave, J., Wenger, E. Situated learning: Legitimate Peripheral Participation. Cam- bridge University Press (September 27, 1991)

[L03] Lee, J., Goodwin, R., Akkiraju, R., Doshi, P.,Ye, Y. SNoBASE: A Semantic Network- based Ontology Ontology Management. http://alphaWorks.ibm.com/tech/snobase

[L90] Douglas B. Lenat, D. B, Guha, R. V., Pittman, K., Pratt, D., Shepherd, M., Cyc: toward programs with common sense, in Commununications of the ACM, Vol. 33, No 8, (1990) 30–49 [L95] Lesser, V. Nlultiagent. Systems: An Emerging Subdiscipline of AI. ACM Computing Surveys, Vol 27, No 3, September 1995

[LC01] Leuf, B., Cunningham, W. The Wiki Way. Addison-Wesley, 2001

[L76] Lewis, D.K., Probabilities of conditionals and conditional probabilities, Philosophical Reviews 85 (1976) 297–315

[M01] Maedche, A., Staab, S., Stojanovic, N., Studer, S., Sure, Y. SEmantic Por- tAL - The SEAL approach. In D. Fensel, J. Hendler, H. Lieberman, W. Wahlster (eds.) Creating the Semantic Web. MIT Press, MA, Cambridge, 2001. http://citeseer.ist.psu.edu/maedche01semantic.html [MM04] Manola, F., Miller, E., editors. (2004), RDF Primer. W3C Recommendation 10 February 2004

[MH69] McCarthy, J., Hayes, P., Some Philosophical Problems from the Standpoint of Artiﬁcial Intelligence, in Machine intelligence 1969 [MH80] McCarthy, J., Circumscription - A Form of Nonmonotonic Reasoning, in Artiﬁcial Intelligence 13 (1980) 27-39

[M86] McCarthy, J., Applications of circumscription to formalizing common-sense knowledge, Artiﬁcial Intelligence 28 (1986) 89–116.

101 [MB07] Miles, A., Brickley, D., SKOS Core Vocabulary Specification, W3C Working Draft 2 November 2005, http://www.w3.org/TR/swbp-skos-core-spec [M89] McGee, V., Conditional probabilities and compounds of conditionals, Philosophical Reviews, 98 (1989) 485–541. [M96] Milne, P., Avoiding triviality: fuzzy implications and conditional events, International Journal of Approximate Reasoning 15 (1996) 123–143. [MH04] McGuinness, D. L., van Harmelen, F., editors. OWL Language Overview. W3C Recommendation 10 February 2004 [M03] Mika, P., Iosif, V., Sure, Y., Akkermans, H. Ontology-based content management in the virtual organization. In Davies, J., Fensel, D., van Harmelen, F., eds. Towards the Semantic Web: Ontology-Driven Knowledge Management. [MHN98] Muller, R., Haarslev, V., Neumann, B. Semantics-Based Information Retrieval, In: Proceedings of IT&KNOWS-98: International Conference on Information Technology and Knowledge Systems, 31. August- 4. September, Vienna, Budapest, 1998. [N01] Noy, N. F. , Sintek, M., Decker, S., Crubezy, M., Fergerson, R. W., Musen, M. A. Creating Semantic Web Contents with Protege-2000. IEEE Intelligent Systems 16(2):60- 71, 2001. [P88] Pearl, J., Probabilistic Reasoning in Intelligent Systems: Networks of Plausible Infer- ence, Morgan Kauffman, San Mateo CA 1988 [P90] Pearl, J., System Z: A Natural Ordering of Defaults with Tractable Applications to Nonmonotonic Reasoning, in Proceedings of the 3rd Conference on Theoretical Aspects of Reasoning about Knowledge (TARK-90), Morgan Kauffman, San Mateo CA 1990 [P95] Pollock, J., Cognitive Carpentry: A Blueprint for How to Build a Person, The MIT Press (May 4, 1995) [RG91] Rao, A. S., Georgeff, M. P., Modeling rational agents within a BDI-architecture. In Proceedings of the Second International Conference on Principles of Knowledge Representation and Reasoning, Morgan Kauffman Publishers, San Mateo, CA, 1991 [R31] Ramsey, F.P., The Foundations of Mathematics and Other Logical Essays (K. Paul, Trench, Trubner & Co., London, England, 1931). [R88] Rich, E., Default reasoning as likelihood reasoning, in: Proceedings AAAI-83¡ Wash- ington, dc 348-351 [RAD03] Richardson, M., Agrawal, R., Domingos, P., Trust management for the Semantic Web, Proceedings of the 2nd International Semantic Web Conference, pages 351-368, 2003 [R01] Raymond, E. R., The Cathedral and the Bazaar. Musings on Linux and Open Source by Accidental Revolutionary. O’Reilly, February 2001

102 [R80] Reiter, R., A logic for default reasoning, Artificial Intelligence 13 (1980) 81-132 [RN95] Russel, S., Norvig, P, Artificial Intelligence: A Modern Approach, 2nd ed., Prentice Hall: 1995 [S07] Schwartz, D.G., Dynamic reasoning systems: a general framework for belief revision. Paper in preparation, to be submitted to Artificial Intelligence [S97] Schwartz, D.G., Dynamic reasoning with qualified syllogisms, Artificial Intelligence, 93(1-2) (1997) 103-167. [S03] Schwartz, D.G., Agent-oriented epistemic reasoning: Subjective conditions of knowledge and belief, Artificial Intelligence 148 (2003) 177-195 [SD07] Slashdot.org http://www.slashdot.org [SF07] SourceForge, http://www.sourceforge.org [S84] Sowa, J. F., Conceptual structures: information processing in mind and machine, Addison-Wesley Longman Publishing Co., Inc. Boston, MA, USA, 1984 [S81] Stalnaker, R.C., Probability and conditionals, in: Harper, W.L., Stalnaker, R., and Pearce, G., eds., Ifs: Conditionals, Beliefs, Decision, Chance, and Time (D. Reidel, Dordrecht, 1981) 107–128. [S98] Sycara, K., MultiAgent Systems. AI Magazine 19(2): Summer 1998, 79-92 [S06] Swoogle Semantic Web Search Engine, http://swoogle.umbc.edu/ [U99] Uschold, M., Jasper, R., A framework for understanding and classifying ontology applications, in Proceedings of the IJCAI99 Workshop on Ontologies, and Problem- Solving Methods (KRR5), Stockholm, Sweden, August 1999. [U05] Ustymenko, S., (Student Poster) Ontology-Supported Sharing and Reuse of Knowl- edge in Diverse Environments, in Proceedings of the 43rd Annual Association for Com- puting Machinery Southeast Conference (ACMSE’05), March 18-20, 2005, Kennesaw, Georgia [US06] Ustymenko, S., Schwartz, D.G., An Agent-Oriented Logic for Reasoning about Belief and Trust, IEEE Workshop on Engineering Semantic Agent Systems, in Proceedings of 30th IEEE Annual International Computer Software and Applications Conference, September 17-21, 2006, Chicago, IL [US06a] Ustymenko, S., Schwartz, D.G., Online Communities and Online Repositories: Improving Digital Libraries by Collaborative Ontology-Based Filtering, in Proceedings of International e-Conference on Computer Science, July 01-08, 2006 [US05] Ustymenko, S., Schwartz, D.G., Applying Object-Oriented Metaphors and Design Patterns in Defining Semantic Metadata, in Proceedings of the First on-Line conference on Metadata and Semantics Research (MTSR’05) , November 21-30, 2005

103 [V05] Vara, V., From Wikipedia’s Creator, a New Site for Anyone, Anything, The Wall Street Journal, March 25, 2005 [V02] Vitiello Jr., E., A module for deﬁning trust relationships in FOAF, July 22, 2002, http://www.perceive.net/schemas/20020725/trust/default.htm

[WJ95] Wooldridge, M., Jennings, N. R., Agent Theories, Architectures, and Languages: a Survey, in Wooldridge, Jennings, Eds., Intelligent Agents, Berlin: Springer-Verlag, 1-22, 1999

[Y04] Yergeau, F., Paoli, J. T., Sperberg-McQueen, C. M. , Maler, E. Extensible Markup Language (XML) 1.0 (Third Edition) W3C Recommendation 4th February 2004. [SM02] Sosteric, M., Hesemeir, S., When learning object is not an object: A ﬁrst step towards a theory of learning objects. International Review of Research in Open and Distance Learning (October - 2002)

[Z01] Zadeh, L., New Direction in AI–Toward a Computational Theory of Perceptions, AI Magazine 22 (2001) 291-304 [Z75] Zadeh, L., The concept of a linguistic variable and its application to approximate reasoning, part I, Information Sciences 8 (1975) 199–249; part II, 8, 301–357; part III, 9, 43–80. Reprinted in Yager, R.R., Ovchinnikov, S., Tong, R.M., and Nguyen, H.T., Eds., Fuzzy Sets and Applications: Selected Papers by L.A. Zadeh, John Wiley and Sons, New York, 1987, pp. 219–269, 271–327, 329–366.

[Z05] Zhang, Q., Ting, Y., Irwin, K., A Classiﬁcation Scheme for Trust Functions in Reputatation-Based Trust Management, International Workshop on Trust, Security, and Reputation on the Semantic Web, A workshop at ISWC 2004, Japan, 2004

104 BIOGRAPHICAL SKETCH

Stanislav Ustymenko

Stanislav Ustymenko is a doctoral student in Computer Science at Florida State University. He came from Ukraine in 2003, and now lives in Tallahassee with his wife Myla and a pair of pet zebra finches. Stan is a Microsoft Certified Solutions Developer with five years of professional software engineering experience. His research interests include Semantic Web, computational logic and belief revision. He is also engaged in professional development activities like Preparing Future Faculty, Online Mentor training, and PIE teaching conferences. He is a member of ACM, IEEE Computer Society, and the UPE CS honor society.

105