Steps Toward a Computational Metaphysics

Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming - ICFP '06, 2006

We investigate the development of a general-purpose framework for mechanized reasoning about the meta-theory of programming languages. In order to provide a standard, uniform account of a programming language, we propose to define it as a logic in a logical framework, using the same mechanisms for definition, reasoning, and automation that are available to other logics. Then, in order to reason about the language's meta-theory, we use reflection to inject the programming language into a (usually richer and more expressive) meta-theory. One of the key features of our approach is that structure of the language is preserved when it is reflected, including variables, meta-variables, and binding structure. This allows the structure of proofs to be preserved as well, and there is a one-to-one map from proof steps in the original programming logic to proof steps in the reflected logic. The act of reflecting a language is automated; all definitions, theorems, and proofs are preserved by the transformation and all the key lemmas (such as proof and structural induction) are automatically derived. The principal representation used by the reflected logic is higher-order abstract syntax (HOAS). However, reasoning about terms in HOAS can be awkward in some cases, especially for variables. For this reason, we define a computationally equivalent variable-free de Bruijn representation that is interchangeable with the HOAS in all contexts. The de Bruijn representation inherits the properties of substitution and alpha-equality from the logical framework, and it is not complicated by administrative issues like variable renumbering. We further develop the concepts and principles of proofs, provability, and structural and proof induction. This work is fully implemented in the MetaPRL theorem prover. We illustrate with an application to F <: as defined in the POPLmark challenge.

2019

The history of philosophy is rich with theories about objects; theories of object kinds, their nature, the status of their existence, etc. In recent years philosophical logicians have attempted to formalize some of these theories, yielding many fruitful results. This thesis intends to add to this tradition in philosophical logic by developing a second-order formal system that may serve as a groundwork for a multitude of theories of objects (e.g. concrete and abstract objects, impossible objects, fictional objects, and others). Through the addition of what we may call sortal quantifiers (i.e. quantifiers that bind individual variables ranging over objects of three unique sorts), a groundwork for a logic that captures concrete and non-concrete objects will be developed. We then extend this groundwork by the addition of a single new operator and the modal operators of a Priorian temporal logic. From this extension, our formal system can represent and define concrete, abstract, fictional, and impossible objects as well as formally axiomatize informal theories of them.

Formalizing meta-theory, or proofs about programming languages, in a proof assistant has many well-known benefits. However, the considerable effort involved in mechanizing proofs has prevented it from becoming standard practice. This cost can be amortized by reusing as much of an existing formalization as possible when building a new language or extending an existing one. Unfortunately reuse of components is typically ad-hoc, with the language designer cutting and pasting existing definitions and proofs, and expending considerable effort to patch up the results.

2000

Isabelle is an interactive theorem prover that supports a variety of logics. It represents rules as propositions (not as functions) and builds proofs by combining rules. These operations constitute a meta-logic (or 'logical framework') in which the object-logics are formalized. Isabelle is now based on higher-order logic -a precise and well-understood foundation.

1994

We are developing a multilevel metalogic programming language that we call Alloy. It is based on first-order predicate calculus extended with metalogical constructs. An Alloy program consists of a collection of theories, all in the same language, and a representation relation over these theories. The whole language is self-representable, including names for expressions with variables. A significant difference, as compared with many previous approaches, is that an arbitrary number of metalevels can be employed and that the object-meta relationship between theories need not be circular. The language is primarily intended for representation of knowledge and metaknowledge and is currently being used in research on hierarchical representation of legal knowledge. We believe that the language allows sophisticated expression and efficient automatic deduction of interesting sets of beliefs of agents. This paper aims to give a preliminary and largely informal definition of the core of the language, a simple but incomplete and inefficient proof system for the language and a sketch of an alternative, more efficient, proof system. The latter is intended to be used as a procedural semantics for the language. It is being implemented by an extension of an abstract machine for Prolog.

2002

We propose classical set theory as the core of an automated proof-verifier and outline a version of it, designed to assist in proof development, which is indefinitely expansible with function symbols generated by Skolemization and embodies a modularization mechanism named ‘theory’. Through several examples, centered on the finite summation operation, we illustrate the potential utility in large-scale proof-development of the ‘theory’ mechanism: utility which stems in part from the power of the underlying set theory and in part from Skolemization.

1992

Abstract Zermelo-Fraenkel (ZF) set theory is widely regarded as unsuitable for automated reasoning. But a computational logic has been formally derived from the ZF axioms using Isabelle. The library of theorems and derived rules, with Isabelle's proof tools, support a natural style of proof. The paper describes the derivation of rules for descriptions, relations and functions, and discusses interactive proofs of Cantor's Theorem, the Composition of Homomorphisms challenge [3], and Ramsey's Theorem [2].

Arxiv preprint arXiv:0811.4367, 2008

The Journal of Logic Programming, 1990

1995

A theory system is a collection of interdependent theories, some if which stand in a meta/object relationship, forming an arbitrary num­ber of meta­levels. The main thesis of this chapter is that theory systems constitute a suitable formalism for constructing advanced ap­plications in reasoning and software engineering. The Alloy language for defining theory systems is introduced, its syntax is defined and a collection of inference rules is presented. A number of problems suit­able for theory systems are discussed, with program examples given in Alloy. Some current implementation issues and future extensions are discussed.