Turing Machine on Attribute Theory

The main thesis of this chapter is that a dynamical viewpoint allows us to better understand some important foundational issues of computation theory. Effective procedures are traditionally studied from two different but complementary points of view. The first approach is concerned with individuating those numeric functions that are effectively calculable. This approach reached its systematization with the theory of the recursive functions (Gödel, Church Kleene).This theory is not directly concerned with computing devices or computations. Rather, the effective calculability of a recursive function is guaranteed by the algorithmic nature of its definition. In contrast, the second approach focuses on a family of abstract mechanisms, which are then typically used to compute or recognize numeric functions, sets of numbers, or numbers. These devices can be divided into two broad categories: automata or machines (Turing and Post), and systems of rules for symbol manipulation (Post). The mechanisms that have been studied include: a. Automata or Machines 1. gate-nets and McCulloch-Pitts nets 2. finite automata (Mealy and Moore machines) 3. push-down automata 4. stack automata 5. Turing machines 6. register machines 7. wang machines 8. cellular automata b. Systems of Rules 9. monogenic production systems in general 10. monogenic Post canonical systems 11. monogenic Post normal systems 12. tag systems. I call any device studied by computation theory a computational system. Computation theory is traditionally interested in studying the relations between each type of computational system and the others, and in establishing what class of numeric functions each type can compute. Accordingly one proves two kinds of theorem: (1) that systems of a given type emulate systems of another type (examples: Turing machines emulate register machines and cellular automata; cellular automata emulate Turing machines, etc.), and (2) that a certain type of system is complete relative to the class of the (partial) recursive functions or, in other words, that this type of system can compute all and only the (partial) recursive functions (examples of complete systems: Turing machines, register machines, cellular automata, tag systems, etc.). All different types of computational systems have much in common. Nevertheless, it is not at all clear exactly which properties these mechanisms share.

The well known lambda calculus was first formulated by Alonzo Church (1932). It was originally intended as a new foundation of mathematics; but soon the remarkable connection between lambda definability and recursive functions was developed. Only much later was the connection with rewrite systems noted, while the remarkable influence of the calculus in computer languages was also noted later. This note is to point out that the Galois connections and this lambda calculus are perhaps the first appearances of an explicit pair of adjoint functors. These functors in general were not found until the work of Daniel Kan in 1958.1

A model for computation over an arbitrary (ordered) ring R is presented. In this general setting, universal machines, partial recursive functions, and NP-complete problems are obtained. While the theory reflects of classical over Z (e.g. the computable functions are the recursive functions), it also reflects the special mathematical character of the underlying ring R (e.g. complements of Julia sets provide natural examples of recursively enumerable undecidable sets over the reals) and provides a natural setting for studying foundational issues concerning algorithms in numerical analysis.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

An RNA-based theory of natural universal computation

A Concise Introduction to Computation Models and Computability Theory provides an introduction to the essential concepts in computability, using several models of computation, from the standard Turing Machines and Recursive Functions, to the modern computation models inspired by quantum physics. An in-depth analysis of the basic concepts underlying each model of computation is provided. Divided into two parts, the first highlights the traditional computation models used in the first studies on computability: - Automata and Turing Machines; - Recursive functions and the Lambda-Calculus; - Logic-based computation models. and the second part covers object-oriented and interaction-based models. There is also a chapter on concurrency, and a final chapter on emergent computation models inspired by quantum mechanics. At the end of each chapter there is a discussion on the use of computation models in the design of programming languages.

A type theoretic programming language is introduced that is based on lambda calculus with coproducts, products and inductive types, and additionally allows the definition of recursive functions in the way that is common in most functional programming languages. A formal system is presented that checks whether such a definition is structurally recursive and a soundness theorem is shown for this system. Thus all functions passing this check are ensured to terminate on all inputs. For the moment only non-mutual recursive functions are considered.

Recursive function theory studies functions that can be evaluated by an algorithm based on some computing model such as a Turing machine or computer program. These functions are called partial recursive (p.r.) and are defined on subsets of N, where N = {0, 1,... }, with values in N. (A good introduction to the theory may be found in [2].) This paper explains the Parameter Theorem, illustrates some unusual computer programs, and explains their connection to recursive function theory. Basing our computing model on a modern high level language, we can construct programs whose existence is known through more formal means. Our functions will operate on strings rather than numbers, however. There is no loss in generality since strings can be viewed as members of N, and vice-versa. From a practical aspect, this approach is somewhat more desirable since conventional programming languages often allow making use of long strings, but place more restrictive limits on the size of integers. We first pose a problem: Does there exist a program (written in some conventional programming language) which halts if and only if its input is identical to the program's text (i.e., source code)? For the remainder of this note X is the set of ASCII characters 'a,' 'b, +,' space, line feed, and so forth, needed to write programs in most programming languages. We denote by X * the set of all strings (finite sequences) over X. Let P1 be the set of all one variable partial recursive functions on X *. A function I belongs to P1 if and only if there is a subset of S of X* and some algorithm which computes 't by associating with each element of S a well-defined element of X *. Similarly, 't belongs to P2 if and only if there is a set S c X * X X *, and an algorithm for 't which associates with each element of S a well-defined element of X *. A partial recursive function I in P1 (or in P2) is recursive if the algorithm is defined on all of X * (or X * X X *). This is equivalent to saying that the algorithm which evaluates I always halts. Our computing model will be based on Adat; its high-level string-handling properties simplify later examples. For readability, however, we will express algorithms in a more familiar Pascal-like style. Readers familiar with either programming language should find forthcoming algorithms sufficiently clear. A formal presentation in Ada is given in the Appendix. A string of ASCII characters, such as in FIGURE 1, represents a function in our language which takes strings to strings. Of course, strings of ASCII characters such as The quick brown fox and %*!! represent nothing at all in our programming language. Let A1 be the set of all strings in X * representing functions in our language of one input STRING which outputs a STRING. Similarly let A2 be the set of all strings in

The modern theory of computability is based on the works of Church, Markov and Turing who, starting from quite different models of computation, arrived at the same class of computable functions. The purpose of this paper is the show how the main results of the Church-Markov-Turing theory of computable functions may quickly be derived and understood without recourse to the largely irrelevant theories of recursive functions, Markov algorithms, or Turing machines. We do this by ignoring the problem of what constitutes a computable function and concentrating on the central feature of the Church-Markov-Turing theory: that the set of computable partial functions can be effectively enumerated. In this manner we are led directly to the heart of the theory of computability without having to fuss about what a computable function is.The spirit of this approach is similar to that of [RGRS]. A major difference is that we operate in the context of constructive mathematics in the sense of Bishop [BSH1], so all functions are computable by definition, and the phrase “you can find” implies “by a finite calculation.” In particular ifPis some property, then the statement “for eachmthere isnsuch thatP(m, n)” means that we can construct a (computable) functionθsuch thatP(m, θ(m))for allm. Church's thesis has a different flavor in an environment like this where the notion of a computable function is primitive.One point of such a treatment of Church's thesis is to make available to Bishopstyle constructivists the Markovian counterexamples of Russian constructivism and recursive function theory. The lack of serious candidates for computable functions other than recursive functions makes it quite implausible that a Bishopstyle constructivist could refute Church's thesis, or any consequence of Church's thesis. Hence counterexamples such as Specker's bounded increasing sequence of rational numbers that is eventually bounded away from any given real number [SPEC] may be used, as Brouwerian counterexamples are, as evidence of the unprovability of certain assertions.

Preface. About This Book. Part 1: Paradigms of Programming. Introduction. Logic Programming. Higher-Order Functions. Combinators. Turing Machines. Part 2: Visualization. Animated Algorithms. Function Iteration and Chaos. Fractional Brownian Motion. Uniform Polyhedra. The Stellated Icosahedra. Ray Tracing. Single-Image Stereograms. Appendixes. References. Index of Programs. Index. Preface. About This Book: Overview. About the Programs. Notation and Terminology. The Mathematica Programmer CD-ROM. The Mathematica Programmer WWW Archive. Colophon.Part 1: Paradigms of Programming: Introduction: Mathematica's Programming Language. Pattern Matching and Term Rewriting. Programming Styles. Program Organization. Logic Programming: The Ingredients of Logic Programs. A PROLOG Interpreter for Mathematica. Lists in PROLOG. Backtracking. Deduction. Higher-Order Functions: Introduction. The Functional Features of Mathematica. Functions as Data. Fixed Points of Higher-Order Functions. Combinators: Introduction. Combinatory Algebras. Combinatory Abstraction. Converting Functions to Combinators. Applications. Turing Machines: Introduction. A Turing Machine Simulator. Assembly Programming. Recursive Functions. Optimization. Conclusions. The Complete Code of TuringMacros.m. Part 2: Visualization: Animated Algorithms: Three Standard Sorting Algorithms. Asymptotic Behavior. Conclusions. Function Iteration and Chaos: Function Iteration. Bifurcations. The Final-State Diagram. The Ingredients of Chaos. Super-Attractive Orbits. Conclusions. Fractional Brownian Motion: Introduction. Random Additions. Fourier Synthesis. Random Faults. Analysis of fBm Data. Uniform Polyhedra: Introduction. Uniform Construction. Data Structures. Rendering. Auxiliary Programs. The Stellated Icosahedra: Introduction. Rendering. Discussion. The Complete Code of Icosahedra.m. Ray Tracing: A Data Type for Surfaces. Photorealistic Rendering. Converting Mathematica Graphics. Sample Images. Stereo Pairs. The Complete Code of POVray.m. Single-Image Stereograms: Introduction. The Classis SIRDS in Mathematica. Designing Good Images. Exact Stereograms. Interface to External SIS Generators. The Complete Code of SIS.m. Appendixes. References. Index of Programs. Index.

I show how backtracking can be discovered naturally without using a recursive function (nor using a loop with an explicit stack). Rather, my approach involves a form of self application that can be elegantly expressed in an object-oriented program, and that is reminiscent of how recursion is done in lambda calculus. It also illustrates why reasoning about object-oriented programs can be hard.

We prove that orthogonal constructor term rewrite systems and lambda-calculus with weak (i.e., no reduction is allowed under the scope of a lambda-abstraction) call-by-value reduction can simulate each other with a linear overhead. In particular, weak call-by- value beta-reduction can be simulated by an orthogonal constructor term rewrite system in the same number of reduction steps. Conversely, each reduction in a term rewrite system can be simulated by a constant number of beta-reduction steps. This is relevant to implicit computational complexity, because the number of beta steps to normal form is polynomially related to the actual cost (that is, as performed on a Turing machine) of normalization, under weak call-by-value reduction. Orthogonal constructor term rewrite systems and lambda-calculus are thus both polynomially related to Turing machines, taking as notion of cost their natural parameters.

From the 1940s to the 1960s, despite the significant work done on recursive functions (properly) and later on the lambda-calculus, the theory of calculability was developed more and more as a theory of computation by an idealized machine, or in the form of a general theory of algorithms. I will only deal here with the former aspect, a development that stems from the concepts introduced in 1936 by Turing. I will try to show how Turing’s ideas were gradually adopted, developed and modified. The Turing machine had an increasingly important role and was the object of systematic investigation. It was subsequently reworked to such an extent that a new model of machine was fashioned, the program and register machine. However, the initial model kept a significant place, and extensions of Turing’s analysis led, toward the end of the century, to profound reflections about the notion of a constructive object and the general notion of an algorithm.

Let ωe denote the e th r.e. subset of the natural numbers N, i.e. ωe = {x: φe(x) converges} where φe is the partial recursive function computed by the e th Turing machine. Then an r.e. set A is called nowhere simple if A is coinfinite and for any r.e. set W e, there exists an r.e. set W'e ⊆ W e such that W'e ⋂ A = Ø and card(W e − A) = ∞ if and only if card(W'e) = ∞. We say A is effectively nowhere simple if there is an effective procedure to find the index of such a W'e from e, i.e. if there is a recursive function f such that W f(e) = W'e. In this case, f is said to be a witness function for A. These classes of sets were introduced by Shore in [20] where he used them to investigate automorphism bases for ℒ(ω) (the lattice of r.e. sets) and ℒ*(ω) (ℒω) modulo finite sets). In particular he was able to give an easy proof of the main result of [19] that any nontrivial class of r.e. sets closed under recursive isomorphisms is an automorphism base for ℒ*(ω) using these sets. Subsequent to this paper, various investigations concerning automorphisms of ℒ(ω) and ℒ*(ω) have utilized properties of r.e. sets with rich lattices of supersets. For example, for effectively nowhere simple sets, Maass [11] proved that any two effectively nowhere simple sets have effectively isomorphic lattices of supersets. Another such property is the outer splitting property [11].

Algorithms for various computations have been known and studied for centuries, but it is only recently that much theoretical attention has been devoted to the analysis of algorithms. Turing machines and recursive functions were the first approaches, but these models, which provide much interesting mathematics, do not look at the problem from a practical standpoint. In real computing, no one uses Turing machines to evaluate polynomials or to multiply matrices, and little of practical significance is obtained from that approach. On the other hand, recent work has led to more realistic models and, correspondingly, to more practical results. Most of the results cannot be considered to be truly practical, but, all of them were motivated by practical considerations.

Some type-based approaches to termination use sized types: an ordinal bound for the size of a data structure is stored in its type. A recursive function over a sized type is accepted if it is visible in the type system that recursive calls occur just at a smaller size. This approach is only sound if the type of the recursive function is admissible, i.e., depends on the size index in a certain way. To explore the space of admissible functions in the presence of higher-kinded data types and impredicative polymorphism, a semantics is developed where sized types are interpreted as functions from ordinals into sets of strongly normalizing terms. It is shown that upper semi-continuity of such functions is a sufficient semantic criterion for admissibility. To provide a syntactical criterion, a calculus for semi-continuous functions is developed.