Keith L. Clark

Negation as failure

A query evaluation process for a logic data base comprising a set of clauses is described. It is essentially a Horn clause theorem prover augmented with a special inference rule for dealing with negation. This is the negation as failure inference rule whereby ~ P can be inferred if every possible proof of P fails. The chief advantage of the query evaluator described is the effeciency with which it can be implemented. Moreover, we show that the negation as failure rule only allows us to conclude negated facts that could be inferred from the axioms of the completed data base, a data base of relation definitions and equality schemas that we consider is implicitly given by the data base of clauses. We also show that when the clause data base and the queries satisfy certain constraints, which still leaves us with a data base more general than a conventional relational data base, the query evaluation process will find every answer that is a logical consequence of the completed data base.

PARLOG: parallel programming in logic

PARLOG is a logic programming language in the sense that nearly every definition and query can be read as a sentence of predicate logic. It differs from PROLOG in incorporating parallel modes of evaluation. For reasons of efficient implementation, it distinguishes and separates and-parallel and or-parallel evaluation. PARLOG relations are divided into two types: single-solution relations and all-solutions relations. A conjunction of single-solution relation calls can be evaluated in parallel with shared variables acting as communication channels for the passing of partial bindings. Only one solution to each call is computed, using committed choice nondeterminism. A conjunction of all-solutions relation calls is evaluated without communication of partial bindings, but all the solutions may be found by an or-parallel exploration of the different evaluation paths. A set constructor provides the main interface between single-solution relations and all-solutions relations. This paper is a tutorial introduction to PARLOG. It assumes familiarity with logic programming. Categories and Subject Descriptors: D.l.l [Programming Techniques]: Applicative (Functional)

APRIL—Agent PRocess Interaction Language

In this paper we introduce key features of a programming language for building DAI and other types of distributed applications requiring the transmission and manipulation of complex symbolic data. April is oriented to the implementation of multi-agent systems. However, April is NOT a ‘multi-agent applications language’. It does not directly offer high level features such as: planners, problem solvers and knowledge representation systems that a multi-agent applications language might be expected to include. April is more an object based concurrent language with objects as processes. As argued in [11], this is a highly suitable base for extension to DAI and multi-agent application platforms.

A relational language for parallel programming

A parallel program often defines a relation not a function. The program constrains the output to lie in some relation R to the input, but the particular output produced during a computation can depend on the time behaviour of component processes. This suggests the use of a relational language as an applicative language for parallel programming. The Horn clause subset of predicate logic is a relational language with an established procedural interpretation for non-deterministic sequential computations [Kowalski 1974]. In this paper we modify and extend that interpretation to define a special purpose parallel evaluator.

Using Grammatical Inference to Automate Information Extraction from the Web

The World-Wide Web contains a wealth of semistructured information sources that often give partial/overlapping views on the same domains, such as real estate listings or book prices. These partial sources could be used more effectively if integrated into a single view; however, since they are typically formatted in diverse ways for human viewing, extracting their data for integration is a difficult challenge. Existing learning systems for this task generally use hardcoded ad hoc heuristics, are restricted in the domains and structures they can recognize, and/or require manual training. We describe a principled method for automatically generating extraction wrappers using grammatical inference that can recognize general structures and does not rely on manually-labelled examples. Domain-specific knowledge is explicitly separated out in the form of declarative rules. The method is demonstrated in a test setting by extracting real estate listings from web pages and integrating them into an interactive data visualization tool based on dynamic queries.

Notes on the implementation of PARLOG

Abstract In this paper we consider the implementation of PARLOG by showing how any PARLOG program can be compiled to a program in a small and quite rudimentary subset of the language which we call Kernel PARLOG. To implement PARLOG on a particular architecture we need only implement Kernel PARLOG, which itself can be adapted to the features of the architecture. The paper presents a step-by-step reduction of PARLOG to Kernel PARLOG. Firstly, we define the set and subset primitives by interpreters in the single-solution subset of PARLOG. Then we show how any PARLOG single-solution relation definition can be compiled to one in Kernel PARLOG.

SAGE: A Logical Agent-Based Environment Monitoring and Control System

We propose SAGE, an agent-based environment monitoring and control system based on computation logic. SAGE uses forward chaining deductive inference to map low level sensor data to high level events, multi-agent abductive reasoning to provide possible explanations for these events, and teleo-reactive programming to react to these explanations, e.g. to gather extra information to check abduced hypotheses. The system is embedded in a publish/subscribe architecture.

Ontology schema for an agent belief store

In this paper we explore the use of a formal ontology as a constraining framework for the belief store of a rational agent. The static beliefs of the agent are the axioms of the ontology. The dynamic beliefs are the descriptions of the individuals that are instances of the ontology classes. The individuals all have a unique identifier, an associated set of named classes to which they are believed to belong, and a set of property values. The ontology axioms act as a schema for the dynamic beliefs. Belief updates not conforming to the axioms lead to either rejection of the update or some other revision of the dynamic belief store to maintain consistency. Partial descriptions are augmented by inferences of property values and class memberships licensed by the axioms. For concreteness we sketch how such an ontology based agent belief store could be implemented in a multi-threaded logic programming language with action rules and object oriented programming features called Go!. This language was specifically designed for implementing communicating rational agent applications. We shall see that its logic rules allow us to extend an ontology of classes and properties with rule defined n-ary relations and functions. Its action rules enable us to implement a consistency maintenance system that takes into account justifications for beliefs. The pragmatics of consistency maintenance is an issue not normally considered by the ontology community. The paper assumes some familiarity with ontology specification using languages such as OWL DL and its subsets, and with logic programming.

Content-Based Routing as the Basis for Intra-Agent Communication

In this paper, an agent architecture is proposed that can be used to integrate pre-existing components that provide the domain dependent agent functionality. The key integrating feature of the agent is an active message board that is used for inter-component, hence intra-agent communication. The board is active because it automatically forwards messages to components, they do not have to poll the message board. It does this on the basis of message pattern functions that components place on the board using advertisement messages. These functions can contain component provided semantic tests on the content of the message, they can also communicate with any other component whilst they are being applied. In addition an agent management toolkit, called ALFA, is described which offers a set of agent management services. This toolkit consists of a number of servers for storing the code of the components and symbolic descriptions of what agents regarding their component makeup. A third server uses all this information to facilitate launching new agents.

Multi-threading and message communication in Qu-Prolog

This paper presents the multi-threading and internet message communication capabilities of Qu-Prolog. Message addresses are symbolic and the communications package provides high-level support that completely hides details of IP addresses and port numbers as well as the underlying TCP/IP transport layer. The combination of the multi-threads and the high level inter-thread message communications provide simple, powerful support for implementing internet distributed intelligent applications.