462 research outputs found
Multi-dimensional Type Theory: Rules, Categories, and Combinators for Syntax and Semantics
We investigate the possibility of modelling the syntax and semantics of
natural language by constraints, or rules, imposed by the multi-dimensional
type theory Nabla. The only multiplicity we explicitly consider is two, namely
one dimension for the syntax and one dimension for the semantics, but the
general perspective is important. For example, issues of pragmatics could be
handled as additional dimensions.
One of the main problems addressed is the rather complicated repertoire of
operations that exists besides the notion of categories in traditional Montague
grammar. For the syntax we use a categorial grammar along the lines of Lambek.
For the semantics we use so-called lexical and logical combinators inspired by
work in natural logic. Nabla provides a concise interpretation and a sequent
calculus as the basis for implementations.Comment: 20 page
A Paraconsistent Higher Order Logic
Classical logic predicts that everything (thus nothing useful at all) follows
from inconsistency. A paraconsistent logic is a logic where an inconsistency
does not lead to such an explosion, and since in practice consistency is
difficult to achieve there are many potential applications of paraconsistent
logics in knowledge-based systems, logical semantics of natural language, etc.
Higher order logics have the advantages of being expressive and with several
automated theorem provers available. Also the type system can be helpful. We
present a concise description of a paraconsistent higher order logic with
countable infinite indeterminacy, where each basic formula can get its own
indeterminate truth value (or as we prefer: truth code). The meaning of the
logical operators is new and rather different from traditional many-valued
logics as well as from logics based on bilattices. The adequacy of the logic is
examined by a case study in the domain of medicine. Thus we try to build a
bridge between the HOL and MVL communities. A sequent calculus is proposed
based on recent work by Muskens.Comment: Originally in the proceedings of PCL 2002, editors Hendrik Decker,
Joergen Villadsen, Toshiharu Waragai (http://floc02.diku.dk/PCL/). Correcte
Monadic parser combinators
In functional programming, a popular approach to building recursive descent parsers is to model parsers as functions, and to define higher-order functions (or combinators) that implement grammar constructions such as sequencing, choice, and repetition. Such parsers form an instance of a monad, an algebraic structure from mathematics that has proved useful for addressing a number of computational problems. The purpose of this report is to provide a step-by-step tutorial on the monadic approach to building functional parsers, and to explain some of the benefits that result from exploiting monads. No prior knowledge of parser combinators or of monads is assumed. Indeed, this report can also be viewed as a first introduction to the use of monads in programming
A framework for point-free program transformation
The subject of this paper is functional program transformation in the so-called point-free style. By this we mean first translating programs to a form consisting only of categorically-inspired combinators, algebraic data types defined as fixed points of functors, and implicit recursion through the use of type-parameterized recursion patterns. This form is appropriate for reasoning about programs equationally, but difficult to actually use in practice for programming. In this paper we present a collection of libraries and tools developed at Minho with the aim of supporting the automatic conversion of programs to point-free (embedded in Haskell), their manipulation and rule-driven simplification, and the (limited) automatic application of fusion for program transformation.Fundação para a Ciência e a Tecnologia (FCT
Down with variables
Techn. Report DI-PURe-05.06.01The subject of this paper is point-free functional
programming in Haskell. By this we mean writing programs using
categorically-inspired combinators, algebraic data types defined as
fixed points of functors, and impicit recursion through the use of
type-parameterized recursion patterns. This style of
programming is appropriate for program calculation (reasoning
about programs equationally), but difficult to actually use in
practice - most programmers use a mixture of the above elements
with explicit recursion and manipulation of arguments. In this paper
we present a mechanism that allows programmers to convert classic
point-wise code into point-free style, and a Haskell library that
enables the direct execution of the resulting code. Together, they
make possible the use of point-free either as a direct programming
style or as a domain into which programs can be transformed before
being subject to further manipulation
Categorical combinators
Our main aim is to present the connection between λ-calculus and Cartesian closed categories both in an untyped and purely syntactic setting. More specifically we establish a syntactic equivalence theorem between what we call categorical combinatory logic and λ-calculus with explicit products and projections, with β and η-rules as well as with surjective pairing. “Combinatory logic” is of course inspired by Curry's combinatory logic, based on the well-known S, K, I. Our combinatory logic is “categorical” because its combinators and rules are obtained by extracting untyped information from Cartesian closed categories (looking at arrows only, thus forgetting about objects). Compiling λ-calculus into these combinators happens to be natural and provokes only n log n code expansion. Moreover categorical combinatory logic is entirely faithful to β-reduction where combinatory logic needs additional rather complex and unnatural axioms to be. The connection easily extends to the corresponding typed calculi, where typed categorical combinatory logic is a free Cartesian closed category where the notion of terminal object is replaced by the explicit manipulation of applying (a function to its argument) and coupling (arguments to build datas in products). Our syntactic equivalences induce equivalences at the model level. The paper is intended as a mathematical foundation for developing implementations of functional programming languages based on a “categorical abstract machine,” as developed in a companion paper (Cousineau, Curien, and Mauny, in “Proceedings, ACM Conf. on Functional Programming Languages and Computer Architecture,” Nancy, 1985)
On the Model of Computation of Place/Transition Petri Nets
In the last few years, the semantics of Petri nets has been investigated in several different ways. Apart from the classical "token game", one can model the behaviour of Petri nets via non-sequential processes, via unfolding constructions, which provide formal relationships between nets and domains, and via algebraic models, which view Petri nets as essentially algebraic theories whose models are monoidal categories. In this paper we show that these three points of view can be reconciled. More precisely, we introduce the new notion of decorated processes of Petri nets and we show that they induce on nets the same semantics as that of unfolding. In addition, we prove that the decorated processes of a net N can be axiomatized as the arrows of a symmetric monoidal category which, therefore, provides the aforesaid unification
Parsing of Hyperedge Replacement Grammars with Graph Parser Combinators
Graph parsing is known to be computationally expensive. For this reason the construction of special-purpose parsers may be beneficial for particular graph languages. In the domain of string languages so-called parser combinators are very popular for writing efficient parsers. Inspired by this approach, we have proposed graph parser combinators in a recent paper, a framework for the rapid development of special-purpose graph parsers. Our basic idea has been to define primitive graph parsers for elementary graph components and a set of combinators for the flexible construction of more advanced graph parsers. Following this approach, a declarative, but also more operational description of a graph language can be given that is a parser at the same time.
In this paper we address the question how the process of writing correct parsers on top of our framework can be simplified by demonstrating the translation of hyperedge replacement grammars into graph parsers. The result are recursive descent parsers as known from string parsing with some additional nondeterminism
Representations of stream processors using nested fixed points
We define representations of continuous functions on infinite streams of discrete values, both in the case of discrete-valued functions, and in the case of stream-valued functions. We define also an operation on the representations of two continuous functions between streams that yields a representation of their composite. In the case of discrete-valued functions, the representatives are well-founded (finite-path) trees of a certain kind. The underlying idea can be traced back to Brouwer's justification of bar-induction, or to Kreisel and Troelstra's elimination of choice-sequences. In the case of stream-valued functions, the representatives are non-wellfounded trees pieced together in a coinductive fashion from well-founded trees. The definition requires an alternating fixpoint construction of some ubiquity
- …