Higher-order Predicate Logic Research Articles

Invited Talk: Towards a Principled Multi-Language Infrastructure

Sun's Java architecture introduced a safe virtual machine (VM) in which an ensemble of software components developed independently could smoothly interoperate. The goal of Microsoft's Common Language Runtime (CLR) is to generalize this approach and allow components in many source languages to interoperate safely. CLR supports flexible interoperation by compiling various source languages into a common intermediate language and by using a unified type system. However, the type system in CLR (and Java VM) enforces only conventional type safety in an object-oriented system. Therefore, higher-level specifications (e.g., resource bounds, generalized access control, formal software protocols) cannot be enforced. Because conventional type systems are too inflexible for real applications, developers often bypass the type system, producing code that steps outside the managed part of the VM; such components cannot be verified.At Yale we have been developing typed common intermediate languages (named FLINT) that can support safely not only the standard object-oriented model, but also higher-order generic (polymorphic) programming and Java-style reflection (introspection). Unlike CLR, our type system is independent of any particular programming model, yet it is capable of expressing all valid propositions and proofs in higher-order predicate logic (so it can be used to capture and verify advanced program properties). The rich type system of FLINT makes it possible to typecheck both compiler intermediate code and low level machine code; this allows typechecking to take place at any phase of compilation, even after optimizations and register allocation. It also leads to a smaller and more extensible VM because low-level native routines that would otherwise be in VM can now be verified and moved into a certified library. This talk describes our vision of the FLINT system, outline our approach to its design, and survey the technologies that can be brought to support its implementation.

A simple type theory with partial functions and subtypes

Simple type theory is a higher-order predicate logic for reasoning about truth values, individuals, and simply typed total functions. We present in this paper a version of simple type theory, called PF *, in which functions may be partial and types may have subtypes. We define both a Henkin-style general models semantics and an axiomatic system for PF *, and we prove that the axiomatic system is complete with respect to the general models semantics. We also define a notion of an interpretation of one PF * theory in another. PF * is intended as a foundation for mechanized mathematics. It is the basis for the logic of IMPS, an Interactive Mathematical Proof System developed at The MITRE Corporation.

Conceptual realism versus Quine on classes and higher-order logic

The problematic features of Quine's ‘set’ theories NF and ML are a result of his replacing the higher-order predicate logic of type theory by a first-order logic of membership, and can be resolved by returning to a second-order logic of predication with nominalized predicates as abstract singular terms. We adopt a modified Fregean position called conceptual realism in which the concepts (unsaturated cognitive structures) that predicates stand for are distinguished from the extensions (or intensions) that their nominalizations denote as singular terms. We argue against Quine's view that predicate quantifiers can be given a referential interpretation only if the entities predicates stand for on such an interpretation are the same as the classes (assuming extensionality) that nominalized predicates denote as singular terms. Quine's alternative of giving predicate quantifiers only a substitutional interpretation is compared with a constructive version of conceptual realism, which with a logic of nominalized predicates is compared with Quine's description of conceptualism as a ramified theory of classes. We argue against Quine's implicit assumption that conceptualism cannot account for impredicative concept-formation and compare holistic conceptual realism with Quine's class Platonism.

Set abstraction—An extension of all solutions predicate in logic programming language

The concept of set abstraction is introduced as a simple analogy of that of lambda abstraction in the theory of lambda calculus. The set abstraction is concerned with two extensions concerning Prolog language features: “set expression” and “predicate variable.” It has been argued in the literature that the set expression extension to Prolog does really contribute to the power of the language, while the extension of predicate variables does not add anything to Prolog. Combining these two concepts of extensions to Prolog, we define “set abstraction” as the set expression in which predicate variables are allowed as data objects. In other words, the set abstraction gets involved in the higher order predicate logic. By showing some application examples, it is demonstrated that with the help of predicate variables set abstractions can nicely handle the issues of the second order predicate logic. Further, the implementation programs written in Prolog and Concurrent Prolog are presented.

Specification and verification of digital systems using higher-order predicate logic

Specification and verification of digital systems using higher-order predicate logic