118 research outputs found
Extended logic-plus-functional programming
Extensions of logic and functional programming are integrated in RELFUN. Its valued clauses comprise Horn clauses (true\u27-valued) and clauses with a distinguished foot\u27 premise (returning arbitrary values). Both the logic and functional components permit LISP-like varying-arity and higher-order operators. The DATAFUN sublanguage of the functional component is shown to be preferable to relational encodings of functions in DATALOG. RELFUN permits non-ground, non-deterministic functions, hence certain functions can be inverted using an is\u27-primitive generalizing that of PROLOG. For function nestings a strict call-by-value strategy is employed. The reduction of these extensions to a relational sublanguage is discussed and their WAM compilation is sketched. Three examples (serialise\u27, wang\u27, and eval\u27) demonstrate the relational/functional style in use. The list expressions of RELFUN\u27s LISP implementation are presented in an extended PROLOG-like syntax
Some methodological issues in the design of CIAO, a generic, parallel concurrent constraint system
We informally discuss several issues related to the parallel
execution of logic programming systems and concurrent logic programming systems, and their generalization to constraint programming. We propose a new view of these systems, based on a particular definition of parallelism. We argüe that, under this view, a large number of the actual systems and models can be explained through the application, at different levéis of granularity, of only a few basic principies: determinism, non-failure, independence (also referred to as stability), granularity, etc. Also, and based on the convergence of concepts that this view brings, we sketch a model for the implementation of several parallel constraint logic programming source languages and models based on a common, generic abstract machine and an intermedÃate kernel language
Extended logic-plus-functional programming
Extensions of logic and functional programming are integrated in RELFUN. Its valued clauses comprise Horn clauses (true'-valued) and clauses with a distinguished foot' premise (returning arbitrary values). Both the logic and functional components permit LISP-like varying-arity and higher-order operators. The DATAFUN sublanguage of the functional component is shown to be preferable to relational encodings of functions in DATALOG. RELFUN permits non-ground, non-deterministic functions, hence certain functions can be inverted using an is'-primitive generalizing that of PROLOG. For function nestings a strict call-by-value strategy is employed. The reduction of these extensions to a relational sublanguage is discussed and their WAM compilation is sketched. Three examples (serialise', wang', and eval') demonstrate the relational/functional style in use. The list expressions of RELFUN's LISP implementation are presented in an extended PROLOG-like syntax
An overview of artificial intelligence and robotics. Volume 1: Artificial intelligence. Part A: The core ingredients
Artificial Intelligence (AI) is an emerging technology that has recently attracted considerable attention. Many applications are now under development. The goal of Artificial Intelligence is focused on developing computational approaches to intelligent behavior. This goal is so broad - covering virtually all aspects of human cognitive activity - that substantial confusion has arisen as to the actual nature of AI, its current status and its future capability. This volume, the first in a series of NBS/NASA reports on the subject, attempts to address these concerns. Thus, this report endeavors to clarify what AI is, the foundations on which it rests, the techniques utilized, applications, the participants and, finally, AI's state-of-the-art and future trends. It is anticipated that this report will prove useful to government and private engineering and research managers, potential users, and others who will be affected by this field as it unfolds
Transformation�based implementation and optimization of programs exploiting the basic Andorra model.
The characteristics of CC and CLP systems are in principle very dierent However a recent trend towards convergence in the implementation techniques for these systems can be observed While CLP and Prolog systems have been incorporating capabilities to deal with userdened suspension and coroutining CC compilers have been trying to
coalesce negrained tasks into coarsergrained sequential threads This convergence of techniques opens up the possibility of having a general purpose kernel language and
abstract machine to serve as a compilation target for a variety of userlevel languages We propose a transformation technique directed towards such an objective In particular we report on techniques to support the Andorra computational model essentially emulating the AndorraI system via program transformation into a sequential language with delay primitives The system is automatic comprising an optional program analyzer and a basic transformer to the kernel language It turns out that a simple parallel CLP or Prolog system with dynamic scheduling is sucient as a kernel language for this purpose The preliminary results are quite encouraging performance
of the resulting system is comparable to the current AndorraI implementation
Recognising the design decisions in Prolog programs as a prelude to critiquing
This thesis presents an approach by which an automated teaching system can
analyse the design of novices' Prolog programs for tutorial critiquing. Existing
methodologies for tutorial analysis of programs focus on the kind of small pro¬
gramming examples that are used only in the early stages of teaching. If an
automated teaching system is to be widely useful, it must cover a substantial
amount of the teaching syllabus, and a critiquing system must be able to analyse
and critique programs written during the later stages of the syllabus.The work is motivated by a study of students' Prolog programs which were
written as assessed exercises towards the end of their course. These programs
all work (in some sense), yet they reveal a wide range of design (laws (bodges)
for which some form of tutoring would be useful. They present problems for any
automated analysis in terms of the size of the programs, the number of individual
decisions that must be made to create each program and the range of correct
and incorrect decisions that may be made in each case.This study identifies two areas in the analysis of students' program in which
further work is needed. Existing work has focussed only on the design and
implementation decisions that relate closely to the programming language. That
is not sufficient for these slightly more advanced programs, for which decisions in
the problem domain must also be recognised. Existing work has focussed on the
different ways to implement code, but in these programs the students also make
decisions about which data structures are to be used. These decisions must also
be part of an analysis.The thesis provides an approach which represents both decisions in the domain
of the problem being solved and decisions about how to implement them in
Prolog. Decisions in the problem domain are represented by tasks (for code)
and by domain objects (for data structures). Decisions that are specific to the
Prolog implementation are represented by prototypes which encapsulate standard
programming techniques (for code) and by a polymorphic data type language (for
data structures). Issues in devising these representations are discussed.An analysis-by synthesis approach is used for code recognition. This is aug¬
mented by a procedure called "clausal split" which isolates novel or poorly de¬
signed parts of an implementation. Following an incomplete analysis of the
program by synthesis, the results of this analysis provide the basis for making
inferences about the parts of the program that have not been understood. For
analysing data structures, a type inference mechanism is combined with inference
about the parts of domain objects. Inferred data type information is also used
to limit search, both for synthesis and analysis.An architecture using this approach has been implemented. The success of the
architecture is assessed on student's programs. From this assessment it is clear
that much further work remains to be done, but the results are hopeful
A Comparative study of four major knowledge representation techniques used in expert systems with an implementation in Prolog
Knowledge representation is a central issue in Artifical Intelligence (AI) research. In order to solve the diverse and complex problems encountered, one needs both a large amount of knowledge and some mechanism for the management and skillful utilization of that knowledge. The basic problem in knowledge representation is the development of an adequate formalism to represent that knowledge. In this thesis I will discuss four of the major techniques for representing knowledge in expert systems: first order logic, production rules, semantic networks, and frames. Using Prolog as the implementation language, I will demonstrate that all of the above mentioned representation techniques, when used in actual implementations, will be reduced to an equivalency - that being a set of Prolog facts and rules. Prolog limits us to a set of facts expressed as predicate(argumentl, argument, ..., argumentn) and IF ... THEN rules, thus eliminating many of the unique features which characterize the various representation techniques. Therefore, Prolog can be viewed as a representation technique itself
Detecting Prolog programming techniques using abstract interpretation
There have been a number of attempts at developing intelligent tutoring systems (ITSs)
for teaching students various programming languages. An important component of such
an ITS is a debugger capable of recognizing errors in the code the student writes and
possibly suggesting ways of correcting such errors. The debugging process involves a
wealth of knowledge about the programming language, the student and the individual
problem at hand, and an automated debugging component makes use of a number of
tools which apply this knowledge. Successive ITSs have incorporated a wider range of
knowledge and more powerful tools.
The research described in this thesis should be seen as carrying on with this succes¬
sion. Specifically, we attempt to enhance an existing Prolog ITS (PITS) debugger called
APR0P0S2 developed by Looi. The enhancements take the form of a richer language
with which to describe Prolog code and more powerful tools with which constructs in
this language may be detected in Prolog code.
The richer language is based on the notion of programming techniques—common
patterns in code which capture in some sense an expert's understanding of Prolog.
The tools are based on Prolog abstract interpretation—a program analysis method for
inferring dynamic properties of code. Our research makes contributions to both these
areas.
We develop a language for describing classes of Prolog programming techniques
that manipulate data-structures. We define classes in this language for common Prolog
techniques such as accumulator pairs and difference structures.
We use abstract interpretation to infer the dynamic features with which techniques
are described. We develop a general framework for abstract interpretation which is
described in Prolog, so leading directly to an implementation. We develop two abstract
domains—one which infers general data flow information about the code and one which
infers particularly detailed type information—and describe the implementation of the
former
Strict and non-strict independent and-parallelism in logic programs: Correctness, efficiency, and compile-time conditions.
This paper presents some fundamental properties of independent and-parallelism and extends its applicability by enlarging the class of goals eligible for parallel execution. A simple model of (independent) and-parallel execution is proposed and issues of correctness and efficiency discussed in the light of this model. Two conditions, "strict" and "non-strict" independence, are defined and then proved sufficient to ensure correctness and
efñciency of parallel execution: if goals which meet these conditions are executed in parallel the solutions obtained are the same as those produced by standard sequential execution. Also, in absence of failure, the parallel proof
procedure does not genérate any additional work (with respect to standard SLD-resolution) while the actual execution time is reduced. Finally, in case of failure of any of the goals no slow down will occur. For strict independence the results are shown to hold independently of whether the parallel goals execute in the same environment or in sepárate environments. In addition, a formal basis is given for the automatic compile-time generation of
independent and-parallelism: compile-time conditions to efficiently check goal independence at run-time are proposed and proved sufficient. Also, rules are given for constructing simpler conditions if information regarding
the binding context of the goals to be executed in parallel is available to the compiler
- …