13,237 research outputs found
Introducing a Calculus of Effects and Handlers for Natural Language Semantics
In compositional model-theoretic semantics, researchers assemble
truth-conditions or other kinds of denotations using the lambda calculus. It
was previously observed that the lambda terms and/or the denotations studied
tend to follow the same pattern: they are instances of a monad. In this paper,
we present an extension of the simply-typed lambda calculus that exploits this
uniformity using the recently discovered technique of effect handlers. We prove
that our calculus exhibits some of the key formal properties of the lambda
calculus and we use it to construct a modular semantics for a small fragment
that involves multiple distinct semantic phenomena
Elements of mathematics and logic for computer program analysis
1 Introduction 2 Induction and sequences 2.1 Induction on natural numbers 2.2 Words and sequences 2.3 A digression on set theory 2.4 Induction on words 2.5 Grammar rules and string rewriting 3 Terms 3.1 Definition of terms 3.2 Knaster-Tarski's fixpoint theorem (1927) 3.3 Kleene's fixpoint theorem (1952?) 3.4 Pattern matching and term rewriting 3.5 Models of a term algebra 4 Lambda-calculus 4.1 Definition of λ-calculus 4.2 Church-computable functions 4.3 Kleene-computable functions 4.4 Turing-computable functions 5 Simply-typed lambda-calculus 5.1 Curry-style simply-typed λ-calculus . 5.2 Unification 5.3 Type inference 5.4 Church-style simply-typed λ-calculus 6 First-order logic 6.1 Formulas and truth 6.2 Provability and deduction systems 6.3 Proof terms and Curry-Howard correspondence 7 To go further 8 Solutions to exercises 8.1 Section 2: Induction and sequences 8.2 Section 3: Terms 8.3 Section 4: Lambda-calculus 8.4 Section 5: Simply-typed lambda-calculus 8.5 Section 6: First-order logicMasterIn order to be able to rigorously prove the correctness of a program, one must have a formal definition of: what is a program, syntactically; how it is evaluated, that is, what is its semantics; how to formulate the properties we are interested in; and how to prove them. All this requires to understand some basic mathematical notions like induction, terms, formulas, deduction, etc. These notes are intended to give an introduction to some of these notions
Inductive-data-type Systems
In a previous work ("Abstract Data Type Systems", TCS 173(2), 1997), the last
two authors presented a combined language made of a (strongly normalizing)
algebraic rewrite system and a typed lambda-calculus enriched by
pattern-matching definitions following a certain format, called the "General
Schema", which generalizes the usual recursor definitions for natural numbers
and similar "basic inductive types". This combined language was shown to be
strongly normalizing. The purpose of this paper is to reformulate and extend
the General Schema in order to make it easily extensible, to capture a more
general class of inductive types, called "strictly positive", and to ease the
strong normalization proof of the resulting system. This result provides a
computation model for the combination of an algebraic specification language
based on abstract data types and of a strongly typed functional language with
strictly positive inductive types.Comment: Theoretical Computer Science (2002
A Calculus with Partially Dynamic Records for Typeful Manipulation of JSON Objects
This paper investigates language constructs for high-level and
type-safe manipulation of JSON objects in a typed functional language. A major obstacle in representing JSON in a static type system is their heterogeneous nature: in most practical JSON APIs, a JSON array is a heterogeneous list consisting of, for example, objects having common fields and possibly some optional fields. This paper presents a typed calculus that reconciles static typing constraints and heterogeneous JSON arrays based on the idea of partially dynamic records originally proposed and sketched by Buneman and Ohori for complex database object manipulation. Partially dynamic records are dynamically typed records, but some parts of their structures are statically known. This feature enables us to represent JSON objects as typed data structures. The proposed calculus smoothly extends with ML-style pattern matching and record polymorphism. These results yield a typed functional language where the programmer can directly import JSON data as terms having static types, and can manipulate them with the full
benefits of static polymorphic type-checking. The proposed calculus
has been embodied in SML#, an extension of Standard ML with record
polymorphism and other practically useful features. This paper also
reports on the details of the implementation and demonstrates its
feasibility through examples using actual Web APIs. The SML# version 3.1.0 compiler includes JSON support presented in this paper, and is available from Tohoku University as open-source software under a BSD-style license
A Typed Calculus for Querying Distributed XML Documents
We study the problems related to querying large, distributed XML documents. Our proposal takes the form of a new process calculus in which XML data are processes that can be queried by means of concurrent pattern-matching expressions. What we achieve is a functional, strongly-typed programming model based on three main ingredients: an asynchronous process calculus in the style of Milner's pi-calculus and existing semantics for concurrent-ML; a model where documents and expressions are both represented as processes, and where evaluation is represented as a parallel composition of the two; a static type system based on regular expression types
Behavioural Types for Actor Systems
Recent mainstream programming languages such as Erlang or Scala have renewed
the interest on the Actor model of concurrency. However, the literature on the
static analysis of actor systems is still lacking of mature formal methods. In
this paper we present a minimal actor calculus that takes as primitive the
basic constructs of Scala's Actors API. More precisely, actors can send
asynchronous messages, process received messages according to a pattern
matching mechanism, and dynamically create new actors, whose scope can be
extruded by passing actor names as message parameters. Drawing inspiration from
the linear types and session type theories developed for process calculi, we
put forward a behavioural type system that addresses the key issues of an actor
calculus. We then study a safety property dealing with the determinism of
finite actor com- munication. More precisely, we show that well typed and
balanced actor systems are (i) deadlock-free and (ii) any message will
eventually be handled by the target actor, and dually no actor will
indefinitely wait for an expected messag
Rewriting Modulo \beta in the \lambda\Pi-Calculus Modulo
The lambda-Pi-calculus Modulo is a variant of the lambda-calculus with
dependent types where beta-conversion is extended with user-defined rewrite
rules. It is an expressive logical framework and has been used to encode logics
and type systems in a shallow way. Basic properties such as subject reduction
or uniqueness of types do not hold in general in the lambda-Pi-calculus Modulo.
However, they hold if the rewrite system generated by the rewrite rules
together with beta-reduction is confluent. But this is too restrictive. To
handle the case where non confluence comes from the interference between the
beta-reduction and rewrite rules with lambda-abstraction on their left-hand
side, we introduce a notion of rewriting modulo beta for the lambda-Pi-calculus
Modulo. We prove that confluence of rewriting modulo beta is enough to ensure
subject reduction and uniqueness of types. We achieve our goal by encoding the
lambda-Pi-calculus Modulo into Higher-Order Rewrite System (HRS). As a
consequence, we also make the confluence results for HRSs available for the
lambda-Pi-calculus Modulo.Comment: In Proceedings LFMTP 2015, arXiv:1507.0759
A type system for components
In modern distributed systems, dynamic reconfiguration, i.e.,
changing at runtime the communication pattern of a program, is chal-
lenging. Generally, it is difficult to guarantee that such modifications will
not disrupt ongoing computations. In a previous paper, a solution to this
problem was proposed by extending the object-oriented language ABS
with a component model allowing the programmer to: i) perform up-
dates on objects by means of communication ports and their rebinding;
and ii) precisely specify when such updates can safely occur in an object
by means of critical sections. However, improper rebind operations could
still occur and lead to runtime errors. The present paper introduces a
type system for this component model that extends the ABS type system
with the notion of ports and a precise analysis that statically enforces
that no object will attempt illegal rebinding
A Calculus of Looping Sequences with Local Rules
In this paper we present a variant of the Calculus of Looping Sequences (CLS
for short) with global and local rewrite rules. While global rules, as in CLS,
are applied anywhere in a given term, local rules can only be applied in the
compartment on which they are defined. Local rules are dynamic: they can be
added, moved and erased. We enrich the new calculus with a parallel semantics
where a reduction step is lead by any number of global and local rules that
could be performed in parallel. A type system is developed to enforce the
property that a compartment must contain only local rules with specific
features. As a running example we model some interactions happening in a cell
starting from its nucleus and moving towards its mitochondria.Comment: In Proceedings DCM 2011, arXiv:1207.682
- …