Computers, Visualization and the Nature of Reasoning

Computers, visualization, and the nature of reasoning Jon Barwise and John Etchemendy1 The computer is bringing about a revolution in our understanding of inference, representation, and reasoning, some of the most fundamental no- tions of logic. The revolution is far from complete, but we think the direction is clear enough. In this article we describe how the computer led the two of us first to change the way we teach elementary logic, and eventually to rethink basic assumptions about the subject matter of our discipline. We think the story is a remarkable case study of the synergy between teaching, technol- ogy, and research. 1 Some autobiography Our story begins in 1983 when we both returned to Stanford from teaching at other universities. Elementary logic instruction is part of the bread-and-but- ter teaching in Stanford’s philosophy department, as it is in most philosophy departments. There is a difference, though, because Stanford has a long tradi- tion of using computers in logic instruction. This dates back to the late 1960’s, when Patrick Suppes introduced his program Valid into Philosophy 57, Stanford’s elementary logic course. This program ran on a mainframe computer devoted to nothing else, and provided students with an entire course of instruction in introductory logic. Like most logic courses offered from the 60’s through the 80’s, it focused on teaching the basic syntactic rules of proof in a formal calculus. Unlike most, it covered the subject in considerable depth, delving into axiomatic systems of some sophistication. 1The programs described in this paper were conceived by the authors, but would never have be- come realities without the design and programming talents of Gerry Allwein, Dave Barker- Plummer, Kalpana Bharadwaj, Alan Bush, Doug Felt, Dan Fish, Christopher Fuselier, Bill Graham, Mark Greaves, Adrian Klein, Mike Lenz, Steve Loving, Eric Ly, Atty Mullins, Pete Murray, Mark Ravaglia, Xin Wei Sha, Jason Strober, Rolf van Widenfelt, and Rick Wong. Financial support was received from Stanford University’s Faculty Author Development Program and Center for the Study of Language and Information, and from Indiana University’s Visual Inference Laboratory. 1 Over the years, thousands of Stanford students learned logic from Valid. While one section of Philosophy 57 was always “person taught”—for computer-phobic students—the bulk of elementary logic instruction was shouldered by Suppes’ pioneering program. This freed most of the Stanford philosophy faculty from the burden of teaching elementary logic. In particular, the two of us could teach more advanced and interesting logic courses. That first year we taught courses in computability (Turing machines, recur- sive functions, undecidablity) and mathematical logic (truth, models, sound- ness, completeness). In the winter of 1984, the same year we returned to Stanford, Apple Computer introduced its Macintosh. The graphical capabilities of the Macintosh immediately captured our imagination as a way to solve some basic pedagogical problems we had encountered in these logic courses. One problem in teaching computability had to do with Turing machines, a model of computation developed in the thirties by the famous logician Alan Turing, and a fundamental notion in theoretical computer science. The problem was the difficulty of giving students a real sense of the power of Turing machines. Since Turing machines get extremely complicated extremely fast, the only ex- ercises we could assign (and have any hope of grading) were toy problems that called for the construction of very simple machines. And even with these simple machines students often failed to get them right, due to the difficulty of verifying that a particular machine did what it was supposed to do. For many students the gap between the problems they could hope to solve with pencil and paper and the evident power of the modern computer made many claims in the course seem far-fetched. For example, students were led to ac- cept Church’s Thesis, the claim that Turing machines can compute any func- tion that can be calculated by mechanical or algorithmic means, more on the basis of our authority than on the basis of their own appreciation of the in- credible power of these machines. The problem in mathematical logic was of a very different sort. In our classes many students who had been quite successful in constructing proofs using Valid, students who should have understood the symbolic language in which those proofs were couched, in fact had great difficulty grasping the very intuitive notion of truth in a structure. This lack of understanding evidenced itself repeatedly. For example, students would make egregious errors in translating between sentences of English and sentences of first-order logic, errors that would have been inconceivable had they really understood the meanings of both sentences. The Macintosh’s graphical capabilities inspired us to tackle these problems in a new way. We envisioned tools that would facilitate the student’s ability to visualize the abstract subject matter of logic, and thereby work more effectively with it. Over the next four years, funded by Stanford’s Faculty 2 Author Development project, we worked with teams of student program- mers to develop programs we called Turing’s World [2] and Tarski’s World [3]. As hoped, these programs have been extremely successful in addressing the pedagogical problems at which they were aimed. What we did not expect, however, was that they would lead us to rethink the conceptual foundations of our subject. In order to explain this second result, we need to briefly describe the programs. Turing’s World Introduced by Alan Turing in 1936, Turing machines are one of the key ab- stractions used in modern computability theory, the study of what computers can and cannot do. A Turing machine is a particularly simple model of the digital computer, one whose operations are limited to reading and writing symbols on a linear tape, or moving along the tape to the left or right. The tape is marked off into squares, each of which can be filled with at most one symbol. At any given point in its operation, the Turing machine can read or write on only one of these squares, the square located directly below its “read/write” head. In Turing’s World the tape is represented by a narrow window that sits at the bottom of the screen. Figure 1 shows the tape with a series of A’s and B’s written on it, and with the read/write head located on the leftmost of these symbols. Figure 1: A tape from Turing’s World. A Turing machine has a finite number of states and is in exactly one of these states at any given time. Associated with these states are instructions telling the machine what action to perform if it is currently scanning a particular symbol, and what state to go into after performing this action. The states of a Turing machine are generally represented by a “flow” or “state” diagram, using circles for the states and labeled arcs for the instructions associated with those states. For example, Figure 2 shows the state diagram of a Turing machine with just two states. 3 Figure 2: A simple Turing machine. The linguistic description of this same machine would be given as fol- lows: In state 0: if you see an A, move right and go into state 0. In state 0: if you see a B, move right and go into state 1. In state 1: if you see a B, move right and go into state 1. or, in abbreviated “4-tuple” notation: 0, A, R, 0 0, B, R, 1 1, B, R, 1 This machine will run down a string of A’s and B’s, stopping at the first A it sees after a B. For example, if run on the sample tape above, it would stop when it got to the fourth symbol from the left, because it would then be in state 1 with no instructions about what to do next. In Turing’s World, a collection of graphical tools lets you design Turing machines by directly drawing their state diagrams. When you run a Turing machine in Turing’s World, the operation of the machine is displayed graph- ically, both on the tape and in the state diagram window. On the tape, the read/write head moves, making the changes required by the machine you’ve designed. In the state diagram, the nodes and arcs highlight to show the changing state of the computation. Turing’s World also allows students to display the text-based “4-tuple” description of their machines, though we have found that they rarely do. Despite their simplicity, Turing machines can be designed to compute remarkably complex functions. In fact, they are generally thought to be as 4 powerful (in theory) as any possible computer. Finding out what they can do is half the fun of studying computability. Figure 3 shows part of the detail of a Turing machine that adds two numbers expressed in decimal notation. Figure 3: A Turing machine for adding in base 10. The ability to design a Turing machine by simply drawing its state diagram, combined with the ability to run the machine and watch it go through its transitions, is a powerful aid in the student’s understanding of the intuitive idea of a Turing machine. By allowing students to introduce subma- chines (as illustrated in Figure 3), the program lets them quickly build up a powerful arsenal of Turing machines and to combine them in important ways. In our classes we now routinely ask students to design a Universal Turing machine, a machine that acts as a fully programmable computer.

Load more