A natural axiomatization of computability and proof of Church’s thesis

1. A natural axiomatization of computability and proof of Church’s thesis Nachum Dershowitz and Yuri Gurevich

2. Some basic definition • The functions which can be built up from the initial functions using composition, primitive recursion and inversion are called the partial recursive or µ-recursive functions. They’re also sometimes just called the recursive functions, and correspond exactly to the class of all functions which are intuitively computable. • The total recursive functions are those partial recursive functions which are total.

3. Church’s Thesis • Church’s Thesis asserts that the only numeric functions that can be calculated by effective means are the recursive ones, which are the same, extensionally as the Turing-computable numeric functions. More rigorously: • “Every partial function which is effectively calculable is partial recursive” • We may need to restate the thesis for proving, as we proceed…

4. Introduction to computability - History • Hilbert’s 10th problem - Solving any Diophantine equation in rational integers in finite number of steps. • Church (1936) identified the commonly used term “effectively calculable” as a recursive function (algorithm). With this formalization one can prove that no algorithmic solutions whatsoever exists for some particular problem. • The problem was resolved by Matiyasevich (1970) and found to be unsolvable.

5. Models of computation • Turings model (1936)- symbols and strings • Deterministic behavior – determined by the symbol seen and the “state of mind” • Finitely many internal states • A finite symbol space • Finite observability – bound on some number (finite) of atomic operations • Linear external memory – a tape • Kolmogorov model – labeled graphs • Gandy model – discussed previously. Based on hereditarily finite sets

6. Formalization – Sketch of postulates • Postulate I : An algorithm determines a sequence of “computational” states for each valid input. • Postulate II: The states of a computational sequence are structures. And everything is invariant under isomorphism. • Postulate III: The transitions from state to state in computational sequences are governable by some fixed, finite description. • Postulate IV: Only undeniably computable operations are available in initial states. • We will show that Church’s Thesis provably follows from these four postulates. In the next slides we will formulate these postulates more rigorously

7. Samples of Postulate II • By virtue of the generality of structures, every other model of computation extant in the literature is a special case of the postulate: • Traditional arithmetic operates over natural numbers. These include also complex functions like primality tests. • Common Lisp’s arithmetic operates over the infinite sets of rational numbers. • RAM memory – memory cells are arbitrary integers and memory content is a dynamic function with an infinite address domain. • The states of pushdown automaton include a stack of symbols and simple stack operations.

8. Sequentiality: Computation • Computation may be formalized as a deterministic transition system, comprising a: • Set of states - • A subset - – which are initial • Transition function - • Terminal states – • Remark: In the original definition of ASMs, the transition function is always total; intuitively terminal states are their own next state. Since we are interested in the output of algorithms, we distinguish between a terminal state and a non-terminating state that may be its own next state.

9. Sequentiality: Postulate • Postulate I (Sequential time) : An algorithm is a state-transition system. Its transitions are partial functions. • Continuous (analogue) processes, transfinite computation sequences (involving limits), nondeterministic transitions and nonprocedural input-output is therefore excluded from consideration. • Classical algorithms of the type Church was considering, never leave room for choices. Even though segments of evaluation of recursive functions could , in principle proceed in non-deterministic fashion or in parallel, a particular order of computation was always fixed in advance. • Remark: Though Turing’s (human) computers operate deterministically when computing functions, he did envision choice-machines, which wait for an “arbitrary choice . . . by an external operator” before continuing (like in an exploration of proofs).

10. Abstractness • States will be first-order structures • States (structures), whose vocabulary does not include relation symbols are called algebras. • State-transition systems with algebraic states are called abstract transition systems (ATSs). • The modifier “first-order” isn’t accurate: should an algorithm make use of sets and/or higher-order functions, then sets and functions should be incorporated in the domain (base set, universe). • Classes of states and initial states are closed under isomorphism, and that transitions commute with isomorphisms, so that isomorphic states transition to isomorphic states. The isomorphism constraint is what makes states “abstract”.

11. Abstractness • All states of an algorithm share the same fixed vocabulary. Transitions do not change the underlying domain. • Usually, states of an ATS include some static functions that are present in initial states and are never changed by transitions. In particular, equality and the Boolean operations are always static. • Any other functions, however, are dynamic and may change from state to state. All the functions of a state are total. • The state also “holds” a value of each function in its vocabulary, applied to every possible combination of domain values. A specific location in a state is given by a function symbol and a tuple of elements of the domain of . Let be the interpretation of in . The value stored in is . For every t in the vocabulary assigns a value .

12. Abstractness: Postulate • Postulate II (Abstract state): States are structures, sharing the same fixed, finite vocabulary. States and initial states are closed under isomorphism. Transitions preserve the domain, and transitions and isomorphisms commute. • Commutation means that whenever there is a transitions and an isomorphism such that then there must also be a transition to the corresponding isomorphic image

13. Postulate:Boundedness • So far, nothing we have said guarantees that the behavior of a transition system is effective. For effectivity, it must be possible to express the rules for going from state to state in some finite fashion. • Postulate III (Bounded exploration): Transitions are determined by a fixed finite “glossary” of “critical” terms. That is, there exists some finite set of (variable-free) terms over the vocabulary of the states, such that states that agree on the values of these glossary terms, also agree on all next-step state changes. • Each critical term “points” to the location containing , where is the value of term in state . Thus, this postulate means that only a bounded number of location need to be explored for the algorithm to make a transition.

14. Boundedness: Definition and Example • Update – a triple, written as an “assignment” indicating that the value b is to be assigned to location changing the graph of function . • Let be set of updates that transpire in a transition out of . • Together with isomorphism preservation of transitions (Postulate II), the equality of the ∆’s implies that any updated value b in ∆(α) is the interpretation of one of the critical terms in the glossary. • Example: Instructions like is prohibited by the postulate.

15. Abstract state machines • An abstract state machine (ASM) is given by: • A set S of algebraic states, closed under isomorphism, sharing a vocabulary F. • A set I ⊆ S of initial states, closed under isomorphism. • A program P, consisting of finitely many commands, each taking the form of a guarded assignment if p then t := u, for terms t and u over F and conjunction p of equalities and disequalities between terms. • At each step of the computation, all assignments in P whose guards hold true are executed in parallel to give the next state. More precisely, given a state α ∈ S, program P defines the following set of updates:

16. Abstract state machines • A set of updates is inconsistent if it contains two updates, f(ā):=b and f(ā):=b’ , with b≠b’. If is empty or inconsistent then α is a terminal state. • Otherwise α has a next state α’ with the same vocabulary and domain as α, and with it’s valuations updated as following:

17. ASM Theorem • Theorem 3.4 (ASM Theorem): For every process satisfying the Sequential Postulates, there is an abstract state machine in the same vocabulary (and with the same sets of states and initial states) that emulates it. • Methods satisfying the Sequential Postulates include: • The classical algorithm for GCD – which Euclid applied to both rational and irrational values. • Method of Gaussian elimination, even when the field over which it’s applied is unspecified. • And exclude: • Underspecified methods: “Guess a solution to a system of linear…” • Non-algorithms: “Try all numbers to see whether or not there is a solution…” • Non-deterministic methods: “pivot on any non-zero element” • Randomized algorithms: “multiply by random matrix prior to…” • Probabilistic methods: Rabin algorithm for testing primality

18. Arithmetical effectivity: Introduction • We may suppose that the vocabulary of an ATS includes (nullary) symbols Out and In1,…,Inninput values. • There is exactly one initial state up to isomorphism, for each n-tuple of input values. • An ATS over domain D computes the following function: where I and O are the sets of initial and terminal states with domain D. • The input-output relation is a partial function over D, since is a partial function, as being undefined for terminal states. • Value ⊥ of Out will constitute failure (undefined)

19. Arithmetical state • Up to isomorphism an arithmetical state’s domain includes: • The natural numbers, two (distinct) Boolean truth values, True and False, and some other distinguished value ⊥ signifying “undefined”. • Operations - zero (0), successor (+1), addition (+), subtraction (-), multiplication (*), integer quotient (/), equality (=), inequality (<), as well as logical constants and standard operations for the Booleans. • May have also various symbols for dynamic function. • Those arithmetic functions are total – we let m-n=0 if m<n, n/0= ⊥and any other non-defined operation will result in “undefined”. • Dynamic operations act as “variables” in the programming sense: their values may be updated by the algorithm in the course of a computation. When all dynamic operations in a state, other than the inputs Ini , are completely undefined—that is, are assigned the value ⊥ for all arguments—we say that the state is blank. This will be the case initially

20. Arithmetical Machines • Postulate IV (Arithmetical State) : Initial states are arithmetical and blank. Up to isomorphism, all initial states share the same static operations, and there is exactly one initial state for any given input values. • Definition 4.3 (Arithmetical ASM): An arithmetical ASM is an ASM satisfying the Arithmetical State postulate. • Since transitions do not change the domain, vocabulary, or static operations, we get: • Proposition 4.4: All states of an arithmetical ASM are arithmetical • As a result we have the main characterization of this section: • Theorem 4.5: A numeric function is partial recursive if and only if it is computable by an arithmetical ASM.

21. Proof of Theorem 4.5 • Minsky counter machines are finite-state automaton with access to a number of unbounded registers or counters. These registers can be thought of as mono-symbolic stacks. Two operations are available on each register: • increment it • decrement it and check to see if it is zero, which causes an alternate state transition • Minsky machines with two or more registers have been shown to be in the same computational class as Turing machines • We will emulate a counter machine using an arithmetical ASM: • Initialization instructions: if p = ⊥ then p:=0 (initialize program counter p) if c = ⊥ then c:=0 (initialize non-input counter c) • Increment instuctions: if p = I then c:=c+1 (increment counter c) if p = I then p:=i+1 (move to next instruction)

22. Proof of Theorem 4.5 • Decrement instructions: if p = I then c:=c-1 (decrement counter c) if p = I then p:=i+1 (move to next instruction) • Branch instruction: if p = i ∧ c = 0 then p:=j (branch on zero) if p = i ∧ c ≠ 0 then p:=k (branch on non-zero) • On the other hand, it is also clear that any arithmetical ASM can be programmed in a standard programming language, by storing the current non-⊥ values of all dynamic functions (and possibly some ⊥ values, as well) and interpreting the ASM’s conditional updates step-by-step. Such programs, of course, can compute only partial recursive functions.

23. Church’s Thesis: more rigorous now • Corollary 4.6: Every numeric function computed by a state-transition system satisfying the Sequential Postulates, and provided initially with only basic arithmetic, is partial recursive. • Proof: By the ASM Theorem every such algorithm can be emulated by an ASM whose initial states are provided only with the basic arithmetic operations. By Theorem 4.5 (Arithmetical ASM Theorem) such an ASM computes a partial recursive function. • Definition 4.7 (Arithmetical Algorithm): A state-transition system satisfying the Sequential and Arithmetical Postulates is called an arithmetical algorithm. • As a conclusion we get Church’s Thesis for the “regular” domain described in the previous slides: • Theorem 4.8 (Church’s Thesis): Every numeric (partial) function computed by an arithmetical algorithm is (partial) recursive. • Proposition 4.9: Every partial recursive function can be computed by an arithmetical algorithm.

24. Recursive oracles • There is nothing special about the particular set of arithmetic operations allowed in arithmetical sets. As a matter of a fact we had seen counter machines, which's set contains only zero, successor, equality and a handful of dynamic nullary operations, serving as counters. • At the other extreme – effectiveness preserved no matter how many recursive functions are permitted at the arithmetical states. So we can extend the domain of our functions to the Boolean triple {True,False,⊥}. • We take any σ , an unary function, and apply it to n-tuples, so that will serve as a shorthand for . • Let and let σ be the following bijection from to : • We’ll say that a function f of arity n over is (partial) recursive if its numeric conjugate is (partial) recursive in the ordinary way

25. Recursive oracles • Corollary 4.10: Every partial function computed by a state-transition system, satisfying the Sequential Postulates, whose states are arithmetic and whose initial states only have recursive (possibly partially defined) operations, is partial recursive.

26. Relative effectivity • A (partial) function f is said to be (partial) recursive relative to a set of functions B if its values can be inferred by equational reasoning from a set of (true) equations involving B. • In other words, f can be obtained by composition, primitive recursion, and/or minimization from the oracles of B. We assume that B always includes zero, successor and equality. • The ordinary recursive functions are just those that are defined in this way from only zero, successor and equality.

27. Relative effectivity • Theorem 5.1: A numeric function is partial recursive relative to “oracular” functions B if and only if it is computable by an ASM operating over domain and initial functions B (containing at least zero, successor, and equality), but no other functions defined in its initial state. • Proof: • It is an ordinary programming exercise to show how to obtain as ASM for the composition of the functions computed by two ASMs or by primitive recursion, so by induction we get what we asked for. • On the other hand, one an interpreter for such ASMs, which can be programmed in any standard programming language, except for calls to the oracles. Such an interpreter can in turn be implemented in terms of the functions in B, using composition, primitive recursion, and minimization. • As a result we have: • Corollary 5.2 : The only numeric functions that are algorithmically computable by a process satisfying the Sequential Postulates are those that are partial recursive relative to the initial functions.

28. Arithmetized effectivity • We consider now algorithms that operate over larger domains than just natural numbers, domains that may include rationals, vectors, matrices, strings, lists, graphs, etc. • To work with such objects, an algorithm would be provided with operations like division of rationals, vector addition, matrix multiplication, string concatenation, list sorting, or graph complementation.

29. Arithmetizable states • We want to extend the object domain to elements besides numbers and truth values, so that its initial states would include operations over auxiliary domains and operations connecting those domains with the natural numbers, in addition to the arithmetic operations. • Let the enriched object domain of an algorithm be and let be an injection of that domain into the natural numbers that preserves . We will use as a restriction to the natural numbers in D. • Function f of arity n over D will be called ρ-recursive if there exists a recursive function over such that . • In other words, f is ρ-recursive if there is some recursive extension of the function over the image ρ(D) whose graph is

30. Postulate IV extension • Postulate IVb (Arithmetizability): Initial states are blank. Up to isomorphism, all initial states share the same domain and static operations, and there is exactly one initial state for any given numerical input values. There is an encoding ρ whose restriction to the natural numbers is recursive (in the ordinary sense), and via which all static operations of the initial states are recursive.

31. Arithmetized algorithms • We will say that an algorithm (and its set of static operations) operating over a domain D is arithmetizable if there is an encoding ρ of D such that the conditions of the Arithmetizability Postulate are fulfilled. • Definition 6.3 (Arithmetized algorithm): A state-transition system satisfying the Sequential and Arithmetizability Postulates is called an arithmetized algorithm. • That gives us the following variation of Church’s Thesis (Theorem 4.8) for enriched domains, which will be the central theorem of this paper: • Theorem 6.4: Every numeric (partial ) function computed by an arithmetized algorithm is (partial ) recursive. • In the course of proof we will need several (not so) easy lemmata.

32. Lemma 6.5 • Suppose by a computation of an ATS A, and let for some isomorphism π. Then one also has via A, where Furthermore, for all terms over the vocabulary of A. • Proof: By the nature of isomorphisms we get for all t. By Abstract State Postulate (II), the isomorphism π is preserved, from which follows whenever and . The result follows by induction.

33. Lemma 6.6 • Definition: Let D ⊆ D’ for domains D and D’ and suppose that algebras α and β have those domains, respectively, and share the same vocabulary. Then α called a subalgebraof β, denoted α ⊆ β, if the operations of β are closed on the subdomainD and every operation fαof α is the restriction to D of the corresponding operation fβ. This implies for all terms t. • Lemma 6.6: Suppose that an ASM M with states S has a transition for states α and α’ with domain D ⊆ D’. Suppose further that α ⊆ β, where Domβ = D’. Then an ASM M’ with exactly the same vocabulary and the same program as M, but with extended states (closed under isomorphisms), engenders the corresponding transition (for extended states β,β’), where α’ ⊆ β’. • Proof: Since α and β share the same vocabulary, the enlarging of the domain D doesn’t affect the element accessible by β, and they are still the ones accessible by α. Therefore, those extra domain elements have no influence on the transitions. Specifically, the update set Δ(α) for M is identical to Δ(β) for M’ whenever α’ ⊆ β’.

34. Lemma 6.7 • Definition: Let ρ: D→D’ be an injection from domain D to D’, and suppose that algebras α and β have those domains respectively, and share the same vocabulary. Then we’ll say that α is embeddedin β via ρ, written as αβ, if ρ’(α) ⊆ β, where ρ’ is a bijection obtained by restricting ρ to its image . This implies: for all terms t. For any collection S of the abstract states, let the corresponding collection S’ (for the embedding ρ), be • Lemma 6.7: Suppose that an ASM M, with states S has a computation for states α and α* with domain D. Suppose further that αβ via some injection ρ: D→D’. Then an ASM M’ with exactly the same vocabulary and program as M, but with states S’, engenders the corresponding computation (β,β*€S’), where α* β*. Furthermore, for all terms t over the vocabulary of M.

35. Proof of Lemma 6.7 and Lemma 6.8 • Proof of Lemma 6.7: By Lemma 6.5 also has a computation and by repeated application of Lemma 6.6, M’ has a computation with ρ’(α*) ⊆ β*, for any β such that ρ’(α) ⊆ β. In other words, α*, when β . Accordingly, we also have for all terms t. • Lemma 6.8: If g’: N→N is a partial recursive function and ρN: N→N is a recursive injection, then is also partial recursive. • Proof: Since the injection ρN is recursive, its inverse is partial recursive. Its composition with other partial recursive functions is partial recursive.

36. Proof of Theorem 6.4 • Suppose A is the arithmetized algorithm operating over the enriched domain D. is the postulated injective encoding. • By ASM Theorem there is ASM M that computes the same function as A. • We define an ASM M’ with the same vocabulary and program as M, but with states S’, and with initial states that interpret each static symbol f as f’. All states in M’ will have domain . • Static arithmetic operations of M are reinterpreted as their witnesses in M’, but Boolean operations and equality remains the same. This way M’ satisfy the requirements of Corollary 4.10 and must compute a (partial) recursive function. • Now we consider when α and α* is the initial and the terminal states. M’ has an initial state , such that α and for each Ini. By Lemma 6.7 there is a corresponding computation . • By the same lemma, where output of M and is the output of M’. • Now we let , where input of M and like before.

37. Proof of Theorem 6.4 • By convention and are the output values of M and M’. • It follows that for all n-tuples of x. • Now we recall that is postulated to be recursive and the partial function computed by A is numeric. Therefore, it follows from Lemma 6.8 that must be partial recursive, as claimed.

38. Conclusions and Significance • As of Theorem 6.4, it showed that no matter what additional data structures the algorithm has, it cannot compute any non-recursive function, since it can be performed over the natural numbers. • The sequential ASM Postulate and the principles provided in the paper act as a framework, from which Church’s Thesis can be simply implied. • Unlike all previous formalizations of effectiveness, the postulates proposed in the paper apply to transition systems with arbitrary structures as states.

39. Thank you for listening (most of the time)