3,360 research outputs found
Alpha-Structural Induction and Recursion for the Lambda Calculus in Constructive Type Theory
We formulate principles of induction and recursion for a variant of lambda calculus in its original syntax (i.e., with only one sort of names) where alpha-conversion is based upon name swapping as in nominal abstract syntax. The principles allow to work modulo alpha-conversion and implement the Barendregt variable convention. We derive them all from the simple structural induction principle on concrete terms and work out applications to some fundamental meta-theoretical results, such as the substitution lemma for alpha-conversion and the lemma on substitution composition. The whole work is implemented in Agda
A dependent nominal type theory
Nominal abstract syntax is an approach to representing names and binding
pioneered by Gabbay and Pitts. So far nominal techniques have mostly been
studied using classical logic or model theory, not type theory. Nominal
extensions to simple, dependent and ML-like polymorphic languages have been
studied, but decidability and normalization results have only been established
for simple nominal type theories. We present a LF-style dependent type theory
extended with name-abstraction types, prove soundness and decidability of
beta-eta-equivalence checking, discuss adequacy and canonical forms via an
example, and discuss extensions such as dependently-typed recursion and
induction principles
A bound for Dickson's lemma
We consider a special case of Dickson's lemma: for any two functions on
the natural numbers there are two numbers such that both and
weakly increase on them, i.e., and . By a
combinatorial argument (due to the first author) a simple bound for such
is constructed. The combinatorics is based on the finite pigeon hole principle
and results in a descent lemma. From the descent lemma one can prove Dickson's
lemma, then guess what the bound might be, and verify it by an appropriate
proof. We also extract (via realizability) a bound from (a formalization of)
our proof of the descent lemma.
Keywords: Dickson's lemma, finite pigeon hole principle, program extraction
from proofs, non-computational quantifiers
From Lock Freedom to Progress Using Session Types
Inspired by Kobayashi's type system for lock freedom, we define a behavioral
type system for ensuring progress in a language of binary sessions. The key
idea is to annotate actions in session types with priorities representing the
urgency with which such actions must be performed and to verify that processes
perform such actions with the required priority. Compared to related systems
for session-based languages, the presented type system is relatively simpler
and establishes progress for a wider range of processes.Comment: In Proceedings PLACES 2013, arXiv:1312.221
Reversing Single Sessions
Session-based communication has gained a widespread acceptance in practice as
a means for developing safe communicating systems via structured interactions.
In this paper, we investigate how these structured interactions are affected by
reversibility, which provides a computational model allowing executed
interactions to be undone. In particular, we provide a systematic study of the
integration of different notions of reversibility in both binary and multiparty
single sessions. The considered forms of reversibility are: one for completely
reversing a given session with one backward step, and another for also
restoring any intermediate state of the session with either one backward step
or multiple ones. We analyse the costs of reversing a session in all these
different settings. Our results show that extending binary single sessions to
multiparty ones does not affect the reversibility machinery and its costs
Recursion Aware Modeling and Discovery For Hierarchical Software Event Log Analysis (Extended)
This extended paper presents 1) a novel hierarchy and recursion extension to
the process tree model; and 2) the first, recursion aware process model
discovery technique that leverages hierarchical information in event logs,
typically available for software systems. This technique allows us to analyze
the operational processes of software systems under real-life conditions at
multiple levels of granularity. The work can be positioned in-between reverse
engineering and process mining. An implementation of the proposed approach is
available as a ProM plugin. Experimental results based on real-life (software)
event logs demonstrate the feasibility and usefulness of the approach and show
the huge potential to speed up discovery by exploiting the available hierarchy.Comment: Extended version (14 pages total) of the paper Recursion Aware
Modeling and Discovery For Hierarchical Software Event Log Analysis. This
Technical Report version includes the guarantee proofs for the proposed
discovery algorithm
A thread calculus with molecular dynamics
We present a theory of threads, interleaving of threads, and interaction
between threads and services with features of molecular dynamics, a model of
computation that bears on computations in which dynamic data structures are
involved. Threads can interact with services of which the states consist of
structured data objects and computations take place by means of actions which
may change the structure of the data objects. The features introduced include
restriction of the scope of names used in threads to refer to data objects.
Because that feature makes it troublesome to provide a model based on
structural operational semantics and bisimulation, we construct a projective
limit model for the theory.Comment: 47 pages; examples and results added, phrasing improved, references
replace
- …