142 research outputs found
Proceedings of the Workshop on the lambda-Prolog Programming Language
The expressiveness of logic programs can be greatly increased over first-order Horn clauses through a stronger emphasis on logical connectives and by admitting various forms of higher-order quantification. The logic of hereditary Harrop formulas and the notion of uniform proof have been developed to provide a foundation for more expressive logic programming languages. The λ-Prolog language is actively being developed on top of these foundational considerations. The rich logical foundations of λ-Prolog provides it with declarative approaches to modular programming, hypothetical reasoning, higher-order programming, polymorphic typing, and meta-programming. These aspects of λ-Prolog have made it valuable as a higher-level language for the specification and implementation of programs in numerous areas, including natural language, automated reasoning, program transformation, and databases
Compiling Prolog to Logic-inference Virtual Machine
The Logic-inference Virtual Machine (LVM) is a new Prolog execution model
consisting of a set of high-level instructions and memory architecture for handling control
and unification. Different from the well-known Warren's Abstract Machine [1], which uses
Structure Copying method, the LVM adopts a hybrid of Program Sharing [2] and
Structure Copying to represent first-order terms. In addition, the LVM employs a single
stack paradigm for dynamic memory allocation and embeds a very efficient garbage
collection algorithm to reclaim the useless memory cells. In order to construct a complete
Prolog system based on the LVM, a corresponding compiler must be written.
In this thesis, a design of such LVM compiler is presented and all important
components of the compiler are described. The LVM compiler is developed to translate
Prolog programs into LVM bytecode instructions, so that a Prolog program is compiled
once and can run anywhere.
The first version of LVM compiler (about 8000 lines of C code) has been
developed. The compilation time is approximately proportional to the size of source
codes. About 80 percent of the time are spent on the global analysis. Some compiled
programs have been tested under a LVM emulator. Benchmarks show that the LVM
system is very promising in memory utilization and performance
An Implementation of the Language Lambda Prolog Organized around Higher-Order Pattern Unification
This thesis concerns the implementation of Lambda Prolog, a higher-order
logic programming language that supports the lambda-tree syntax approach to
representing and manipulating formal syntactic objects. Lambda Prolog achieves
its functionality by extending a Prolog-like language by using typed lambda
terms as data structures that it then manipulates via higher-order unification
and some new program-level abstraction mechanisms. These additional features
raise new implementation questions that must be adequately addressed for Lambda
Prolog to be an effective programming tool. We consider these questions here,
providing eventually a virtual machine and compilation based realization. A key
idea is the orientation of the computation model of Lambda Prolog around a
restricted version of higher-order unification with nice algorithmic properties
and appearing to encompass most interesting applications. Our virtual machine
embeds a treatment of this form of unification within the structure of the
Warren Abstract Machine that is used in traditional Prolog implementations.
Along the way, we treat various auxiliary issues such as the low-level
representation of lambda terms, the implementation of reduction on such terms
and the optimized processing of types in computation. We also develop an actual
implementation of Lambda Prolog called Teyjus Version 2. A characteristic of
this system is that it realizes an emulator for the virtual machine in the C
language a compiler in the OCaml language. We present a treatment of the
software issues that arise from this kind of mixing of languages within one
system and we discuss issues relevant to the portability of our virtual machine
emulator across arbitrary architectures. Finally, we assess the the efficacy of
our various design ideas through experiments carried out using the system
A Statically Typed Logic Context Query Language With Parametric Polymorphism and Subtyping
The objective of this thesis is programming language support for context-sensitive program adaptations. Driven by the requirements for context-aware adaptation languages, a statically typed Object-oriented logic Context Query Language (OCQL) was developed, which is suitable for integration with adaptation languages based on the Java type system. The ambient information considered in context-aware applications often originates from several, potentially distributed sources. OCQL employs the Semantic Web-language RDF Schema to structure and combine distributed context information. OCQL offers parametric polymorphism, subtyping, and a fixed set of meta-predicates. Its type system is based on mode analysis and a subset of Java Generics. For this reason a mode-inference approach for normal logic programs that considers variable aliasing and sharing was extended to cover all-solution predicates. OCQL is complemented by a service-oriented context-management infrastructure that supports the integration of OCQL with runtime adaptation approaches. The applicability of the language and its infrastructure were demonstrated with the context-aware aspect language CSLogicAJ. CSLogicAJ aspects encapsulate context-aware behavior and define in which contextual situation and program execution state the behavior is woven into the running program. The thesis concludes with a case study analyzing how runtime adaptation of mobile applications can be supported by pure object-, service- and context-aware aspect-orientation. Our study has shown that CSLogicAJ can improve the modularization of context-aware applications and reduce anticipation of runtime adaptations when compared to other approaches
Web and Semantic Web Query Languages
A number of techniques have been developed to facilitate
powerful data retrieval on the Web and Semantic Web. Three categories
of Web query languages can be distinguished, according to the format
of the data they can retrieve: XML, RDF and Topic Maps. This article
introduces the spectrum of languages falling into these categories
and summarises their salient aspects. The languages are introduced using
common sample data and query types. Key aspects of the query
languages considered are stressed in a conclusion
- …