Simple Type Theory Research Articles

Mathematical Structures Within Simple Type Theory

AbstractWe present an extension of simple type theory that incorporates types for any kind of mathematical structure (of any order). We further extend this system allowing isomorphic structures to be identified within these types thanks to some syntactical restrictions; for this purpose, we formally define what it means for two structures to be isomorphic. We model both extensions in NFU set theory in order to prove their relative consistency.

Ordinal type theory

ABSTRACT Higher-order logic, with its type-theoretic apparatus known as the simple theory of types (STT), has increasingly come to be employed in theorising about properties, relations, and states of affairs – or ‘intensional entities’ for short. This paper argues against this employment of STT and offers an alternative: ordinal type theory (OTT). Very roughly, STT and OTT can be regarded as complementary simplifications of the ‘ramified theory of types’ outlined in the Introduction to Principia Mathematica (on a realist reading). While STT, understood as a theory of intensional entities, retains the Fregean division of properties and relations into a multiplicity of categories according to their adicities and ‘input types’ and discards the division of intensional entities into different ‘orders’, OTT takes the opposite approach: it retains the hierarchy of orders (though with some modifications) and discards the categorisation of properties and relations according to their adicities and input types. In contrast to STT, this latter approach avoids intensional counterparts of the Epimenides and related paradoxes. Fundamental intensional entities lie at the base of the proposed hierarchy and are also given a prominent part to play in the individuation of non-fundamental intensional entities.

Types and Type Theories in Natural Language Analysis

This article reviews the set of possible paths from a semantics based on Simple Type Theories (STTs) toward one based on Rich Type Theories (RTTs) and the motivations behind the move from one to the other. The main elements of this review are threefold. First, it provides a systematic overview of different STTs, including options for what to include as members of the set of basic types, and whether to assume type constructors additional to the one for constructing functional types. Second, this review discusses the main differences between STTs and RTTs, namely, that in RTTs but not in STTs, types are part of the object language. That is, one can refer to and reason with and about types. In turn, this makes available an alternative account of propositions to the one assumed in semantics in the Frege–Church–Montague tradition: Instead of being characterized as sets of possible worlds, propositions can be treated themselves as types, that is, as structured semantic objects. Third and finally, this review provides an outline of some of the main applications of RTTs, including hyperintensionality, quantification, anaphora, polysemy, and modification.

Finitary Type Theories With and Without Contexts

We give a definition of finitary type theories that subsumes many examples of dependent type theories, such as variants of Martin–Löf type theory, simple type theories, first-order and higher-order logics, and homotopy type theory. We prove several general meta-theorems about finitary type theories: weakening, admissibility of substitution and instantiation of metavariables, derivability of presuppositions, uniqueness of typing, and inversion principles. We then give a second formulation of finitary type theories in which there are no explicit contexts. Instead, free variables are explicitly annotated with their types. We provide translations between finitary type theories with and without contexts, thereby showing that they have the same expressive power. The context-free type theory is implemented in the nucleus of the Andromeda 2 proof assistant.

Completeness in partial type theory

Abstract The present paper provides a completeness proof for a system of higher-order logic framed within partial type theory. The framework is a modification of Tichý’s extension of Church’s simple type theory, equipped with his innovative natural deduction system in sequent style. The system deals with both total and partial (multiargument) functions-as-mappings and also accommodates algorithmic computations arriving at various objects of the framework. The partiality of a function or a failure of a computation is not represented by a postulated null object such as the third truth value. The logical operators of the system are classical. Another welcome feature of this expressive system is that its consequence relation is monotonic.

Sikkel: Multimode Simple Type Theory as an Agda Library

Many variants of type theory extend a basic theory with additional primitives or properties like univalence, guarded recursion or parametricity, to enable constructions or proofs that would be harder or impossible to do in the original theory. However, implementing such extended type theories (either from scratch or by modifying an existing implementation) is a big hurdle for their wider adoption. In this paper we present Sikkel, a library in the dependently typed programming language Agda that allows users to program in extended type theories. It uses a deeply embedded language that can be easily extended with additional type and term constructors, thus supporting a wide variety of type theories. Moreover, Sikkel has a type checker that is sound by construction in the sense that all well-typed programs are automatically translated to their semantics in a shallow embedding based on presheaf models. Additionally, our model supports combining different base categories by using modalities to transport definitions between them. This enables in particular a general approach for extracting definitions to the meta-level, so that we can use the extended type theories to define regular Agda functions and prove properties of them. In this paper, we demonstrate Sikkel theories with guarded recursion and parametricity, but other extensions can be easily plugged in. For now, Sikkel supports only simple type theories but its model already anticipates the future addition of dependent types and a universe.

Simple Type Theory is not too Simple: Grothendieck’s Schemes Without Dependent Types

Church’s simple type theory is often deemed too simple for elaborate mathematical constructions. In particular, doubts were raised whether schemes could be formalized in this setting and a challenge was issued. Schemes are sophisticated mathematical objects in algebraic geometry introduced by Alexander Grothendieck in 1960. In this article we report on a successful formalization of schemes in the simple type theory of the proof assistant Isabelle/HOL, and we discuss the design choices which make this work possible. We show in the particular case of schemes how the powerful dependent types of Coq or Lean can be traded for a minimalist apparatus called locales.

Puzzles of Existential Generalisation from Type-theoretic Perspective

The present paper addresses several puzzles related to the Rule of Existential Generalization, (EG). In solution to these puzzles from the viewpoint of simple type theory, I distinguish (EG) from a modified Rule of Existential Quantifier Introduction which is derivable from (EG). Both these rules are often confused and both are considered as primitive but I show that (EG) itself is derivable from the proper Rule of Existential Quantifier Introduction. Moreover, the latter rule must be primitive in logical systems that treat both total and partial functions, for the universal and the existential quantifiers are not interdefinable in them. An appropriate natural deduction for such a system is deployed. The present logical system is simpler than the system recently proposed and applied by the present author. It utilises an adequate definition of substitution which is capable of handling not only a higher-order quantification, but also (hyper)intensional contexts.

In defence of Higher-Level Plural Logic: drawing conclusions from natural language

Plural Logic is an extension of First-Order Logic which has, as well as singular terms and quantifiers, their plural counterparts. Analogously, Higher-Level Plural Logic is an extension of Plural Logic which has, as well as plural terms and quantifiers, higher-level plural ones. Roughly speaking, higher-level plurals stand to plurals like plurals stand to singulars; they are pluralised plurals. Allegedly, Higher-Level Plural Logic enjoys the expressive power of a simple type theory while committing us to nothing more than the austere ontology of First-Order Logic. Were this true, Higher-Level Plural Logic would be a useful tool, with various applications in philosophy and linguistics. However, while the notions of plural reference and quantification enjoy widespread acceptance today, their higher-level counterparts have been received with a lot of scepticism. In this paper, I argue for the legitimacy of Higher-Level Plural Logic by providing evidence to the effect that natural languages contain higher-level plural expressions and showing that it is likely that they do so in an indispensable manner. Since the arguments I put forward are of the same sort advocates of Plural Logic have employed to defend their position, I conclude that the commonly held view that Plural Logic is legitimate, but not so its higher-level plural extensions is untenable.

Quantum Programming Made Easy

We present IQu, namely a quantum programming language that extends Reynold's Idealized Algol, the paradigmatic core of Algol-like languages. IQu combines imperative programming with high-order features, mediated by a simple type theory. IQu mildly merges its quantum features with the classical programming style that we can experiment through Idealized Algol, the aim being to ease a transition towards the quantum programming world. The proposed extension is done along two main directions. First, IQu makes the access to quantum co-processors by means of quantum stores. Second, IQu includes some support for the direct manipulation of quantum circuits, in accordance with recent trends in the development of quantum programming languages. Finally, we show that IQu is quite effective in expressing well-known quantum algorithms.

Algebraic Models of Dependent Type Theory

It has been observed [Awo16, Fio12] that the rules governing the essentially algebraic notion of a category with families [Dyb96] precisely match those of a representable natural transformation between presheaves. This provides us with a natural, functorial description of essentially algebraicobjects which are used to model dependent type theory—following Steve Awodey, we call them natural models.We can view natural models from several different viewpoints, of which we focus on three in this thesis. First, natural models are essentially algebraic, meaning that they can be described by specifying operations between sorts, subject to equational axioms—this allows us to assemblenatural models into a category with certain beneficial properties. Second, since natural models are natural transformations between presheaves, they are morphisms in a locally cartesian closed category, meaning that they can be regarded as polynomials [GK13]. Third, since natural models admit interpretations of dependent type theory, we can use them to provide a functorial semantics.This thesis develops the theory of natural models in three new directions by viewing them in these three ways.Natural models as essentially algebraic objects. The first development of the thesis is to bridge the gap between the presentation of natural models as models of an essentially algebraic theory, and the functorial characterisation of natural models as representable natural transformations. Wedemonstrate that the functorial characterisations of natural models and morphisms thereof align as we hope with the essentially algebraic characterisations. Natural models as polynomials. The next development is to apply the theory of polynomials in locally cartesian closed categories to natural models. In doing so, we are able to characterise theconditions under which a natural model admits certain type theoretic structure, and under which a natural transformation is representable, entirely in the internal language of a locally cartesian closed category. In particular, we prove that a natural model admits a unit type and dependentsum types if and only if it is a polynomial pseudomonad, that it admits dependent product types if and only if it is a pseudoalgebra, and we prove various facts about the full internal subcategory associated with a natural model. Natural models as models of dependent type theory. The final development of the thesis is to demonstrate their suitability as a tool for the semantics of dependent type theory. We build the term model of a particularly simple dependent type theory and prove that it satisfies the appropriate universal property, and then we proceed by describing how to turn an arbitrary natural model intoone admitting additional type theoretic structure in an algebraically free way.

Mechanized Metatheory Revisited

When proof assistants and theorem provers implement the metatheory of logical systems, they must deal with a range of syntactic expressions (e.g., types, formulas, and proofs) that involve variable bindings. Since most mature proof assistants do not have built-in methods to treat bindings, they have been extended with various packages and libraries that allow them to encode such syntax using, for example, de Bruijn numerals. We put forward the argument that bindings are such an intimate aspect of the structure of expressions that they should be accounted for directly in the underlying programming language support for proof assistants and not via packages and libraries. We present an approach to designing programming languages and proof assistants that directly supports bindings in syntax. The roots of this approach can be found in the mobility of binders between term-level bindings, formula-level bindings (quantifiers), and proof-level bindings (eigenvariables). In particular, the combination of Church’s approach to terms and formulas (found in his Simple Theory of Types) and Gentzen’s approach to proofs (found in his sequent calculus) yields a framework for the interaction of bindings with a full range of logical connectives and quantifiers. We will also illustrate how that framework provides a direct and semantically clean treatment of computation and reasoning with syntax containing bindings. Some implemented systems, which support this intimate and built-in treatment of bindings, will be briefly described.

Sharing a Library between Proof Assistants: Reaching out to the HOL Family

We observe today a large diversity of proof systems. This diversity has the negative consequence that a lot of theorems are proved many times. Unlike programming languages, it is difficult for these systems to co-operate because they do not implement the same logic. Logical frameworks are a class of theorem provers that overcome this issue by their capacity of implementing various logics. In this work, we study the STTforall logic, an extension of Simple Type Theory that has been encoded in the logical framework Dedukti. We present a translation from this logic to OpenTheory, a proof system and interoperability tool between provers of the HOL family. We have used this translation to export an arithmetic library containing Fermat's little theorem to OpenTheory and to two other proof systems that are Coq and Matita.

Decreasing sentences in Simple Type Theory

AbstractWe present various results regarding the decidability of certain sets of sentences by Simple Type Theory (). First, we introduce the notion of decreasing sentence, and prove that the set of decreasing sentences is undecidable by Simple Type Theory with infinitely many zero‐type elements (); a result that follows directly from the fact that every sentence is equivalent to a decreasing sentence. We then establish two different positive decidability results for a weak subtheory of . Namely, the decidability of (a subset of Σ1) and (the set of all sentences , where φ is strictly decreasing). Finally, we present some consequences for the set of existential‐universal sentences. All the above results have direct implications for Quine's theory of “New Foundations” () and its weak subtheory .

Increasing sentences in Simple Type Theory

We introduce the notion of pseudo-increasing sentence, and prove that all such sentences are decidable by a weak subtheory of Simple Type Theory with infinitely many zero-type elements. We then present the consequences of this result to Quine's theory of “New Foundations” (NF). In particular, we prove the decidability of certain universal-existential sentences, and establish the consistency of a subtheory of NF.

The Chemical Approach to Typestate-Oriented Programming

We introduce a novel approach to typestate-oriented programming based on the chemical metaphor: state and operations on objects are molecules of messages, and state transformations are chemical reactions. This approach allows us to investigate typestate in an inherently concurrent setting, whereby objects can be accessed and modified concurrently by several processes, each potentially changing only part of their state. We introduce a simple behavioral type theory to express in a uniform way both the private and the public interfaces of objects; describe and enforce structured object protocols consisting of possibilities, prohibitions, and obligations; and control object sharing.

Dualized Simple Type Theory

We propose a new bi-intuitionistic type theory called Dualized Type Theory (DTT). It is a simple type theory with perfect intuitionistic duality, and corresponds to a single-sided polarized sequent calculus. We prove DTT strongly normalizing, and prove type preservation. DTT is based on a new propositional bi-intuitionistic logic called Dualized Intuitionistic Logic (DIL) that builds on Pinto and Uustalu's logic L. DIL is a simplification of L by removing several admissible inference rules while maintaining consistency and completeness. Furthermore, DIL is defined using a dualized syntax by labeling formulas and logical connectives with polarities thus reducing the number of inference rules needed to define the logic. We give a direct proof of consistency, but prove completeness by reduction to L.

On the strength of a weak variant of the axiom of counting

In this paper is used to denote Jensen's modification of Quine's ‘new foundations’ set theory () fortified with a type‐level pairing function but without the axiom of choice. The axiom is the variant of the axiom of counting which asserts that no finite set is smaller than its own set of singletons. This paper shows that proves the consistency of the simple theory of types with infinity (). This result implies that proves that consistency of , and that proves the consistency of .

Contextual isomorphisms

What is the right notion of "isomorphism" between types, in a simple type theory? The traditional answer is: a pair of terms that are inverse up to a specified congruence. We firstly argue that, in the presence of effects, this answer is too liberal and needs to be restricted, using Führmann's notion of thunkability in the case of value types (as in call-by-value), or using Munch-Maccagnoni's notion of linearity in the case of computation types (as in call-by-name). Yet that leaves us with different notions of isomorphism for different kinds of type. This situation is resolved by means of a new notion of "contextual" isomorphism (or morphism), analogous at the level of types to contextual equivalence of terms. A contextual morphism is a way of replacing one type with the other wherever it may occur in a judgement, in a way that is preserved by the action of any term with holes. For types of pure λ-calculus, we show that a contextual morphism corresponds to a traditional isomorphism. For value types, a contextual morphism corresponds to a thunkable isomorphism, and for computation types, to a linear isomorphism.

Decidable Fragments of the Simple Theory of Types with Infinity and NF

We identify complete fragments of the Simple Theory of Types with Infinity ($\mathrm{TSTI}$) and Quine's $\mathrm{NF}$ set theory. We show that $\mathrm{TSTI}$ decides every sentence $\phi$ in the language of type theory that is in one of the following forms: (A) $\phi= \forall x_1^{r_1} \cdots \forall x_k^{r_k} \exists y_1^{s_1} \cdots \exists y_l^{s_l} \theta$ where the superscripts denote the types of the variables, $s_1 > \ldots > s_l$ and $\theta$ is quantifier-free, (B) $\phi= \forall x_1^{r_1} \cdots \forall x_k^{r_k} \exists y_1^{s} \cdots \exists y_l^{s} \theta$ where the superscripts denote the types of the variables and $\theta$ is quantifier-free. This shows that $\mathrm{NF}$ decides every stratified sentence $\phi$ in the language of set theory that is in one of the following forms: (A') $\phi= \forall x_1 \cdots \forall x_k \exists y_1 \cdots \exists y_l \theta$ where $\theta$ is quantifier-free and $\phi$ admits a stratification that assigns distinct values to all of the variable $y_1, \ldots, y_l$, (B') $\phi= \forall x_1 \cdots \forall x_k \exists y_1 \cdots \exists y_l \theta$ where $\theta$ is quantifier-free and $\phi$ admits a stratification that assigns the same value to all of the variables $y_1, \ldots, y_l$.