Object-Oriented Theorem Proving (OOTP): First Thoughts

12/28/2017 ∙ by Moez A. AbdelGawad, et al. ∙ Rice University 0

Automatic (i.e., computer-assisted) theorem proving (ATP) can come in many flavors. This document presents early steps in our effort towards defining object-oriented theorem proving (OOTP) as a new style of ATP. Traditional theorem proving (TTP) is the only well-known flavor of ATP so far. OOTP is a generalization of TTP. While TTP is strongly based on functional programming (FP), OOTP is strongly based on object-oriented programming (OOP) instead. We believe OOTP is a style of theorem proving that is no less powerful and no less natural than TTP and thus likely will be no less practically useful than TTP. In the document we also discuss, very briefly, a related notion of OO software verification (OOSV) based on OOTP. To clarify the relation between OOTP and TTP, we also touch on the relation between OOP and FP.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

One of the main advantages of functional programming (FP) languages is that proving properties of most functional programs—programs written using functional programming languages such as ML—is often straightforward. It is well-known that traditional (automatic) theorem proving (which we abbreviate TTP) and functional programming go hand in hand [8]. In fact the development of FP shows that TTP was the original raison d’être for FP.

To see how and why that is the case, it should be noted that TTP is typically based on tactics and tacticals. Tactics and tacticals are higher-order functions. Tacticals are even higher-order than tactics, since tacticals take other tactics—higher-order functions—as their input and produce them as results.

Further, the formal verification of the correctness of functional software is usually done using functional software tools, so as to have a degree of mathematical confidence in the capabilities of these proving tools (also called proof assistants). That is, not only is the proof of the correctness of a function in a functional program itself a function, but most of the professional software tools used in TTP (e.g., Coq and Isabelle) are themselves—or at least their most important core (i.e., their “proving engine”, based on tactics and tacticals)—written mostly in functional languages.111That is, a functional program is used to reason about another functional program to produce a functional program—a proof of the correctness of the input program—as its result: we have functional processing of functional input to produce functional output. Hence, the very strong connection between TTP and FP.

In this work we suggest a new style of theorem proving, object-oriented theorem proving (OOTP), that goes hand in hand with object-oriented programming (OOP) in the same way as TTP goes with FP. A main aim of OOTP is to make proving properties of a large subset of object-oriented programs as equally straightforward as TTP makes it for a large subset of functional software.222This subset includes referentially-transparent, provably-terminating OO programs. As such, our work justifies OO developers adopting the so-called “almost-functional” style of OO programming, where developers largely avoid imperative (i.e., non-referentially-transparent) features of OO languages (such as mutable fields and variables). It should be noted though that in fact this “almost-functional” style of OOP seems to be not necessary! As Paulson notes in [8, p.58], any procedural code (including one containing goto statements and assignment statements, the least opaque code) can be translated into a set of mutually recursive functions of a functional program. In other words, as we explain in this work, the opaque code can be translated into an object. (See Appendix A for the translation of the code in [8, p.58] to OO code.) Employing OOTP, objects seemingly can be used to reason even about the most opaque code.

2 Object-Oriented Theorem Proving

To introduce OOTP, it should be first and foremost noted that OOTP generalizes and subsumes TTP. In particular, OOTP generalizes the notions of axioms, theorems and inference rules of TTP to simultaneous axioms, simultaneous theorems and simultaneous inference rules, where simultaneity of a defined set of axioms, theorems or inference rules allows interdependence between the simultaneously-defined axioms, theorems or inference rules (i.e., they can be defined mutually-recursively). In the sequel we explain in more detail how OOTP is defined as a generalization of TTP.

In TTP, each axiom is a primitive theorem, while each inference rule is a function from theorems to theorems [8]. In OOTP, we have each set of simultaneous axioms as a set of simultaneous primitive theorems, while each set of simultaneous inference rules is an object that maps—i.e., whose methods map—simultaneous theorems to simultaneous theorems.

Further, in TTP (as first suggested by Milner, for LCF [9, 6]) regular FP type checking ensures that theorems could be made only by axioms and inference rules. Applying inference rules to already known theorems constructs proofs, rule by rule, in the forward direction [8]. In OOTP, on the other hand, regular OO type checking will ensure that simultaneous theorems could be made only by simultaneous axioms and simultaneous inference rules. Applying simultaneous inference rules to already known simultaneous theorems constructs simultaneous proofs (as one unit, called an OO proof, or an object), rule by rule, in the forward direction.

Moreover, tactics in TTP permit a more natural style, backward proofs. A tactic in TTP is a function from goals to subgoals, justified by the existence of an inference rule going the other way. The tactic actually returns this inference rule (as a function) in its result: tactics are higher-order functions [8]. Similarly, in OOTP we have OO tactics, which permit a more natural style, backward OO proof. An OO tactic is an object that maps—i.e., whose simultaneously-defined methods map—(simultaneous) goals to (simultaneous) subgoals, justified by the existence of a set of simultaneous inference rules going the other way (i.e., from subgoals to goals). The OO tactic actually returns this set of simultaneous inference rules (as an object) in its result: OO tactics are higher-order objects.

Finally, tacticals in TTP provide control structures for combining simple tactics into complex ones. The resulting tactics could be combined to form still more complex tactics, which in a single step could perform hundreds of primitive inferences. Tacticals are even more higher-order than tactics [8]. Similarly, OO tacticals in OOTP provide control structures for combining simple OO tactics into complex ones. The resulting OO tactics could be combined to form still more complex OO tactics, which in a single step could perform hundreds of primitive OO inferences. OO tacticals are even more higher-order than OO tactics.

Table 1 summarizes the similarities and differences between OOTP and TTP.

TTP OOTP
Axiom Simultaneous Axioms
(OO Axiom)
Theorem Simultaneous Theorems
(OO Theorem)
Inference Rule Simultaneous Inference Rules
(OO Inference Rule)
Proof (Function) Simultaneous Proofs
(OO Proof; Object)
Tactic OO Tactic
(Higher-order function) (Higher-order object)
Tactical OO Tactical
(Higher-order function) (Higher-order object)
Table 1: Main notions in TTP and corresponding notions in OOTP.

3 Remaining Work

After overcoming some initial unfamiliarity it is easy to recognize that, when formalized, OOTP, as presented so far, seems to be a straightforward, relatively-mild generalization of TTP. It should be noted, however, that object-oriented programming (from which OOTP gets inspiration) is characterized by two features that make it distinct and intricate, and thus—we believe—more practically useful than functional programming (from which TTP gets inspiration). These two features are (1) encapsulation and (2) (type) inheritance and subtyping.

3.1 Self-awareness and Inheritance

Encapsulation, in OOP, first and foremost means the binding together of a collection of related methods and fields in one unit (a capsule/an object). In addition, encapsulation in OOP refers to the autognosticism property of objects (i.e., their self-awareness, via the parameter this, or self, that is passed implicitly to all methods of an object). Encapsulation in OOP also frequently refers to the ability to hide some implementation details. (The information hiding sense of encapsulation is not characteristic to OOP, however, since it is supported in FP, for example, via abstract data types.)

Type inheritance, and subtyping, in OOP refer to the inheritance and reuse of object types and of behavioral contracts by subclasses (and their corresponding subtypes) from superclasses (and their corresponding supertypes), and to the preservation and refinement of types and contracts in the subclasses/subtypes.

Providing a mathematical and practically-useful meaning of encapsulation in OOTP (which we partially did above) and of inheritance and subtyping in OOTP (which yet remains to be done, but which we expect to involve some notion of specification inheritance and/or theorem refinement) should make OOTP a more intricate and more powerful generalization of TTP.

3.2 Object-Oriented Software Verification (OOSV)

We predict that a precise and full definition of encapsulation and inheritance in OOTP will immediately enable establishing an obvious and direct method for reasoning about object-oriented software and verifying its properties. Specifying the details of this method is work that remains to be done.

4 Comparisons and Some Philosophy

4.1 OOTP versus TTP … and OOSV

Just as OOP is more practically useful than FP (as demonstrated by the practical popularity of OO programming languages as compared to that of functional programming languages333The skeptic reader should check by themselves the TIOBE index and langpop.com, or do an online survey to compare the popularity of OOP with that of FP. We also invite the reader to check our related work ‘From FP to OOP (or, Java for the Working ML Programmer)’ [4].), we believe OOTP might also prove to be more practically useful in proving theorems about the real-world—intrinsically complex, interconnected and interdependent?—than TTP is. In particular, as hinted to above we believe OOTP, given its inherent object-orientation, can be used to reason about and verify OO software (OOSV) in a more natural manner.

4.2 OOP versus FP

In this section we briefly discuss the relation between OOP, as a computer programming paradigm centered around objects, and FP, as a paradigm centered around functions, by presenting an analogy and some philosophy. We offer what we believe is a novel prespective but we do not go into plenty of details given that the topic has been discussed, extensively but inconclusively, in the research literature (e.g., as revealed by [7] and related work, or by an online search for ‘the expression problem’).

An Analogy.

Based on our modeling of nominal OOP and structural OOP [1], in our opinion the main and most fundamental difference between OOP and FP is that OOP embraces mutual recursion wholeheartedly (mutually recursive methods come essentially for free in OOP) while FP embraces mutual recursion reluctantly (mutually recursive functions require special constructs in FP, and even then their use is discouraged444See the code example in Appendix A for an FP warning against some definitions of mutually-recursive non-imperative functions.).

To an extent this difference is analogous to the difference between natural languages that consider words as the main units of the language555Word-based languages; most natural languages fall in this category since a word—a finite sequence of letters—is the smallest unit that has meaning in such languages. and natural languages that consider characters (or letters) as the main fundamental units of speech and language666Character-based languages; very few natural languages fall in this category in which most if not all single characters, or “letters,” have meanings..

We find this analogy appropriate because in OOP an object, at its very core, is a set of functions (the methods of the object, possibly mutually recursively defined). That is, in OOP an object is a finite set of tightly related functions but each method in an object, on its own, is not considered as a fundamental independent unit (i.e., in OOP rarely, or at least less-frequently, does a single method have an independent meaning, outside the context of an object) but rather the grouping and binding of the set of functions (as methods) in one unit (as an object, via the notion of this/self) is the fundamental, smallest-meaningful unit in OOP. Functional languages, on the other hand, consider it to be the norm that each function has an independent meaning, and they allow mutually-recursive functions usually only as a rare (and “complex”) exception.

As such, akin to the view of words and letters in most natural languages, OOP considers mutually-dependent functions as the norm (and thus embraces their grouping as a fundamental unit: an objects) while considering single functions having independent meanings as being an exception (i.e., only very few objects have single meaningful methods in an OOP program, e.g., the equals() method of class Object777Even equals() is not quite independent. Its definition usually requires to be “in sync” with the definition of hashCode() [5].). Functional programming, on the other hand, similar only to very few natural languages, considers functions having independent meanings as the norm (as we explained above).

A Philosophical Note.

Consider the following three questions:

  1. Is FP superior to OOP (as some PL researchers and theoreticians may claim) or vice versa (as some industrial software developers may claim)?

  2. To which of the two programming paradigms belongs the future of computer programming?

  3. Is our world fundamentally composed of interdependent and complex entities (OOP) or is it fundamentally composed of independent and simple entities (FP)?

We believe these three questions to be somewhat philosophical questions, whose answers will always remain controversial, rather than being technical questions whose answers can be resolved scientifically. While having our own personal answers to these questions (squarely in favor of OOP), we hope the brief discussion above—including the illustrating analogy with natural languages—sheds some light on why we believe these questions are lesser technical and scientific ones and more controversial and philosophical ones.888We believe research on FP should aim to suggest how OOP can be improved—e.g., as was done in Java 8.0—but should not aim for FP replacing OOP.999Our opinion is formed based on nothing related to any software efficiency arguments, in spite of their importance. We believe efficiency arguments are fundamentally ambivalent, agnostic or neutral towards the ‘OOP versus FP’ question. Efficiency of computer software, particularly time and space efficiency, is almost always due to the existence of imperative programming features in a programming language. Imperative programming features, which are usually found in OOP but not FP languages, are not inherent or characteristic of OOP, and can be added to a FP language with little additional complexity to the language (as ML—a popular functional language—demonstrates).

5 Ideas to Incorporate Later

  • Use category theory [3] to express and present OOTP?

  • Structured programming motivated Velleman’s ‘structured proving’ [10]. Similarly, object-oriented programming motivated OOTP.

6 Implementation/Proof of Concept

We are currently working on further exploration and refinement of our ideas on OOTP by implementing a basic OO theorem prover in three programming languages: ML (FP), Java (OOP) and Scala (OOP/FP), using theorem prover ideas from our implementation of Paulson’s Hal [8] and our update [2] to Velleman’s Proof Designer [10, 11]. Early versions of our code should be available on sourceforge and github in the near future. Stay tuned.

References

Appendix A Opaque Code Translated to OOP and FP Code

a.1 Imperative to OOP

The imperative code

  • var x := 0; y := 0; z := 0;
    F:  x := x+1; goto G
    G:  if y<z then goto F else (y := x+y; goto H)
    H:  if z>0 then (z := z-x; goto F) else stop

can be translated to the following non-imperative OO code

  • class C {
      final x, y, z: int
      // constructor
      C(xx,yy,zz: int) { x = xx; y = yy; z = zz }
      C F() { new C(x+1,y,z).G() }
      C G() {
        if y < z then this.F()
        else new C(x,x+y,z).H() }
      C H() {
        if z > 0 then new C(x, y, z-x).F()
        else this }
    }

Calling new C(0,0,0).F() returns an object equivalent to new C(1,1,0), as expected.

The code can be also translated to the following (more succinct, but harder to reason about) imperative OO code

  • class IC {
      x, y, z: int
      IC(xx,yy,zz: int) { x := xx; y := yy; z := zz }
      void F() { x := x+1; G() }
      void G() {
        if y < z then F()
        else { y := x+y; H() }}
      void H() { if z > 0 then { z := z-x; F() }}
    }

On an object ic = new IC(0,0,0) calling ic.F() terminates with ic equivalent to new IC(1,1,0), as expected.

It should be noted that in the OO code above all unqualified field references and methods calls are implicitly done via this.

a.2 Imperative to FP

For comparison purposes, the corresponding mutually-recursive functional translation (adapted from the code in [8, p.58]) of the opaque imperative code above looks like

  • type int_triple = int * int * int
    fun F(x,y,z: int): int_triple =
          G(x+1,y,z)
    and
        G(x,y,z: int): int_triple =
          if y<z then F(x,y,z)
          else H(x,x+y,z)
    and
        H(x,y,z: int): int_triple =
          if z>0 then F(x,y,z-x)
          else (x,y,z);

Calling F(0,0,0) returns (1,1,0).

The functional code makes us note that

  • All variables are passed explicitly as parameters in the code. With many variables, the code may not scale well.

  • The code, and functional programming more generally, do not support open recursion. Method calls in OOP are virtual (i.e., are made via this at runtime, which is sometimes called dynamic/late-binding) by default in most OO languages. Function calls in FP, however, are always non-virtual (i.e., are always statically-bound). Unlike in OOP, FP lacks a notion of inheritance/subclassing that allows for late/dynamic-rebinding. An alternative to open recursion in FP is to make use of higher-order functions—i.e., functionals—that take other functions, dynamically, as parameters).

  • Finally, and most importantly, because referential transparency is frequently stated as a main advantage of functional programming, Paulson [8, p.58], in an implicit warning against mutually-recursive functional programming (after presenting code similar to the functional code above, notably non-imperative), remarks that

    Functional programs are referentially transparent, yet can be totally opaque. If your code starts to look like this, beware!

    It should be noted that mutual recursion, and even open mutual recursion, is embraced wholeheartedly in OOP, due to the seemingly natural and intuitive real-world modeling capabilities of mutual recursion. It is a main goal of OOTP to make reasoning about such code (i.e., non-imperative but mutually-recursive code, expressed as OO code) as natural and straightforward (“transparent”) as TTP makes it for (non-imperative and non-mutually-recursive) functional code.