Carsten Schürmann

Bio: Carsten Schürmann is an academic researcher from IT University of Copenhagen. The author has contributed to research in topics: Logical framework & Twelf. The author has an hindex of 23, co-authored 73 publications receiving 2039 citations. Previous affiliations of Carsten Schürmann include Yale University & Carnegie Mellon University.

System Description: Twelf - A Meta-Logical Framework for Deductive Systems

Abstract: Twelf is a meta-logical framework for the specification, implementation, and meta-theory of deductive systems from the theory of programming languages and logics. It relies on the LF type theory and the judgments-as-types methodology for specification [HHP93], a constraint logic programming interpreter for implementation [Pfe91], and the meta-logic M2 for reasoning about object languages encoded in LF [SP98]. It is a significant extension and complete reimplementation of the Elf system [Pfe94]. Twelf is written in Standard ML and runs under SML of New Jersey and MLWorks on Unix and Window platforms. The current version (1.2) is distributed with a complete manual, example suites, a tutorial in the form of on-line lecture notes [Pfe], and an Emacs interface. Source and binary distributions are accessible via the Twelf home page http://www.cs.cmu.edu/~twelf.

Automating the meta theory of deductive systems

Abstract: This thesis describes the design of a meta-logical framework that supports the representation and verification of deductive systems, its implementation as an automated theorem prover, and experimental results related to the areas of programming languages, type theory, and logics. Design. The meta-logical framework extends the logical framework LF [HHP93] by a meta-logic M+2 . This design is novel and unique since it allows higher-order encodings of deductive systems and induction principles to coexist. On the one hand, higher-order representation techniques lead to concise and direct encodings of programming languages and logic calculi. Inductive definitions on the other hand allow the formalization of properties about deductive systems, such as the proof that an operational semantics preserves types or the proof that a logic is consistent. M+2 is a proof calculus whose proof terms are recursive functions that may be defined by cases and range over dependent higher-order types. The soundness of M+2 follows from a realizability interpretation of proof terms as total recursive functions. Implementation. A proof search algorithm for proof terms in M+2 is implemented in the metatheorem prover that is part of the Twelf system [PS99b]. Its takes full advantage of higher-order encodings while using inductive reasoning. Experiments. Twelf has been used for many experiments. Among others, it proved automatically the Church-Rosser theorem for the simply-typed λ-calculus and the cut-elimination theorem for intuitionistic first-order logic. In programming languages, it proved various type preservation theorems for different operational semantics and compiler correctness theorems. In logics, it was able to derive the equivalence of various logic calculi, such as the natural deduction calculus, the sequent calculus, and the Hilbert calculus. Twelf also proved that Cartesian closed categories can be embedded into the simply-typed λ-calculus. In the special domains of programming languages, type theory, and logics, Twelf's reasoning power far exceeds that of any other theorem prover.

Practical programming with higher-order encodings and dependent types

Abstract: Higher-order abstract syntax (HOAS) refers to the technique of representing variables of an object-language using variables of a meta-language. The standard first-order alternatives force the programmer to deal with superficial concerns such as substitutions, whose implementation is often routine, tedious, and error-prone. In this paper, we describe the underlying calculus of Delphin. Delphin is a fully implemented functional-programming language supporting reasoning over higher-order encodings and dependent types, while maintaining the benefits of HOAS. More specifically, just as representations utilizing HOAS free the programmer from concerns of handling explicit contexts and substitutions, our system permits programming over such encodings without making these constructs explicit, leading to concise and elegant programs. To this end our system distinguishes bindings of variables intended for instantiation from those that will remain uninstantiated, utilizing a variation of Miller and Tiu's ∇-quantifier [1].

Microservices: Yesterday, Today, and Tomorrow

Abstract: Microservices is an architectural style inspired by service-oriented computing that has recently started gaining popularity. Before presenting the current state of the art in the field, this chapter reviews the history of software architecture, the reasons that led to the diffusion of objects and services first, and microservices later. Finally, open problems and future challenges are introduced. This survey primarily addresses newcomers to the discipline, while offering an academic viewpoint on the topic. In addition, we investigate some practical issues and point out a few potential solutions.

Towards a practical programming language based on dependent type theory

Abstract: Dependent type theories have a long history of being used for theorem proving One aspect of type theory which makes it very powerful as a proof language is that it mixes deduction with computation This also makes type theory a good candidate for programming---the strength of the type system allows properties of programs to be stated and established, and the computational properties provide semantics for the programs This thesis is concerned with bridging the gap between the theoretical presentations of type theory and the requirements on a practical programming language Although there are many challenging research problems left to solve before we have an industrial scale programming language based on type theory, this thesis takes us a good step along the way

System Description: Twelf - A Meta-Logical Framework for Deductive Systems

Abstract: Twelf is a meta-logical framework for the specification, implementation, and meta-theory of deductive systems from the theory of programming languages and logics. It relies on the LF type theory and the judgments-as-types methodology for specification [HHP93], a constraint logic programming interpreter for implementation [Pfe91], and the meta-logic M2 for reasoning about object languages encoded in LF [SP98]. It is a significant extension and complete reimplementation of the Elf system [Pfe94]. Twelf is written in Standard ML and runs under SML of New Jersey and MLWorks on Unix and Window platforms. The current version (1.2) is distributed with a complete manual, example suites, a tutorial in the form of on-line lecture notes [Pfe], and an Emacs interface. Source and binary distributions are accessible via the Twelf home page http://www.cs.cmu.edu/~twelf.

Dependent types in practical programming

Abstract: We present an approach to enriching the type system of ML with a restricted form of dependent types, where type index objects are drawn from a constraint domain C, leading to the DML(C) language schema. This allows specification and inference of significantly more precise type information, facilitating program error detection and compiler optimization. A major complication resulting from introducing dependent types is that pure type inference for the enriched system is no longer possible, but we show that type-checking a sufficiently annotated program in DML(C) can be reduced to constraint satisfaction in the constraint domain C. We exhibit the unobtrusiveness of our approach through practical examples and prove that DML(C) is conservative over ML. The main contribution of the paper lies in our language design, including the formulation of type-checking rules which makes the approach practical. To our knowledge, no previous type system for a general purpose programming language such as ML has combined dependent types with features including datatype declarations, higher-order functions, general recursions, let-polymorphism, mutable references, and exceptions. In addition, we have finished a prototype implementation of DML(C) for an integer constraint domain C, where constraints are linear inequalities (Xi and Pfenning 1998).