A Prolog-based Proof Tool for Type Theory TA λ and Implicational Intuitionistic-Logic

Transcription

1 for Type Theory TA λ and Implicational Intuitionistic-Logic L. Yohanes Stefanus University of Indonesia Depok 16424, Indonesia and Ario Santoso Technische Universität Dresden Dresden 01187, Germany Abstract Studies on type theory have brought numerous important contributions to computer science. In this paper we present a GUI-based proof tool that provides assistance in constructing deductions in type theory and validating implicational intuitionistic-logic formulas. As such, this proof tool is a testbed for learning type theory and implicational intuitionistic-logic. This proof tool focuses on an important variant of type theory named TA λ, especially on its two core algorithms: the principal-type algorithm and the type inhabitant search algorithm. The former algorithm finds a most general type assignable to a given λ-term, while the latter finds inhabitants (closed λ-terms in β-normal form) to which a given type can be assigned. By the Curry Howard correspondence, the latter algorithm provides provability for implicational formulas in intuitionistic logic. We elaborate on how to implement those two algorithms declaratively in Prolog and the overall GUI-based program architecture. In our implementation, we make some modification to improve the performance of the principal-type algorithm. We have also built a web-based version of the proof tool called λ-guru. 1 Introduction In 1902, Russell revealed the inconsistency in naive set theory. This inconsistency challenged the foundation of mathematics at that time. To solve that problem, type theory was introduced [1, 5]. As time goes on, type theory becomes widely used, it becomes a logician s standard tool, especially in proof theory. Since 1970s, the need for robust programming languages has made type theory the center of attention among computer scientists. Many practical programming languages have been developed based on type theory [4, 6]. Type theory has many variants, one of them is called TA λ (for type-assignment in λ- calculus). TA λ is one of the simplest type-theories. Many complex techniques for analyzing the structures of complex type-theories appear in TA λ in an easier form and hence easier to understand. Therefore, TA λ is a good vehicle for learning more complex techniques in type theory. By learning TA λ, one can obtain a good foundation to study other type-systems [4]. The importance of TA λ and its relation to type theory in general drive this research project. This work focuses on two most important algorithms in TA λ, i.e., the principal-type algorithm and the type inhabitant search algorithm. The former algorithm finds a most general type (principal type) assignable to a given λ-term, while the latter finds inhabitants (i.e., closed λ-terms in β-normal form) to which a given type can be assigned. Those two algorithms are implemented using Prolog and exploiting the ability of definite clause grammars (DCG) Supported by the European Master s Program in Computational Logic (EMCL) G. Sutcliffe, S. Schulz, E. Ternovska (eds.), IWIL 2010 (EPiC Series, vol. 2), pp. 41

2 for processing linguistic expressions. DCG is a Prolog feature for expressing grammar rules [2]. In addition, a graphical user interface (GUI) is developed for helping users try those two algorithms. Therefore, the resulting software can be used as a testbed for learning TA λ and, by the Curry Howard correspondence, as a proof assistant for implicational formulas in intuitionistic logic. 2 The Principal-Type Algorithm Implementation The principal-type algorithm decides whether a λ-term is typable or not. It takes a λ-term as an input. If the given λ-term is typable, this algorithm will produce its principal (most general) type and its TA λ -deduction tree. If the given λ-term is not typable, this algorithm will give a correct statement that the given λ-term is not typable. Here are some examples of input and output of this algorithm: 1. Input: λyz.(yz)z Output: y : a a b y : a a b z : a z : a ( E) y : a a b, z : a yz : a b z : a z : a ( E) y : a a b, z : a (yz)z : b ( I) y : a a b λz.(yz)z : a b ( I) λyz.(yz)z : (a a b) a b 2. Input: λxz.(xz)x Output: The term is not typable We do not explain the details of the algorithm in this paper due to space limitation. Please check the details in [, 4]. In this implementation, we use a definite clause grammar (DCG) in Prolog for parsing the input as a λ-term. While parsing the λ-term, the parser constructs a tree that represents the given λ-term. If the given λ-term is valid, the program will apply the principal-type algorithm to decide whether the given λ-term is typable or not and produce a deduction for the typable case. Generally the process is described by the flowchart in Figure 1. The principal-type algorithm consists of four cases: (1) when the λ-term is a term variable, (2) when the λ-term is an application, () when the λ-term is an abstraction λx.p with x F reev ariable(p ), and (4) when the λ-term is an abstraction λx.p with x / F reev ariable(p ). The four cases are distinguished in the predicate pta/5 which implements the algorithm by recursively analyzing the structure of the tree which represents the input λ-term. The five arguments of the predicate are as follows: 4 1. The λ-term M which we want to assign a type. 2. The TA λ -deduction for the λ-term M.. The result of the algorithm, i.e. the statement which says that the λ-term M is typable or not.

3 Figure 1: Flowchart for the Implementation of the Principal-Type Algorithm 4. The list of variables used during deduction. 5. The tree which represents the deduction. The case distinction happens in the first argument. For example, we represent an abstraction λx.m as abstraction(termvar(x),m). Then if the λ-term in the current recursion has that form, then we apply the algorithm for an abstraction. Improvement on the Principal-Type Algorithm In our implementation, we make some modification to improve the performance of the principaltype algorithm given in [4]. The improvement is obtained by combining case II and case III. This modification eliminates the need for checking whether an abstraction variable is free in the abstraction body or not. The Type Inhabitant Search Algorithm Implementation The type inhabitant search algorithm is a core procedure for answering the question given a type τ, how many inhabitants (closed λ-terms in β-normal form) can receive τ in TA λ? [8, 4]. This algorithm can be used as a tester whether the number of closed λ-terms that can receive a certain type τ is zero or not. As a consequence, by the Curry Howard correspondence, it can be used to test whether a certain implicational formula in intuitionistic logic is provable or not. The algorithm takes a type as input and searches for closed λ-terms in β-normal form that can receive the given type in TA λ through several steps. For example, given τ (((c d) c a) b) (d a) b as input, the algorithm will produce the following sets: A (τ, 0) = {V τ }, A (τ, 1) = {λx ((c d) c a) b 1 x d a 2.x ((c d) c a) b 1 V (c d) c a 1 }, A (τ, 2) = {λx ((c d) c a) b 1 x2 d a.x ((c d) c a) b 1 (λx c d x c 4.xd a 2 V2 d)}, 5

4 A (τ, ) = {λx ((c d) c a) b 1 x d a 2.x ((c d) c a) b 1 (λx c d x c 4.xd a 2 (x c d V c))}, A (τ, 4) = {λx ((c d) c a) b 1 x2 d a.x ((c d) c a) b 1 (λx c d x c 4.xd a 2 (x c d x c 4 ))} as it searches for closed λ-terms in β-normal form. The λ-terms are written here in full typed-notation where each term variable is decorated with its type explicitly at the superscript position. The sequence of A -sets shows the approximation from initially unknown λ-terms (containing meta-variables V, V 1, V 2, etc.) toward closed λ-terms in β-normal form. In the example above, type τ has the λ-term λx ((c d) c a) b 1 x d a 2.x ((c d) c a) b 1 (λx c d x c 4.xd a 2 (x c d x c 4 )) as its inhabitant. By the Curry Howard correspondence, the existence of this inhabitant means that the formula (((c d) c a) b) (d a) b is valid in intuitionistic logic. In our implementation, we use definite clause grammars in Prolog for parsing the input as a type expression. The parser constructs a tree that represents the given type expression. If it is valid, the program will run the type inhabitant search algorithm to search for its inhabitants. In general, the process is described by the flowchart in Figure 2. Figure 2: Flowchart for the Implementation of the Type Inhabitant Search Algorithm The main idea of the type inhabitant search algorithm is to iterate through the approximation of the λ-term and to produce A-sets with certain depth (A(τ, 0), A(τ, 1),..., A(τ, n)) during the iteration. In this implementation, we model the iteration as recursion which constructs the A-sets. We define a predicate searchihbt/ with the following arguments: 1. an A-set, i.e. A(τ, d) for a certain type τ and depth d. 2. the list of previous A-sets, i.e. the list of A(τ, t) with t = 0, 1,..., d 1.. the list of all A-sets that we get during the iteration (searching). 6

5 4 User Interface To help users interact with the implementation of those two algorithms, we provide a userfriendly GUI (graphical user interface). The design of our user interface follows the golden rules in designing user interface [7]. Figure and Figure 4 show an overview of our GUI design. Figure : Overview of GUI Design for the Principal-Type Algorithm 7

6 Figure 4: Overview of GUI Design for the Type Inhabitant Search Algorithm The user interface consists of two main tabs: Principal-Type Algorithm tab and Type Inhabitant Search Algorithm tab. In the Principal-Type Algorithm tab, there is a textbox where user can input a λ-term and a panel where the type deduction is shown. In the Type Inhabitant Search Algorithm tab, there is a textbox where user can input a type and a panel where the algorithm result is shown. This GUI is implemented using Java with Prolog in the back end. We also use LaTeX to help generating tidy output from the algorithms, i.e. deduction trees and steps of type inhabitants searching. In general, the program works as follows. The Java program takes the user input and calls the Prolog programs implementing the algorithms declaratively. The Prolog programs generate the output of the algorithms as LaTeX code. After the algorithms finish execution, the Java program calls LaTeX to compile the algorithm output into a PDF file. Lastly, the Java program reads the generated PDF file and displays it to the user as output. The flowchart of this architecture is shown in Figure 5 and the explanation is as follows: 8 1. User writes a λ-term into the input textbox. 2. The Java GUI program parses the input λ-term using the parser implemented in Prolog.. The parser passes the parsed λ-term to the program implementing the principal-type algorithm. 4. The Java GUI program gets back the deduction result for the given λ-term. 5. The Java GUI program writes the deduction in LaTeX format into a file. 6. The Java GUI program calls the LaTeX program to convert the LaTeX file into a PDF file.

7 Figure 5: Illustration of the Scenario for the Principal-Type Algorithm Program 7. The Java GUI program reads the PDF file. 8. The Java GUI program displays the solution to the user. For the program of the type inhabitant search algorithm implementation, the flowchart is similar. The difference is only on the parser and the main Prolog program for computing the final result. As a package, this GUI-based implementation of the principal-type algorithm and the type inhabitant search algorithm can play the role of a proof tool that provides assistance in constructing deductions in type theory and establishing the validity of implicational intuitionisticlogic formulas. The intuitive interface helps people study and understand the two algorithms and the related theories. A web-based version of the software, called λ-guru, has also been built. It can be accessed at Generally, to construct the λ-guru, we convert the Java GUI program, which is developed under the Java Swing library, into a JApplet. We also create a PHP program which accepts HTTP POST requests from the JApplet. This PHP program then calls the Prolog program which parses the input and applies the principal-type algorithm or the type inhabitant search algorithm. After the PHP program gets the result back from the Prolog program, it then forwards the algorithm result to the JApplet program. Finally, the JApplet program displays the result to the user. The flowchart of this process is shown in Figure 6. 5 Conclusion and Future Work We have presented a Prolog-based implementation of a proof tool that provides assistance in constructing deductions in type theory and establishing the validity of implicational intuitionisticlogic formulas. With this functionality, this proof tool is useful for learning type theory. This 9

8 Figure 6: λ-guru Web-based Architecture proof tool focuses on an important variant of type theory named TA λ, especially on its two core algorithms: the principal-type algorithm and the type inhabitant search algorithm. We have elaborated on how to implement those two algorithms declaratively in Prolog and the overall GUI-based program architecture. We have also described the graphical user interface that can help users interact with the program. Furthermore, we have built a web-based version of the proof tool called λ-guru. The next step of this work is to implement declaratively the converse principal-type algorithm. It is shown in [4] that if a type τ is assignable to a closed λ-term M but is not the principal type of M, then it is the principal type of another closed λ-term M. The task of the converse principal-type algorithm is to construct M when τ and M are given. Acknowledgments The authors would like to thank the anonymous reviewers of this paper for their helpful comments and suggestions. References [1] A. N. Whitehead and B. Russell. Principia Mathematica. Cambridge University Press, Cambridge, revised edition, [2] L. Sterling and E. Shapiro. The Art of PROLOG. MIT Press, Massachusetts, second edition, [] J. R. Hindley. The Principal Type-Scheme of an Object in Combinatory Logic. Trans. American Math. Soc., [4] J. R. Hindley. Basic Simple Type Theory. Cambridge University Press, Cambridge, first edition, [5] C. Munoz. Type theory and its applications to computer science. Quarterly News Letter of Institute for Computer Application in Science and Engineering (ICASE), Vol 8, No 4, [6] Benjamin C. Pierce. Types and Programming Languages. The MIT Press, Cambridge, Massachusetts, [7] B. Shneiderman and C. Plaisant. Designing The User Interface. Pearson Education, fourth edition,

9 [8] B. Yelles. Type-assignment in the lambda-calculus; syntax and semantic. Technical report, Mathemathics Dept. University of Wales Swansea, Swansea SA2 8PP, UK,