274 research outputs found
Semantics for first-order affine inductive data types via slice categories
Affine type systems are substructural type systems where copying of
information is restricted, but discarding of information is permissible at all
types. Such type systems are well-suited for describing quantum programming
languages, because copying of quantum information violates the laws of quantum
mechanics. In this paper, we consider a first-order affine type system with
inductive data types and present a novel categorical semantics for it. The most
challenging aspect of this interpretation comes from the requirement to
construct appropriate discarding maps for our data types which might be defined
by mutual/nested recursion. We show how to achieve this for all types by taking
models of a first-order linear type system whose atomic types are discardable
and then presenting an additional affine interpretation of types within the
slice category of the model with the tensor unit. We present some concrete
categorical models for the language ranging from classical to quantum. Finally,
we discuss potential ways of dualising and extending our methods and using them
for interpreting coalgebraic and lazy data types
Linear/non-Linear Types For Embedded Domain-Specific Languages
Domain-specific languages are often embedded inside of general-purpose host languages so that the embedded language can take advantage of host-language data structures, libraries, and tools. However, when the domain-specific language uses linear types, existing techniques for embedded languages fall short. Linear type systems, which have applications in a wide variety of programming domains including mutable state, I/O, concurrency, and quantum computing, can manipulate embedded non-linear data via the linear type !σ. However, prior work has not been able to produce linear embedded languages that have full and easy access to host-language data, libraries, and tools.
This dissertation proposes a new perspective on linear, embedded, domain-specific languages derived from the linear/non-linear (LNL) interpretation of linear logic. The LNL model consists of two distinct fragments---one with linear types and another with non-linear types---and provides a simple categorical interface between the two. This dissertation identifies the linear fragment with the linear embedded language and the non-linear fragment with the general-purpose host language.
The effectiveness of this framework is illustrated via a number of examples, implemented in a variety of host languages. In Haskell, linear domain-specific languages using mutable state and concurrency can take advantage of the monad that arises from the LNL model. In Coq, the QWIRE quantum circuit language uses linearity to enforce the no-cloning axiom of quantum mechanics. In homotopy type theory, quantum transformations can be encoded as higher inductive types to simplify the presentation of a quantum equational theory. These examples serve as case studies that prove linear/non-linear type theory is a natural and expressive interface in which to embed linear domain-specific languages
Introduction to linear logic and ludics, part II
This paper is the second part of an introduction to linear logic and ludics,
both due to Girard. It is devoted to proof nets, in the limited, yet central,
framework of multiplicative linear logic and to ludics, which has been recently
developped in an aim of further unveiling the fundamental interactive nature of
computation and logic. We hope to offer a few computer science insights into
this new theory
A Static Analyzer for Large Safety-Critical Software
We show that abstract interpretation-based static program analysis can be
made efficient and precise enough to formally verify a class of properties for
a family of large programs with few or no false alarms. This is achieved by
refinement of a general purpose static analyzer and later adaptation to
particular programs of the family by the end-user through parametrization. This
is applied to the proof of soundness of data manipulation operations at the
machine level for periodic synchronous safety critical embedded software. The
main novelties are the design principle of static analyzers by refinement and
adaptation through parametrization, the symbolic manipulation of expressions to
improve the precision of abstract transfer functions, the octagon, ellipsoid,
and decision tree abstract domains, all with sound handling of rounding errors
in floating point computations, widening strategies (with thresholds, delayed)
and the automatic determination of the parameters (parametrized packing)
Implicit automata in typed -calculi II: streaming transducers vs categorical semantics
We characterize regular string transductions as programs in a linear
-calculus with additives. One direction of this equivalence is proved
by encoding copyless streaming string transducers (SSTs), which compute regular
functions, into our -calculus. For the converse, we consider a
categorical framework for defining automata and transducers over words, which
allows us to relate register updates in SSTs to the semantics of the linear
-calculus in a suitable monoidal closed category. To illustrate the
relevance of monoidal closure to automata theory, we also leverage this notion
to give abstract generalizations of the arguments showing that copyless SSTs
may be determinized and that the composition of two regular functions may be
implemented by a copyless SST. Our main result is then generalized from strings
to trees using a similar approach. In doing so, we exhibit a connection between
a feature of streaming tree transducers and the multiplicative/additive
distinction of linear logic.
Keywords: MSO transductions, implicit complexity, Dialectica categories,
Church encodingsComment: 105 pages, 24 figure
Internal Parametricity for Cubical Type Theory
We define a computational type theory combining the contentful equality
structure of cartesian cubical type theory with internal parametricity
primitives. The combined theory supports both univalence and its relational
equivalent, which we call relativity. We demonstrate the use of the theory by
analyzing polymorphic functions between higher inductive types, observe how
cubical equality regularizes parametric type theory, and examine the
similarities and discrepancies between cubical and parametric type theory,
which are closely related. We also abstract a formal interface to the
computational interpretation and show that this also has a presheaf model
String Diagrams for Non-Strict Monoidal Categories
Whereas string diagrams for strict monoidal categories are well understood, and have found application in several fields of Computer Science, graphical formalisms for non-strict monoidal categories are far less studied. In this paper, we provide a presentation by generators and relations of string diagrams for non-strict monoidal categories, and show how this construction can handle applications in domains such as digital circuits and programming languages. We prove the correctness of our construction, which yields a novel proof of Mac Lane’s strictness theorem. This in turn leads to an elementary graphical proof of Mac Lane’s coherence theorem, and in particular allows for the inductive construction of the canonical isomorphisms in a monoidal category
String Diagrams for Non-Strict Monoidal Categories
Whereas string diagrams for strict monoidal categories are well understood,
and have found application in several fields of Computer Science, graphical
formalisms for non-strict monoidal categories are far less studied. In this
paper, we provide a presentation by generators and relations of string diagrams
for non-strict monoidal categories, and show how this construction can handle
applications in domains such as digital circuits and programming languages. We
prove the correctness of our construction, which yields a novel proof of Mac
Lane's strictness theorem. This in turn leads to an elementary graphical proof
of Mac Lane's coherence theorem, and in particular allows for the inductive
construction of the canonical isomorphisms in a monoidal category
- …