Average-based Population Protocols : Explicit and Tight Bounds of the Convergence Time

This paper describes a fibrational categorical semantics for the modal necessity-only fragment of constructive modal type theory, both with and without dependent types. Constructive type theory does not usually discuss logical modalities, and modalities tend to be mostly studied within classical logic, not within type theory. But modalities should be very useful in type theory, as they are very useful in modelling theoretical computing systems. Providing constructive versions of modal logics and their associated Curry-Howard modal type theories is also a very productive program, e.g. helpful when dealing with computational effects, staged computation, and functional reactive types, for example. There seems to be renewed interest in the notion of constructive modal type theory (and in notions of linear type theory), in part because of the interest in homotopy type theory. The modal type theory presented here uses dependent types, in the style of Ritter's categorical models of the Calculus of Constructions. To build up to these, we first discuss the kinds of constructive modal type theory in the literature. Then we provide a non-dependent modal type theory, introduced in previous work, that we generalize to dependent types in the following section. Dependent type theories are usually but not always given categorical semantics in terms of fibrations. We provide semantics in terms of fibrations for both the non-dependent and the dependent type systems discussed and prove them sound and complete, thereby providing evidence that the type theory is meaningful. These fibrational models should be also applicable to the homotopy type theory setting.

This paper presents the design, the implementation, and experiments of the integration of syntactic, conditional possibly associative-commutative term rewriting into proof assistants based on constructive type theory. Our approach is called external because it consists in performing term rewriting in a specific and efficient environment and checking the computations later in a proof assistant. Two typical systems are considered in this work: ELAN, based on the rewriting calculus, as the term rewriting-based environment, and Coq, based on the calculus of inductive constructions as the proof assistant. We first formalize the proof terms for deduction by rewriting and strategies in ELAN using the rewriting calculus with explicit substitutions. We then show how these proof terms can soundly be translated into Coq syntax where they can be directly type checked. For the method to be applicable for rewriting modulo associativity and commutativity, we provide an effective method to prove equalities modulo these axioms in Coq using ELAN. These results have been integrated into an ELAN-based rewriting tactic in Coq.

Quotient topologies in constructive set theory and type theory

This is the first of two articles dedicated to the notion of constructive set. In them we attempt a comparison between two different notions of set which occur in the context of the foundations for constructive mathematics. We also put them under perspective by stressing analogies and differences with the notion of set as codified in the classical theory Zermelo–Fraenkel. In the current article we illustrate in some detail the notion of set as expressed in Martin–L¨of type theory and present the essential characters of this theory. In a second article we shall explore a distinct notion of set, as arising in the context of intuitionistic versions of Zermelo–Fraenkel set theory. The theory we shall analyse there is Aczel’s CZF (Constructive Zermelo– Fraenkel) and we shall supplement its exposition by a succinct account of Aczel’s interpretation of CZF in type theory. This will enable us to compare the two notions in a more precise sense.

An intuitionistic theory of types with assumptions of high-arity variables

On declarative rewriting for sound and complete union, intersection and negation types

A mechanical proof of the Knuth---Bendix Critical Pair Theorem in the higher-order language of the theorem prover PVS is described. This well-known theorem states that a Term Rewriting System is locally confluent if and only if all its critical pairs are joinable. The formalization of this theorem follows Huet's well-known structure of proof in which the restriction on strong normalization or Noetherian was dropped and the result presented as a lemma. In order to formalize the Knuth---Bendix Critical Pair Theorem we rely on previously developed PVS theories for abstract reduction systems, named ars, and term rewriting systems, named trs, which were built upon the PVS libraries for finite sequences and sets. On the one hand, the theory trs is composed of subtheories for dealing with the structure of terms, for replacements of subterms and substitutions and jointly with the theory ars it allows for adequate specifications of elaborate notions of term rewriting systems such as the one of critical pairs. On the other hand, ars specifies basic definitions and notions of abstract reduction systems such as reduction, termination, normal forms, and confluence as well as non basic concepts such as strong normalization.

G. Huet and J.J. Levy (INRIA Rep. 359, 1979) showed that for every strongly sequential orthogonal (i.e., left-linear and non-overlapping) term rewriting system, index reduction strategy is normalizing. Their result is extended to overlapping term rewriting systems. It is shown that index reduction is normalizing for the class of strongly sequential left-linear term rewriting systems in which every critical pair can be joined with root balanced reductions. This class includes all weakly orthogonal left-normal systems, for which a leftmost-outermost reduction strategy is normalizing. >

Martin-Lof's intuitionistic type theory (ITT) can be regarded as a programming logic. Yet its data type aspect has not been much addressed. In the present paper we show how to introduce the data types in ITT in a systematic way. The main tool is data logic. Data logics are introduced in [12], which are many-sorted second order theories. For a given data type we can establish its data logic, i.e. a set of non-logical axioms, then from the axioms its rules in ITT can be obtained.

We give two finite axiomatizations of indexed inductive-recursive definitions in intuitionistic type theory. They extend our previous finite axiomatizations of inductive-recursive definitions of sets to indexed families of sets and encompass virtually all definitions of sets which have been used in intuitionistic type theory. The more restricted of the two axiomatization arises naturally by considering indexed inductive-recursive definitions as initial algebras in slice categories, whereas the other admits a more general and convenient form of an introduction rule.The class of indexed inductive-recursive definitions properly contains the class of indexed inductive definitions (so called “inductive families”). Such definitions are ubiquitous when using intuitionistic type theory for formalizing mathematics and program correctness. A side effect of the present paper is to get compact finite axiomatizations of indexed inductive definitions in intuitionistic type theory as special cases.Proper indexed inductive-recursive definitions (those which do not correspond to indexed inductive definitions) are useful in intuitionistic metamathematics, and as an example we formalize Tait-style computability predicates for dependent types. We also show that Palmgren’s prooftheoretically strong construction of higher-order universes is an example of a proper indexed inductive-recursive definition. A third interesting example is provided by Bove and Capretta’s definition of termination predicates for functions defined by nested recursion.Our axiomatizations form a powerful foundation for generic programming with dependent types by introducing a type of codes for indexed inductive-recursive definitions and making it possible to define generic functions by recursion on this type.KeywordsDependent type theoryMartin-Löf Type Theoryinductive definitionsinductive-recursive definitionsinductive familiesinitial algebrasnormalization proofsgeneric programming

The first example of a simultaneous inductive-recursive definition in intuitionistic type theory is Martin-Löfs universe à la Tarski. A set U0of codes for small sets is generated inductively at the same time as a function T0, which maps a code to the corresponding small set, is defined by recursion on the way the elements of U0are generated.In this paper we argue that there is an underlyinggeneralnotion of simultaneous inductive-recursive definition which is implicit in Martin-Löf's intuitionistic type theory. We extend previously given schematic formulations of inductive definitions in type theory to encompass a general notion of simultaneous induction-recursion. This enables us to give a unified treatment of several interesting constructions including various universe constructions by Palmgren, Griffor, Rathjen, and Setzer and a constructive version of Aczel's Frege structures. Consistency of a restricted version of the extension is shown by constructing a realisability model in the style of Allen.

Martin-Lof’s Constructive Type Theory (CTT) is a formal language developed in order to reason constructively about mathematics. It is thus a formal language conceived primarily as a tool to reason with rather than a formal language conceived primarily as a mathematical system to reason about. Constructive Type Theory is therefore much closer in spirit to Frege’s ideography and to the language of Russell and Whitehead’s Principia Mathematica than to the majority of logical systems (“logics”) studied by contemporary logicians. Since CTT is designed as a language to reason with, much attention is paid to the explanation of basic concepts. This is perhaps the main reason why the style of presentation of CTT differs somewhat from the style of presentation typically found in, for instance, ordinary logic textbooks. For those new to the system it might be useful to approach an introduction, such as the one given below, more as a language course than as a course in mathematics.

In this article we continue the work started in [Ernesto Copello, Álvaro Tasistro, Nora Szasz, Ana Bove, and Maribel Fernández. Alpha-structural induction and recursion for the λ-calculus in constructive type theory. Electronic Notes in Theoretical Computer Science, 323:109–124, 2016], deriving in Constructive Type Theory new induction principles for the λ-calculus, using (the historical) first order syntax with only one sort of names for both bound and free variables, and with α-conversion based upon name swapping. The principles provide a flexible framework for mimicking pen-and-paper proofs within the rigorous formal setting of a proof assistant. We here report on one successful application, namely a complete proof of the Church-Rosser Theorem. The whole development has been machine-checked using the system Agda [Ulf Norell. Towards a Practical Programming Language Based on Dependent Type Theory. PhD thesis, Department of Computer Science and Engineering, Chalmers University of Technology, September 2007].

The aim of this book is to show how constructive type theory, in the form developed by Per Martin-Löf, helps us to understand the structure of natural language. The study of similar questions within simple (=classical) type theory was inaugurated by Frege and given a standard of technical detail by Montague. The point of shifting to constructive type theory is not in the constructivist criticism against classical reasoning, but in the positive observation that constructive type theory has new things to say. Some of the problems to which grammars based on classical type theory have not found satisfactory solutions will be shown to require precisely these new things. These problems appear in a simple form in what is known, since Geach, as donkey sentences. But they are repeated in other guises, for example, in the functioning of tenses, and in a larger scale, such as in the progressive structure of texts, and in the significance of context in communication.

Proof assistants based on dependent type theory are closely related to functional programming languages, and so it is tempting to use them to prove the correctness of functional programs. In this paper, we show how Agda, such a proof assistant, can be used to prove theorems about Haskell programs. Haskell programs are translated into an Agda model of their semantics, by translating via GHC's Core language into a monadic form specially adapted to represent Haskell's polymorphism in Agda's predicative type system. The translation can support reasoning about either total values only, or total and partial values, by instantiating the monad appropriately. We claim that, although these Agda models are generated by a relatively complex translation process, proofs about them are simple and natural, and we offer a number of examples to support this claim.