Normalization for fitch-style modal calculi

In this paper we discuss usability, and propose to take that notion as a formalisation of (un)definedness in typed lambda calculus, especially in calculi based on PCF. We discuss some important properties that make usability attractive as a formalisation of (un)definedness. There is a remarkable difference between usability and solvability: in the untyped lambda calculus the solvable terms are precisely the terms with a head normal form, whereas in typed lambda calculus the usable terms are between the terms with a normal form and the terms with a (weak) head normal form.

Three versions of the lambda calculus are discussed: typed lambda calculus, untyped lambda calculus, and polymorphically typed lambda calculus. It is shown that the syntax for these calculi can be described as initial algebras for suitable endofunctors. Models of the first two calculi are described as in [Lambek and Scott 1985] and the Per model of the third is recalled. Algebraic types are described in terms of sketches. A main contribution of the paper is the internalization of the theory of sketches in the category Per. Sketches themselves, models of sketches, categories of models of sketches and the category of all models of all sketches can all be realized in this setting. Next, dinatural transformations are reviewed in the context of the category Per and the relation between certain end formulas and initial algebras for finite signatures is discussed. The point of the theory of algebraic semantics in Per is to provide a setting for thinking about algebraic types and algebraic operations in conjunction with logical types and polymorphic operations. Two specific examples are discussed and a general principle for combining algebraic and polymorphic operations is proposed.KeywordsNatural TransformationCategory TheoryLogical TypeDenotational SemanticGraph ObjectThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The present paper proposes a method by which to translate outputs of a robust HPSG parser into semantic representations of Typed Dynamic Logic (TDL), a dynamic plural semantics defined in typed lambda calculus. With its higher-order representations of contexts, TDL analyzes and describes the inherently inter-sentential nature of quantification and anaphora in a strictly lexicalized and compositional manner. The present study shows that the proposed translation method successfully combines robustness and descriptive adequacy of contemporary semantics. The present implementation achieves high coverage, approximately 90%, for the real text of the Penn Treebank corpus.

Parsing as logic deduction has become a latest approach in linguistics. HDS is an HPSG-deductive system basing on Martin-Löf typed lambda calculus. However, HDS is a formal system. HDS does not overtly include concrete parsing process. Therefore this paper presents an algorithm, which automatically finds out HDS deduction for concrete parsing. The feature of the algorithm is that it is type-driven and it is able to discover the possible phonologically null traces in a sentence and to fill traces with information so as to normalize these sentences. An application example shows validity of the algorithm.

Ever since Montague (1974 [1970]) laid the foundations for formally precise analysis of natural language (hereafter NL) semantics in the late 1960’s, the typed lambda calculus (hereafter TLC) and certain of its extensions have been the linguists’ tool of choice for representing the meanings of NL expressions. But starting around the turn of the millenium, motivated by a range of linguistic phenomena collectively known as covert movement phenomena, logical grammarians of various persuasions have proposed the use of other semantic term calculi that embody, directly or indirectly, some notion or other of continuation.

The aim of this work is to correlate two dierent approaches to the semantics of programming languages: game semantics and intersection type assignment systems (ITAS). Namely, we present an ITAS that provides the description of the semantic interpretation of a typed lambda calculus in a game model based on innocent strategies. Compared to the traditional ITAS used to describe the semantic interpretation in domain theoretic models, the ITAS presented in this paper has two main dierences: the introduction of a notion of labelling on moves, and the omission of several rules, i.e. the subtyping rules and some structural rules.

A typed lambda calculus with categorical type constructors is introduced. It has a uniform category theoretic mechanism to declare new types. Its type structure includes categorical objects like products and coproducts as well as recursive types like natural numbers and lists. It also allows duals of recursive types, i.e. lazy types, like infinite lists. It has generalized iterators for recursive types and duals of iterators for lazy types. We will give reduction rules for this simply typed lambda calculus and show that they are strongly normalizing even though it has infinite things like infinite lists.

This paper discusses the problem of finding common instances to terms in typed λ-calculus. It is shown that here the notion of most general unifier must be extended. Complete sets of unifiers are defined, and their structure with respect to substitution composition is studied.

The paper deals with the fundamental rule of extensional logics, namely the rule of Existential Generalization. This rule can be applied in the situation when a function f is applied on its argument a to obtain the value of f at a. If the application does not fail, i.e., if the function f is defined at a, then we can existentially quantify, and derive that there is the value f(a). Our system is based on Transparent Intensional Logic (TIL). Since TIL is a hyperintensional, partial, typed lambda calculus, we examine the validity of the rule in TIL, or rather in its computational variant the TIL-Script language. The rule is context sensitive in the sense that depending on a context we should recognize the type of entity to be abstracted over. This is not to say that the rule can be invalid dependently on context; the rule is valid universally. Only that the type of the argument over which we quantity depends on the context. There are three kinds of contexts to be distinguished, namely extensional, intensional and hyperintensonal. We introduce the definition of these three kinds of context and an algorithm that recognizes in which context a particular construction occurs so that the Existential Generalization can be validly applied. The tool navigates users through the correct application of the deduction rules.

The Typed Böhm Theorem

Narrative Semantics, Modal Logic and Fictional Possible Worlds

It is argued that some possible worlds are only contingently possible, and likewise that some impossible worlds are only contingently impossible. There are counterexamples to S5 modal logic and even to S4. What about B? Although there are no convincing grounds for supposing that even the actual world is only contingently possible, as far as the logic of modality is concerned (as opposed to the metaphysical reality), the actual world might instead have been impossible. The correct modal propositional logic is the simple system T.

We present the type rules for a dependently typed core calculus together with a straight-forward implementation in Haskell. We explicitly highlight the changes necessary to shift from a simply-typed lambda calculus to the dependently typed lambda calculus. We also describe how to extend our core language with data types and write several small example programs. The article is accompanied by an executable interpreter and example code that allows immediate experimentation with the system we describe.

This thesis proposes a novel way of performing type checking, whose results are incremental, depending on the provided local information. This new way of type checking is called co-contextual, where all context information of expressions, methods, classes, etc., is removed. Instead, we introduce corresponding structures using requirements. Standard type systems are translated to the co-contextual ones systematically using dualism as technique. Type systems play an important role to prevent execution errors from occurring during runtime. They are used to check programs statically for potential errors. Programs are type checked against a given set of rules. Depending on these rules programs are well-typed or not. The set of these rules is called typing rules. Each type rule associates types to the constructs of a program given a certain context. There can be different forms of contexts, depending on the features of the typed programming language. Functional languages use a typing context of variables and their types; object-oriented (OO) languages use additional class tables. Class tables are used for example to ensure that method and class declarations are well-typed. Type checking is performed top-down. While traversing the syntax tree of a program, typing contexts are extended with information on the expressions and their types. In case of OO, class tables are extended with clauses from class declarations, including the class members, i.e., fields, methods, or constructors. Contexts are passed through the nodes of the syntax tree in order to coordinate type checking between them. Therefore, while traversing the syntax tree top-down, the type checker creates dependencies between otherwise independent subexpressions. This way, it inhibits incrementalization and parallelization of type checking. That is, a change to a node of the syntax tree would require to redo the type check of the whole syntax tree. In this thesis a novel formulation of type systems is proposed, in order to remove dependencies between subexpressions. We propose a co-contextual formulation of typing rules that depends only on the local program constructs, e.g., expressions, methods, classes. The co-contextual typing rules have as conclusion a type and sets of requirements. That is, contexts and class tables are replaced by the dual concept of context and class table requirements. In addition, operations on contexts and class tables are replaced by new dual operations on requirements. The co-contextual type checker traverses a syntax tree bottom-up and merges context requirements of independently checked subexpressions. We describe a method for systematically constructing a co-contextual formulation of type rules from a regular context-based formulation and we show how co-contextual type rules give rise to incremental type checking. We derive co-contextual type checkers for functional and OO languages. As a representative of functional languages we consider PCF and extensions of it: records, parametric polymorphism, structural subtyping and let-polymorphism. Also, we investigate featherweight java (FJ) as the basis of OO languages and extensions of it: method overloading and generics. We build a1 co-contextual type checker for FJ enabling key features of OO languages: subtype polymorphism, nominal typing and implementation inheritance. The dualism between the co-contextual and contextual type systems preserves the correctness of the contextual calculus. That is, we prove the correctness of the co-contextual calculus via the equivalence between contextual type rules and their co-contextual formulations. We implemented an incremental type checker for PCF along with a performance evaluation showing that co-contextual type checking has performance comparable to standard context-based type checking, and incrementalization can improve performance significantly. Regarding FJ, we implemented a co-contextual type checker with incrementalization and compared its performance against javac on a number of realistic programs. Our performance evaluation shows significant speedups for the co-contextual type checker with incrementalization in comparison to javac.

Parallel reduction is a major component of parallel programming and widely used for summarisation and aggregation. It is not well understood, however, what sorts of non-trivial summarisations can be implemented as parallel reductions. This paper develops a calculus named λ AS , a simply typed lambda calculus with algebraic simplification. This calculus provides a foundation for studying a parallelisation of complex reductions by equational reasoning. Its key feature is δ abstraction. A δ abstraction is observationally equivalent to the standard λ abstraction, but its body is simplified before the arrival of its arguments using algebraic properties such as associativity and commutativity. In addition, the type system of λ AS guarantees that simplifications due to δ abstractions do not lead to serious overheads. The usefulness of λ AS is demonstrated on examples of developing complex parallel reductions, including those containing more than one reduction operator, loops with conditional jumps, prefix sum patterns and even tree manipulations.