We present an extension, TeleoR, of Nilsson's Teleo-Reactive (TR) rule based robotic agent programming language[22]. For both languages programs essentially comprise sequences of Guard ~>Action rules grouped into parameterised procedures. The Guard is a deductive query to a set of rapidly changing percept facts generated from the most recent sensor values. For TR, the Action is either a tuple of primitive robotic actions, to be executed in parallel, or a single call to a program procedure, which can be a recursive call, or a BeliefStoreupdate. TeleoR has extra forms of action. The procedures encode goal (teleo) directed reactive task and sub-task behaviours of robotic agents. TR/TeleoR programs are robust and opportunity grabbing, and so are well suited to human/robot or robot/robot co-operative tasks requiring flexible behaviour. TeleoR, extends TR in having: types and higher order features; extra forms of action rules that temporarily inhibit other rules in the same procedure; repeatable sequences of time capped actions; wait/repeat re-start of failed actions; belief store update and message send actions linked with any rule; a flexibly typed higher order LP/FP programming language for BeliefStore inference; support for the high level programming of multi-tasking agents that interleave the use of subsets of a set of independent robotic resources. All the extensions were driven by application needs. The use of QuLog enables us to guarantee by compiler analysis that all guarded rule actions will be fully instantiated and correctly typed when sent to a robot, perhaps via a ROS interface. The focus of this paper is on the extensions for single task communicating robotic agents. Our goal was to extend TR without losing the elegance and simplicity of Nilsson's language. We also wanted to be able to give the extended language a formally defined operational semantics, building upon one we had given for TR. The extensions, their semantics, and their implementation were developed in parallel. A methodology we can recommend.

Abstract Pedro is a TCP/IP publish/subscribe server implemented in C that uses Prolog technology for testing subscriptions against notifications. It provides both content‐ and address‐based routing of messages between processes. An inter‐process message M is a string representation of a Pedro term (usually but not necessarily a variable free term). A subscription is essentially a message template T paired with a Pedro query that is used to restrict the allowed values for variables in T. Pedro automatically forwards any notification it receives to all processes that have a current subscription that covers the notification. A Pedro connected process can optionally register a name with Pedro giving the process a unique Pedro handle. Pedro handles can be used to send peer‐to‐peer messages between processes. In this paper we illustrate the use of Pedro and describe its implementation. Copyright © 2010 John Wiley & Sons, Ltd.

Text classification is the problem of classifying a set of documents into a pre-defined set of classes. A major problem with text classification problems is the high dimensionality of the feature space. Only a small subset of these words are feature words which can be used in determining a document's class, while the rest adds noise and can make the results unreliable and significantly increase computational time. A common approach in dealing with this problem is feature selection where the number of words in the feature space are significantly reduced. In this paper we present the experiments of a comparative study of feature selection methods used for text classification. Ten feature selection methods were evaluated in this study including the new feature selection method, called the GU metric. The other feature selection methods evaluated in this study are: Chi-Squared (χ2) statistic, NGL coefficient, GSS coefficient, Mutual Information, Information Gain, Odds Ratio, Term Frequency, Fisher Criterion, BSS/WSS coefficient. The experimental evaluations show that the GU metric obtained the best F1 and F2 scores. The experiments were performed on the 20 Newsgroups data sets with the Naive Bayesian Probabilistic Classifier.

We describe the use of mobile agent technologies in building a framework for supporting distributed logic programming and remote conditional querying. A mobile agent moves from server to server carrying its own knowledge. When it arrives at a server it is given read access to the some part of the server's knowledge base. It then answers its queries using the server's knowledge and its own, adding the results to its own knowledge. We can view the mobile agent's queries as conditional remote queries - what answers would the server give if the knowledge carried by the agent were added to the server. To implement a prototype framework of mobile agents and knowledge servers we have used a new multiparadigm and multi-threaded programming language Go !. This supports mobile agent's as knowledge objects and has powerful knowledge structuring features. We assume some familiarity with Prolog.

We present a generic framework for developing complex distributed applications in open information environments, using reactive agents as basic building blocks. We address agent architecture and collaboration issues by introducing a minimal agent architecture, the Reactive Information Agent, and adopting a flexible asynchronous communication infrastructure, the Inter-Agent Communication Model. Finally, we present an implementation of the framework which allows agent designers to rapidly develop multi-agent systems based on simple heterogeneous computational elements, which are mobile, adaptive, reflective, and dynamically reconfigurable during the system lifetime.

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.

Most research on parallel logic programming divides into (1) or-parallel implementations of Prolog, and (2) and-parallel implementations of committed choice variants of Prolog, the so-called concurrent logic languages. The reason is implementation efficiency: it is extremely complex to implement a combined and/or parallel system. This paper introduces the research on the concurrent and-parallel languages and their extensions, with an emphasis on Parlog. However, all the main concurrent languages are introduced and compared, and set in a historical context of precursor research. Recent work on extensions of the languages is described, particularly the Parlog extensions: Parlog + + and Polka for object-oriented programming, and Pandora for constrained search.

The key concepts of the parallel logic programming language PARLOG are introduced by comparing the language with Prolog. Some familiarity with Prolog and with the concepts of logic programming is assumed. Two major application areas of PARLOG, systems programming and object-oriented programming, are illustrated. Other applications are briefly surveyed.>

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)

A common basis is presented, for Floyd's method of inductive assertions and for the subgoal induction method of Morris and Wegbreit. This basis is provided by consequence verification, a method for verifying logic programs. We connect flowcharts with logic programs by giving a recursive definition of the set of all computations of a flowchart. This definition can be given in two ways: the recursion can run forward or backward. Both definitions can be expressed in logic, resulting in a logic program which is then subjected to consequence verification. Verification of the forward logic program is shown to be essentially Floyd's method; verification of the backward program corresponds similarly to subgoal induction.

In recent, separate, work on program transformation and synthesis (Darlington, 1975; 1978; Clark & Sickel, 1977; Clark, 1977) the authors have discovered that a structure of a class of algorithms can be exposed by synthesising each algorithm in the class from a common high level specification, building up a ‘family tree’ of algorithms. In this paper we would like to illustrate this technique by a simple example outlining how four common sorting algorithms, Merge Sort, Quick Sort, Insertion Sort and Seletion Sort, can be synthesised from a common specification. We hope to encourage others to undertake this exercise for other domains.