Type-theoretic Approach Research Articles

Data Layout from a Type-Theoretic Perspective

The specifics of data layout can be important for the efficiency of functional programs and interaction with external libraries. In this paper, we develop a type-theoretic approach to data layout that could be used as a typed intermediate language in a compiler or to give a programmer more control. Our starting point is a computational interpretation of the semi-axiomatic sequent calculus for intuitionistic logic that defines abstract notions of cells and addresses. We refine this semantics so addresses have more structure to reflect possible alternative layouts without fundamentally departing from intuitionistic logic. We then add recursive types and explore example programs and properties of the resulting language.

Понятие доказательства в контексте теоретико-типового подхода, III: доказательства как (некоторые) типы

Понятие доказательства в контексте теоретико-типового подхода, III: доказательства как (некоторые) типы

Понятие доказательства в контексте теоретико-типового подхода, II: доказательства теорем

Понятие доказательства в контексте теоретико-типового подхода, II: доказательства теорем

Понятие доказательства в контексте теоретико-типового подхода, I: доказательство программ

Понятие доказательства в контексте теоретико-типового подхода, I: доказательство программ

Type-theoretic Means for Querying Heterogeneous Data Sources Available via Cloud APIs

We propose a unified approach for querying data sources which are accessible in form of heterogeneous APIs rather than some standards compliant databases. Different APIs use different query structures and support different capabilities. Type-theoretic approach is used for query structure representation. Because of the fact that not any API will support the full expressibility of the query language we propose techniques for “widening” the query to make it compatible with the given API possibilities. After the query is executed additional filters are applied to the acquired data. In order to achieve this goal a special set of query expansion rules was developed. It consists of the rules that generate special conversion functions which transform more specific queries into less specific ones.

Typetheoretic Approach to the Shimming Problem in Scientific Workflows

When composing Web services into scientific workflows, users often face the so-called shimming problem when connecting two related but incompatible components. The problem is addressed by inserting a special kind of adaptors, called shims, that perform appropriate data transformations to resolve data type inconsistencies. However, existing shimming techniques provide limited automation and burden users with having to define ontological mappings, generate data transformations, and even manually write shimming code. In addition, these approaches insert many visible shims that clutter workflow design and distract user's attention from functional components of the workflow. To address these issues, we 1) reduce the shimming problem to a runtime coercion problem in the theory of type systems, 2) propose a scientific workflow model and define the notion of well-typed workflows, 3) develop an algorithm to typecheck workflows, 4) design a function that inserts “invisible shims”, or runtime coercions into workflows, thereby solving the shimming problem for any well-typed workflow, 5) implement our automated shimming technique, including all the proposed algorithms, lambda calculus, type system, and translation functions in our VIEW system and present two case studies to validate our approach.

A type-theoretical approach for ontologies: The case of roles

In the domain of ontology design as well as in Knowledge Representation, modeling universals is a challenging problem. Most approaches that have addressed this problem rely on Description Logics DLs but many difficulties remain, due to under-constrained representation which reduces the inferences that can be drawn and further causes problems in expressiveness. In mathematical logic and program checking, type theories have proved to be appealing but, so far they have not been applied in the formalization of ontologies. To bridge this gap, we present in this paper a theory for representing ontologies in a dependently-typed framework which relies on strong formal foundations including both a constructive logic and a functional type system. The language of this theory defines in a precise way what ontological primitives such as classes, relations, properties, etc., and thereof roles, are. The first part of the paper details how these primitives are defined and used within the theory. In a second part, we focus on the formalization of the role primitive. A review of significant role properties leads to the specification of a role profile and most of the remaining work details through numerous examples, how the proposed theory is able to fully satisfy this profile. It is demonstrated that dependent types can model several non-trivial aspects of roles including a formal solution for generalization hierarchies, identity criteria for roles and other contributions. A discussion is given on how the theory is able to cope with many of the constraints inherent in a good role representation.

Modeling Contexts with Dependent Types

In the area of knowledge representation, a challenging topic is the formalization of context knowledge on the basis of logical foundations and ontological semantics. However, most attempts to provide a formal model of contexts suffer from a number of difficulties, such as limited expressiveness of representation, restricted variable quantification, lack of (meta) reasoning about properties, etc. In addition, type theory originally developed for formal modeling of mathematics has also been successfully applied to the correct specification of programs and in the semantics of natural language. In this paper, we suggest a type theoretical approach to the problem of context and action modeling. Type theory is used both for representing the system's knowledge of the discourse domain and for reasoning about it. For that purpose, we extend an existing dependent type theory having nice properties, with context-based rules and appropriate inductive types. We claim that the resulting theory exploiting the power of dependent types is able to provide a very expressive system together with a unified theory allowing higher-order reasoning.

Coinduction for Exact Real Number Computation

This paper studies coinductive representations of real numbers by signed digit streams and fast Cauchy sequences. It is shown how the associated coinductive principle can be used to give straightforward and easily implementable proofs of the equivalence of the two representations as well as the correctness of various corecursive exact real number algorithms. The basic framework is the classical theory of coinductive sets as greatest fixed points of monotone operators and hence is different from (though related to) the type theoretic approach by Ciaffaglione and Gianantonio.

Underspecified Interpretations in a Curry-typed Representation Language

In previous work we have developed Property Theory with Curry Typing (PTCT, an intensional first-order logic for natural language semantics. PTCT permits fine-grained specifications of meaning. It also supports polymorphic types and separation types.1 We develop an intensional number theory within PTCT order to represent proportional generalized quantifiers like 'most', and we suggest a dynamic type-theoretic approach to anaphora and ellipsis resolution. Here we extend the type system to include product types, and use these to define a permutation function that generates underspecified scope representations within PTCT. We indicate how filters can be added to encode constraints on possible scope readings. Our account offers several important advantages over other current theories of underspecification.

Towards the Correctness of Security Protocols

In [19], the authors presented a type-theoretic approach to the verification of security protocols. In this approach, a universal type system is proposed to capture in a finite way all the possible computations (internal actions or protocol instrumentations) that could be performed by a smart malicious intruder. This reduces the verification of cryptographic protocols to a typing problem where types are attack scenarios. In this paper, we recall this type system and we prove its completeness i.e. if the intruder can learn a message from a given protocol instrumentation, then this message could be infered from the type system. A significant result of this paper is the presentation of a new transformation that allows us to abstract a non-terminating type inference system into a terminating deductive proof system. We demonstrate how these results could be used to establish the security of cryptographic protocols from the secrecy standpoint. Finally, the usefulness and the efficiency of the whole approach is illustrated by proving the correctness of a new version of the Needham-Shoreder protocol with respect to the secrecy property.

Weak readings of indefinites: type-shifting and closure

The starting point of our investigation is the assumption that weak indefinite NPs have a well-formed denotation of type (e,t). This paper explores the consequences of this flexible type-theoretic approach at the compositional level. Some expressions (e.g., predicative be) select for arguments of type (e,t). The combination of predicative NPs with stage-level predicates and other expressions which do not necessarily select for arguments of type (e, t) creates a type mismatch which can be solved by defining modes of composition other than function application. These closure operations are argued to be lexicalized in light verbs like have and intensional verbs like seek. They are grammaticalized in the existential there construction.

From context-free to definite-clause grammars: a type-theoretic approach

We discuss the mechanical transformation of an unambiguous context-free grammar (CFG) into a definite-clause grammar (DCG) using a finite set of examples, each of which is a pair 〈 s, m〉, where s is a sentence belonging to the language defined by the CFG and m is the semantic representation (meaning) of s. The resulting DCG would be such that it could be executed to compute the semantics for every sentence of the original DCG. The motivation for our work comes from the observation that it is not easy to manually augment a CFG with semantic attributes to obtain a DCG because the task of building a correct and efficient DCG requires a fair amount of search, especially when the semantic representations involve quantified terms, as in natural languages. Our proposed approach is based upon two key assumptions: (1) the semantic representation language is the simply typed λ-calculus, and (2) the semantic representation of a sentence is a function (expressed in the typed λ-calculus) of the semantic representations of its parts ( compositionality). With these assumptions, we show how a higher-order DCG can be systematically constructed using a matching procedure for simply typed λ-terms. We then show how to translate the constructed higher-order DCG into a first-order DCG by a partial-execution procedure. We have applied our methodology to the synthesis of the semantics of a small query language, and we believe that this methodology could be a useful tool for generating natural query language front-ends for various applications.

Program transformation in constructive type theory

Transformational programming is a method for program development. To formalize the transformational programming techniques, the key point is to formally represent transformation rules and to prove the correctness of these rules. In this paper, we describe a constructive type-theoretical approach for formalizing the concepts of program schema, transformation rules and strategies, and software development processes. Some examples for verification and derivation of semantically correct program transformation rules are presented.

A type-theoretic approach to program development

A paradigm of program development using type theories is given after analyzing some typical examples. In order to carry this approach forward, a language ALT is designed. It is a linguistic description of a generalized higher order typed lambda calculus with π, Σ types and π, Σ kinds (supertypes). Four examples are given to show how ALT can be used to implement many concepts of software engineering and artificial intelligence. They are intuitionistic logic, Peano arithmetic, approximate reasoning and program transformations. ALT is described formally, using a structural operational approach.

A type-theoretic approach for program development

A paradigm of program development using type theories is given after analyzing some typical examples. In order to carry this approach forward, a language ALT is designed, a linguistic description of a generalized higher order typed lambda calculus with Π, Σ types and Π, Σ kinds (supertype). Four examples are given to show how ALT can be used to implement many concepts of software engineering and artificial intelligence, they are intuitionistic logic, Peano arithmetic, approximate reasoning and program transformation. ALT is described formally, using a structural operational approach.