27,151 research outputs found
A Note on Logic Programming Fixed-Point Semantics
In this paper, we present an account of classical Logic Programming fixed-point semantics in terms of two standard categorical constructions in which the least Herbrand model is characterized by properties of universality. In particular, we show that, given a program , the category of models of is reflective in the category of interpretations for . In addition, we show that the immediate consequence operator gives rise to an endofunctor on the category of Herbrand interpretations for such that category of algebras for is the category of Herbrand models of . As consequences, we have that the least Herbrand model of is the least fixed-point of and is the reflection of the empty Herbrand interpretation
Cyclic Datatypes modulo Bisimulation based on Second-Order Algebraic Theories
Cyclic data structures, such as cyclic lists, in functional programming are
tricky to handle because of their cyclicity. This paper presents an
investigation of categorical, algebraic, and computational foundations of
cyclic datatypes. Our framework of cyclic datatypes is based on second-order
algebraic theories of Fiore et al., which give a uniform setting for syntax,
types, and computation rules for describing and reasoning about cyclic
datatypes. We extract the "fold" computation rules from the categorical
semantics based on iteration categories of Bloom and Esik. Thereby, the rules
are correct by construction. We prove strong normalisation using the General
Schema criterion for second-order computation rules. Rather than the fixed
point law, we particularly choose Bekic law for computation, which is a key to
obtaining strong normalisation. We also prove the property of "Church-Rosser
modulo bisimulation" for the computation rules. Combining these results, we
have a remarkable decidability result of the equational theory of cyclic data
and fold.Comment: 38 page
Dual-Context Calculi for Modal Logic
We present natural deduction systems and associated modal lambda calculi for
the necessity fragments of the normal modal logics K, T, K4, GL and S4. These
systems are in the dual-context style: they feature two distinct zones of
assumptions, one of which can be thought as modal, and the other as
intuitionistic. We show that these calculi have their roots in in sequent
calculi. We then investigate their metatheory, equip them with a confluent and
strongly normalizing notion of reduction, and show that they coincide with the
usual Hilbert systems up to provability. Finally, we investigate a categorical
semantics which interprets the modality as a product-preserving functor.Comment: Full version of article previously presented at LICS 2017 (see
arXiv:1602.04860v4 or doi: 10.1109/LICS.2017.8005089
Generic Trace Semantics via Coinduction
Trace semantics has been defined for various kinds of state-based systems,
notably with different forms of branching such as non-determinism vs.
probability. In this paper we claim to identify one underlying mathematical
structure behind these "trace semantics," namely coinduction in a Kleisli
category. This claim is based on our technical result that, under a suitably
order-enriched setting, a final coalgebra in a Kleisli category is given by an
initial algebra in the category Sets. Formerly the theory of coalgebras has
been employed mostly in Sets where coinduction yields a finer process semantics
of bisimilarity. Therefore this paper extends the application field of
coalgebras, providing a new instance of the principle "process semantics via
coinduction."Comment: To appear in Logical Methods in Computer Science. 36 page
Strongly Normalising Cyclic Data Computation by Iteration Categories of Second-Order Algebraic Theories
Cyclic data structures, such as cyclic lists, in functional
programming are tricky to handle because of their cyclicity. This
paper presents an investigation of categorical, algebraic, and
computational foundations of cyclic datatypes. Our framework of
cyclic datatypes is based on second-order algebraic theories of Fiore
et al., which give a uniform setting for syntax, types, and
computation rules for describing and reasoning about cyclic datatypes.
We extract the ``fold\u27\u27 computation rules from the categorical
semantics based on iteration categories of Bloom and Esik. Thereby,
the rules are correct by construction. Finally, we prove strong
normalisation using the General Schema criterion for second-order
computation rules. Rather than the fixed point law, we particularly
choose Bekic law for computation, which is a key to obtaining strong
normalisation
Iteration Algebras for UnQL Graphs and Completeness for Bisimulation
This paper shows an application of Bloom and Esik's iteration algebras to
model graph data in a graph database query language. About twenty years ago,
Buneman et al. developed a graph database query language UnQL on the top of a
functional meta-language UnCAL for describing and manipulating graphs.
Recently, the functional programming community has shown renewed interest in
UnCAL, because it provides an efficient graph transformation language which is
useful for various applications, such as bidirectional computation. However, no
mathematical semantics of UnQL/UnCAL graphs has been developed. In this paper,
we give an equational axiomatisation and algebraic semantics of UnCAL graphs.
The main result of this paper is to prove that completeness of our equational
axioms for UnCAL for the original bisimulation of UnCAL graphs via iteration
algebras. Another benefit of algebraic semantics is a clean characterisation of
structural recursion on graphs using free iteration algebra.Comment: In Proceedings FICS 2015, arXiv:1509.0282
A principled approach to programming with nested types in Haskell
Initial algebra semantics is one of the cornerstones of the theory of modern functional programming languages. For each inductive data type, it provides a Church encoding for that type, a build combinator which constructs data of that type, a fold combinator which encapsulates structured recursion over data of that type, and a fold/build rule which optimises modular programs by eliminating from them data constructed using the buildcombinator, and immediately consumed using the foldcombinator, for that type. It has long been thought that initial algebra semantics is not expressive enough to provide a similar foundation for programming with nested types in Haskell. Specifically, the standard folds derived from initial algebra semantics have been considered too weak to capture commonly occurring patterns of recursion over data of nested types in Haskell, and no build combinators or fold/build rules have until now been defined for nested types. This paper shows that standard folds are, in fact, sufficiently expressive for programming with nested types in Haskell. It also defines buildcombinators and fold/build fusion rules for nested types. It thus shows how initial algebra semantics provides a principled, expressive, and elegant foundation for programming with nested types in Haskell
- …