Download The Representational Foundations of Computation and more Lecture notes Theory of Computation in PDF only on Docsity!
The Representational Foundations of Computation
Michael Rescorla
Abstract : Turing computation over a non-linguistic domain presupposes a notation for the domain. Accordingly, computability theory studies notations for various non-linguistic domains. It illuminates how different ways of representing a domain support different finite mechanical procedures over that domain. Formal definitions and theorems yield a principled classification of notations based upon their computational properties. To understand computability theory, we must recognize that representation is a key target of mathematical inquiry. We must also recognize that computability theory is an intensional enterprise: it studies entities as represented in certain ways, rather than entities detached from any means of representing them.
1. A COMPUTATIONAL PERSPECTIVE ON REPRESENTATION Intuitively speaking, a function is computable when there exists a finite mechanical procedure that calculates the function’s output for each input. In the 1930s, logicians proposed rigorous mathematical formalisms for studying computable functions. The most famous formalism is the Turing machine : an abstract mathematical model of an idealized computing device with unlimited time and storage capacity. The Turing machine and other computational formalisms gave birth to computability theory : the mathematical study of computability.
A Turing machine operates over strings of symbols drawn from a finite alphabet. These strings comprise a formal language. In some cases, we want to study computation over the formal language itself. For example, Hilbert’s Entscheidungsproblem requests a uniform mechanical procedure that determines whether a given formula of first-order logic is valid. Items drawn from a formal language are linguistic types , whose tokens we can inscribe, concatenate, and manipulate [Parsons, 2008, pp. 34-36, pp. 160-164]. Most of modern mathematics concerns non-linguistic entities , such as natural numbers or real numbers. These entities do not have tokens that we can inscribe, concatenate, or manipulate [Parsons, 2008, pp. 37-39]. Thus, they do not comprise a formal language over which a Turing machine can directly operate. Nevertheless, we would like to extend the notion of Turing computability to subsume natural numbers, real numbers, and other non-linguistic domains. Our interest in non-linguistic domains of computation ensures a central theoretical role for representation , as the following argument makes explicit: A Turing machine manipulates linguistic items, but we sometimes want to study computation over non-linguistic domain X. So there is a gap between the domain of items manipulated by the Turing machine and our desired domain of computation X. To bridge the gap, we must interpret linguistic items manipulated by the Turing machine as denoting items drawn from X. A Turing machine computes over X only if linguistic items manipulated by the Turing machine represent elements of X. Thus, any complete theory of computation must cite representational relations between linguistic items and non- linguistic items. This argument, which I will call the Gap Argument , is quite robust. It does not assume any special conception of the ‘symbols’ comprising the Turing machine ‘alphabet.’ It does not
2. COMPUTATION OVER NON-LINGUISTIC DOMAINS
A Turing machine contains a scanner that moves along a machine tape divided into cells. Depending on the scanner’s state and the contents of its current cell location, the scanner either erases a symbol, inscribes a symbol, or moves to the left or right. Symbols belong to a fixed finite alphabet that contains at least two elements. Let * be the set of finite strings over . A Turing machine halts when it reaches a point where its instructions dictate no further action. For x , y , say that Turing machine T yields output y on input x iff If T begins computation with x inscribed on an otherwise blank machine tape and with the scanner located at the beginning of x , then T eventually halts with y inscribed on an otherwise blank machine tape. Say that Turing machine T computes : * iff
T yields output ( x ) on any input x dom (), and T yields no output on any input x dom ().
: * * is partial recursive iff some Turing machine computes it. One can easily extend these definitions to functions with multiple arguments. Computability theory is important partly because it illuminates computation over non- linguistic domains, such as the natural numbers and the real numbers. However, applying the Turing machine formalism to non-linguistic domains raises various complications. This section surveys several notable complications. Subsequent sections draw philosophical morals.
2.1. Relativity Classical recursion theory emphasizes the intuitive concept computable function from natural numbers to natural numbers. If we want to elucidate this concept through the Turing machine
formalism, then the Gap Argument shows that we must introduce a semantic interpretation over strings. Let d : * be a surjective function, where is the natural numbers. If d ( x ) is
defined, then x is a d - name for d ( x ).^1 Say that Turing machine T computes f : relative to d iff there is a function : * * such that T computes and
f ( d ( x ) = d (( x )), for all x . Informally, T converts a d -name for any x dom ( f ) into a d -name for f ( x ). Pick any standard notation for the natural numbers. For example, let dbinary : be binary notation.
Then f : is partial recursive iff it is Turing-computable relative to dbinary. Church’s thesis (sometimes called the Church-Turing thesis ) states that a number-theoretic function is intuitively computable iff it is partial recursive. One might try to avoid the Gap Argument by characterizing numerical computability through notions defined directly over the natural numbers, rather than linguistic intermediaries. To illustrate, say that a numerical function is Kleene-computable iff we can obtain it from the primitive recursive functions through function composition and application of the minimization operator . Kleene’s Normal Form Theorem entails that a function is partial recursive iff it is Kleene-computable. We define Kleene-computability without mentioning symbol manipulation, so the Gap Argument does not apply. However, few commentators would recommend Kleene-computability as a satisfactory foundation for computability theory. As Gödel [1934/1986, pp. 369-370] maintained, Turing analyzes not just computability but computation itself. Turing thereby connects formal
(^1) Philosophers and computability theorists typically assume that ’s elements are individuated non-semantically , through factors such as geometric shape. Under this assumption, the string language taken on its own is equallycompatible with any arbitrary semantic interpretation d. In [Rescorla, forthcoming], I question whether the Turing formalism mandates an alphabetthese issues aside. I assume an alphabet whose elements are individuated non-semantically. For present purposes, I set whose elements are individuated non-semantically.
Kleene proved that one can computably incorporate arguments of partial recursive functions into indices for partial recursive functions: Parameterization (or s-m-n) theorem : There exists a partial recursive function s : × * such that, for all x , y , z , x ( y , z ) = s ( x , y ) ( z ). Indexing of partial recursive functions underlies most of recursion theory’s basic results: Rice’s theorem; the Kleene recursion theorem; and so on.^4 In general, suppose we want to model Turing computations that take inputs drawn from countable domain X and yield outputs drawn from countable domain Y. Suppose that neither X nor Y contains strings drawn from a finite alphabet of symbols. Then we must introduce notations for X and Y. For present purposes, we construe notations as surjective functions d : X and e : * Y. We say that f : X Y is computable relative to d and e iff there is a partial
recursive : * * such that f ( d ( x )) = e (( x )), for all x *. Informally, converts a d -name for each x dom ( f ) into an e -name for f ( x ).^5 Our definitions reflect a crucial relativity inherent to Turing-computation over a non- linguistic domain: Relativity : Turing computation over non-linguistic domains is relative to a notation. The same Turing machine T computes different non-linguistic functions, depending upon the semantic interpretation of strings manipulated by the Turing machine. To illustrate, consider a machine T that doubles the number of stroke marks on the tape, and let m be a string of m strokes. If m denotes the number m , then T computes the function f ( n ) = 2 n. If (^4) Similarly, one can introduce a canonical indexing for numerical partial recursive functions f : . The results mentioned in this paragraph are typically proved for that case, rather than for string-theoretic functions. But theproofs are essentially the same in either case. (^5) This definition captures a notion sometimes called strong computability. In contrast, weak computability demands only thatcomputability theorists assign more weight to weak computability than strong computability. For our purposes, the f ( d ( x )) = e (( x )) for all x dom ( f (^) d ). See [Weihrauch, 2000, pp. 53-54, p. 59]. Outside recursion theory, difference is not important.
m denotes the number m -1, then T computes g ( n ) = 2 n + 1. Lacking a determinate interpretation of strings, we cannot treat a Turing machine as computing a determinate function over the natural numbers. Similarly, consider any UTM. Relative to our canonical indexing , the UTM computes the function : ×* * that carries x and y * to x ( y ), assuming x ( y ) is
defined. Yet the UTM does not compute relative to a suitably different notation for. As these examples illustrate, a change in notation typically alters the non-linguistic function computed by a Turing machine. Lacking a determinate semantic interpretation of strings, a Turing machine does not compute a determinate function over a non-linguistic domain.
2.2. Admissible versus deviant notations There exist ‘deviant’ notations relative to which intuitively non-computable functions become Turing-computable [Copeland and Proudfoot, 2010; Montague, 1960; Shapiro, 1982]. In [Rescorla, 2007], I considered the following simple example. Let A have a non-recursive
characteristic function. Let A = { x 0 , x 1 , x 2 , …} and \ A = { y 0 , y 1 , y 2 , …}. Define dA : * by
y ifnisodd d n x ifniseven n A n ( 1 )/ 2
( ) /^2
A ’s characteristic function is Turing computable relative to dA. Yet A ’s characteristic function is not recursive and hence (by Church’s thesis) not intuitively computable. Recursion theory textbooks invariably ignore deviant notations for. They select a single notation (such as dbinary ) and develop recursion theory relative to that privileged notation. For many purposes, this procedure is entirely legitimate. However, if we desire a general theory of computation over natural numbers, then the procedure seems arbitrary and unsatisfying. Numerical computation can proceed relative to diverse reasonable notations. There is no clear
More generally, consider any countably infinite domain X. There exist uncountably many notations d : * X. For any notations d 1 : * X and d 2 : * X , say that d 1 is reducible to d 2 ,
or d 1 d 2 , iff there exists a partial recursive : * * such that d 1 ( x ) = d 2 (( x )),
for all x dom ( d 1 ). Informally, is a computable translation from d 1 to d 2 : it carries each d 1 -name to a co-referring d 2 -name. Say that d 1 and d 2 are equivalent (or d 1 d 2 ) iff d 1 d 2 and d 2 d 1. We can partition the notations d : * X into equivalence classes. There are countably many
recursive : * *, so each equivalence class is countable. It follows that there are uncountably many equivalence classes. One can easily show that distinct equivalence classes induce distinct notions of computable function from X to X : If ( d 1 d 2 ), then there are functions computable relative to d 1 and d 1 that are not computable relative to d 1 and d 2. For example, the identity mapping is computable relative d 1 and d 1 (when we use d 1 -names for both inputs and outputs) but not relative to d 1 and d 2 (when we use d 1 -names for inputs and d 2 - names for outputs). Thus, one can define uncountably many concepts of computability over X. Of course, we do not have uncountably many intuitive concepts of computability over a domain. An intuitive notion of computability arises only when the relevant notations are ‘admissible’ rather than ‘deviant.’ A theory of Turing computation over any non-linguistic countably infinite domain must address the distinction between admissible and deviant notations for the domain. Unfortunately, analyzing this distinction in satisfying terms is not so easy. To illustrate, suppose one says that a notation is admissible iff there is an effective procedure that maps strings into values denoted by strings. On this analysis, admissibility
requires a computation that takes strings drawn from * and yields appropriate denotations drawn from X. Assuming that X is a non-linguistic domain, we need a notation to represent its elements. Which notations for X may we use when computing denotations of strings? Not just any notation will do. For example, many deviant notations will be incorrectly ruled admissible if we allow computations relative to dA. But why should we disallow computations relative to dA? Well, because dA itself is deviant. Unfortunately, that answer presupposes the distinction between admissible and deviant notations. In other words, suppose we say: d : * X is admissible iff there is an admissible notation e : * X and a Turing machine T such that T carries each d -name to a co-referring e- name_._ Then we assume that we have already demarcated the admissible notations for X , which renders our procedure circular. To avoid circularity, we can demand that some effective procedure carry strings to denoted values as represented by a fixed privileged notation. More precisely: (1) d : * X is admissible iff there is a Turing machine T that carries each d -name to a co- referring dX- name, where dX : * X is some fixed privileged notation for X. We may rephrase (1) as follows:
(2) d : * X is admissible iff d dX. For example, we might explicate admissibility over the natural numbers by taking dbinary as our privileged notation: (3) d : * is admissible iff d dbinary. According to (3), a numerical notation is admissible just in case we can computably translate it into binary notation. (3) seems implicit in the practice of recursion theory, which dismisses without consideration all numerical notations not reducible to dbinary. Similarly, we might
[1987, p. 41] advocates (7) rather (4) as the proper definition of admissibility for partial recursive functions (although he uses the phrase ‘acceptable’ rather than ‘admissible’).^6 Setting aside the differences between (2) and (5), each definition faces the same fundamental worry: it ties admissibility to a privileged notation arbitrarily chosen from among many equally worthy competitors [Rescorla, 2012]. Consider the special case of (3). I grant that (3) yields an extensionally adequate, non-circular characterization of admissible numerical notations. However, one can represent natural numbers using many legitimate notations besides dbinary. There is no principled basis for privileging dbinary over these alternative notations when elucidating admissibility. A good elucidation should instead isolate desirable features shared by dbinary and all the legitimate alternatives. Since (3) does not do so, it does not reveal what it is for numerical notations to be admissible. These worries become even more pronounced when we consider computation over an arbitrary domain. Definitions (2) and (5) offer no clue what desirable features are shared by the privileged notation dX for domain X and the privileged notation dY for domain Y. The definitions prioritize certain privileged notations without explaining why those notations deserve privileged status. An alternative strategy for elucidating admissibility is to isolate some ‘intrinsic’ property shared by all admissible notations. For example, we can easily prove the following result [Weihrauch, 2000, p. 73]: for any notation d : * ,
(^6) Some readers may insist that suffices for admissibility. If this verdict were correct, then it would be an example of Multiplicity (discussed in Section 2.3), so it would actually strengthen my overall argument. However, Ifind the verdict implausible. Rogers [1987, p. 42] adduces a notation such that and ( ) with the following property: there is a Turing machine that responds to input x with output 1 if x (0) is defined and output 0 if on input 0. We cannot decide this question relative to our canonical indexing x (0) is undefined. In other words, we can^ ‘decide’^ relative to^ ^ whether a given partial recursive function is defined , and normally that is taken as powerful evidence that the question is intuitively undecidable. Computation relative toyield a mechanical procedure for deciding whether partial recursive functions are defined on input 0. At the very does not seem to me to least, classifying as admissible would be a major revision to current mathematical practice.
d dbinary iff the successor function is computable relative to d and d e for any notation e : * relative to which the successor function is computable.
In a similar vein, Rogers [1987, pp. 41-42] proves that, for any notation : * , iff the Enumeration theorem and Parameterization theorems are true for (i.e. the theorems remain true when one substitutes for ). These ‘intrinsic’ characterizations of admissibility for and seem helpful. At least they avoid any appeal to an arbitrarily chosen privileged notation. However, neither characterization yields anything resembling an analysis of admissibility for the relevant domain. Neither characterization reveals why certain notations are suitable for computing over the relevant domain while others are not. Moreover, neither characterization even tries to characterize admissible notations over an arbitrary domain. Can we provide a satisfying analysis of admissibility for arbitrary domains? Or, failing that, a satisfying analysis of admissibility for certain salient domains? For present purposes, we may leave these questions unanswered. What matters is simply that the distinction between admissible and deviant notations plays an important role within computability theory. The distinction arises whenever we model computation over a countably infinite non-linguistic domain. In certain cases (such as ), the distinction is an explicit target of mathematical study.
2.3. Multiplicity Most domains studied within classical recursion theory support only a single fruitful notion of computability. But some countably infinite domains X satisfy
employed in computable analysis, as in everyday life, is to employ ‘infinitary names’ for real numbers. A few notable examples: Base-n notation : Decimal notation, dbase- 10 , is familiar to anyone with a grade school education. More generally, one can introduce a notation dbase-n that uses natural number n as its base. Turing [1936] uses dbase- 2.^7 Rational open interval notation ( dinterval ): Assume some canonical notation for rational numbers. Then we can name a real number x by listing names of all rational numbers a and b such that a < x < b. In a 1937 correction to the 1936 paper, Turing replaced dbase- 2 with dinterval , crediting the latter notation to Brouwer. Rational lower or upper bounds ( d < and d> ): We can name a real number x by listing names of all rational numbers a < x. Alternatively, we can name x by listing names of all rational numbers a>x. There are many other viable notations, including notations inspired by the familiar Cauchy sequence and Dedekind cut constructions. Formally, we model all these notations as surjective functions d : ω^ , where ω^ is the set of infinite strings over .^8 Turing computation normally operates over finite strings. Thus, one must alter the Turing formalism if one wants to model computation over infinitary names. A particularly appealing framework is Weihrauch’s [2000] Type-2 Theory of Effectivity, which builds upon earlier work by Grzegorczyk [1955], Hauck [1973], Lacombe [1955], and others. Weihrauch introduces
(^7) dbase- 2 is non-injective, since every dyadic rational number has two names: one name terminates with infinitely manymodified notation that includes only names of the first kind, so that each dyadic rational number has a unique name. ‘ 0 ’s, and the other name terminates with infinitely many ‘ 1 ’s. Turing seems to have envisioned a slightly See Gherardi [2011] (^8) Weihrauch uses the term for detailed analysis of Turing’s approach to computable analysis. ‘notation’ for surjective d : * X with X countable and the term ‘representation’ for surjective d : ω^ X with X uncountable. I use the term ‘notation’ for both kinds of mapping.
Turing-style machines that respond to infinite strings on a read-only input tape by progressively writing infinite strings onto a write-only output tape. He defines: f : is computable relative to d iff there exists a machine T such that, when supplied with a d -name for x dom ( f ) on the input tape, T progressively writes a d -name for f ( x ) onto the output tape. Intuitively: T can compute any finite initial portion of a d -name for f ( x ), given a sufficiently long finite initial portion of a d -name for x dom ( f ). Developing these ideas rigorously requires various technicalities that need not concern us. The important point is that computable analysis offers a rigorously defined notion of Turing computability relative to d for functions over. One can also rigorously define reducibility over notations d : ω^ and e : ω^ , similar to reducibility over notations for countable domains. Intuitively: d e iff some machine computes any finite initial portion of an e -name for z , given a sufficiently long finite initial
portion of a d -name for z. As Turing in effect observed, dbase-n dinterval but ( dinterval dbase-n ). Computable analysis studies computational properties of notations d : ω^ . For example, addition is not Turing-computable relative to dbase- 10. To illustrate, suppose that the input base-10 names are ‘1.444…’ and ‘1.555…’ The sum has two base-10 names: ‘2.999…’ and ‘3.000…’. One cannot determine from any finite initial portion of the input names that a corresponding output name should begin ‘ 2 ’, since any finite initial portion is consistent with the sum being > 3. Nor can one determine from any finite initial portion of the input names that the output name should begin ‘ 3 ’, since any finite initial portion is consistent with the denotation being < 3. Thus, no Turing-style machine can compute even the first digit of a dbase- 10 -name for x + y , given arbitrary finite initial portions of dbase- 10 -names for x and y.
for (^) c. In this manner, computable analysis yields numerous examples of Multiplicity over a countable domain.
3. REPRESENTATION AS CENTRAL TO COMPUTABILITY THEORY My survey of computability theory showcases the central role played by representation. Given the Gap Argument, we can study Turing computation over a non-linguistic domain only if we furnish a semantics for strings. Given Relativity, the non-linguistic function computed by a Turing machine depends upon our semantic interpretation. Some of the discipline’s most basic concepts --- including computation over , computation over , and computation over --- emerge only once we endow strings with representational import. Hence, many of the core phenomena studied by computability theory arise only once suitable representational relations are in place. When the domain of computation is both infinite and non-linguistic, representation occupies an especially central role. Since Deviancy prevails, a satisfying account must address which notations are admissible for computation over the domain. What distinguishes acceptable and deviant notations? When Multiplicity prevails, further questions arise. How do various equivalence classes of notations relate to one another? What notion of computability does each equivalence class induce? Which such notions hold any interest? The representation relation becomes a central object of study. Reducibility serves as a vital tool, sorting notation systems into equivalence classes according to their computational properties. Thus, systematic investigation of notation systems is integral to mathematical theorizing about computation. We may instructively compare computability theory with other developed branches of mathematics, such as number theory, analysis, set theory, algebra, and topology. Those fields
study a fixed mathematical structure (such as the natural numbers or the real numbers) or collection of mathematical structures (such as structures satisfying the axioms of a group or a topological space). One studies mathematical structures in themselves , without studying our representational access to those structures. Of course, one must represent a structure in order to study it. But number theory, algebra, analysis, topology, and set theory do not explicitly address our representational interface with the relevant structures. For example, number theory studies the natural numbers, without explicitly considering how we represent natural numbers. In contrast, computability theory studies human and machine computation over mathematical structures. This subject matter ensures a essential role for the representational interface between humans (or machines) and salient mathematical structures. Representation becomes an object of explicit study, in a way that it does not for most branches of mathematics.
3.1. Previous philosophical treatments of computation and representation Many philosophers have emphasized the links between computation and representation. Indeed, philosophers sometimes overstate those links. Most dramatically, Fodor [1975] insists that all computation operates over entities with representational properties. He encapsulates his view through the slogan ‘no computation without representation.’ As Chalmers [2011] and Piccinini [2008] observe, Fodor’s analysis seems implausible. Some computations do not require representation. A Turing machine might compute a string-theoretic function : * *. Strings manipulated by the machine need not have any semantic interpretation. For example, representational notions are irrelevant to Turing’s discovery that the Entscheidungsproblem is unsolvable, because the Entscheidungsproblem concerns computation over strings drawn from a finite alphabet. A significant role for representation arises only when we consider computation
