835 research outputs found
Amalia -- A Unified Platform for Parsing and Generation
Contemporary linguistic theories (in particular, HPSG) are declarative in
nature: they specify constraints on permissible structures, not how such
structures are to be computed. Grammars designed under such theories are,
therefore, suitable for both parsing and generation. However, practical
implementations of such theories don't usually support bidirectional processing
of grammars. We present a grammar development system that includes a compiler
of grammars (for parsing and generation) to abstract machine instructions, and
an interpreter for the abstract machine language. The generation compiler
inverts input grammars (designed for parsing) to a form more suitable for
generation. The compiled grammars are then executed by the interpreter using
one control strategy, regardless of whether the grammar is the original or the
inverted version. We thus obtain a unified, efficient platform for developing
reversible grammars.Comment: 8 pages postscrip
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
COLAB : a hybrid knowledge representation and compilation laboratory
Knowledge bases for real-world domains such as mechanical engineering require expressive and efficient representation and processing tools. We pursue a declarative-compilative approach to knowledge engineering. While Horn logic (as implemented in PROLOG) is well-suited for representing relational clauses, other kinds of declarative knowledge call for hybrid extensions: functional dependencies and higher-order knowledge should be modeled directly. Forward (bottom-up) reasoning should be integrated with backward (top-down) reasoning. Constraint propagation should be used wherever possible instead of search-intensive resolution. Taxonomic knowledge should be classified into an intuitive subsumption hierarchy. Our LISP-based tools provide direct translators of these declarative representations into abstract machines such as an extended Warren Abstract Machine (WAM) and specialized inference engines that are interfaced to each other. More importantly, we provide source-to-source transformers between various knowledge types, both for user convenience and machine efficiency. These formalisms with their translators and transformers have been developed as part of COLAB, a compilation laboratory for studying what we call, respectively, "vertical\u27; and "horizontal\u27; compilation of knowledge, as well as for exploring the synergetic collaboration of the knowledge representation formalisms. A case study in the realm of mechanical engineering has been an important driving force behind the development of COLAB. It will be used as the source of examples throughout the paper when discussing the enhanced formalisms, the hybrid representation architecture, and the compilers
αCheck: a mechanized metatheory model-checker
The problem of mechanically formalizing and proving metatheoretic properties
of programming language calculi, type systems, operational semantics, and
related formal systems has received considerable attention recently. However,
the dual problem of searching for errors in such formalizations has attracted
comparatively little attention. In this article, we present Check, a
bounded model-checker for metatheoretic properties of formal systems specified
using nominal logic. In contrast to the current state of the art for metatheory
verification, our approach is fully automatic, does not require expertise in
theorem proving on the part of the user, and produces counterexamples in the
case that a flaw is detected. We present two implementations of this technique,
one based on negation-as-failure and one based on negation elimination, along
with experimental results showing that these techniques are fast enough to be
used interactively to debug systems as they are developed.Comment: Under consideration for publication in Theory and Practice of Logic
Programming (TPLP
The design and implementation of a relational programming system.
The declarative class of computer languages consists mainly of two paradigms
- the logic and the functional. Much research has been devoted in recent years
to the integration of the two with the aim of securing the advantages of both
without retaining their disadvantages. To date this research has, arguably, been
less fruitful than initially hoped. A large number of composite functional/logical
languages have been proposed but have generally been marred by the lack of a
firm, cohesive, mathematical basis. More recently new declarative paradigms,
equational and constraint languages, have been advocated. These however do
not fully encompass those features we perceive as being central to functional and
logic languages. The crucial functional features are higher-order definitions, static
polymorphic typing, applicative expressions and laziness. The crucial logic features are ability to reason about both functional and non-functional relationships
and to handle computations involving search.
This thesis advocates a new declarative paradigm which lies midway between
functional and logic languages - the so-called relational paradigm. In a relationallanguage program and data alike are denoted by relations. All expressions
are relations constructed from simpler expressions using operators which form
a relational algebra. The impetus for use of relations in a declarative language
comes from observations concerning their connection to functional and logic programming. Relations are mathematically more general than functions modelling
non-functional as well as functional relationships. They also form the basis of
many logic languages, for example, Prolog.
This thesis proposes a new relational language based entirely on binary relations, named Drusilla. We demonstrate the functional and logic aspects of
Drusilla. It retains the higher-order objects and polymorphism found in modern functional languages but handles non-determinism and models relationships
between objects in the manner of a logic language with notion of algorithm being composed of logic and control elements. Different programming styles -
functional, logic and relational- are illustrated.
However, such expressive power does not come for free; it has associated with
it a high cost of implementation. Two main techniques are used in the necessarily
complex language interpreter. A type inference system checks programs to ensure
they are meaningful and simultaneously performs automatic representation selection for relations. A symbolic manipulation system transforms programs to improve.
efficiency of expressions and to increase the number of possible representations
for relations while preserving program meaning
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
Formal verification of AI software
The application of formal verification techniques to Artificial Intelligence (AI) software, particularly expert systems, is investigated. Constraint satisfaction and model inversion are identified as two formal specification paradigms for different classes of expert systems. A formal definition of consistency is developed, and the notion of approximate semantics is introduced. Examples are given of how these ideas can be applied in both declarative and imperative forms
- …