where is it used?

Author: lmoss

booksource/_build/.doctrees/environment.pickle

@@ -1,9 +1,11 @@
 # Invitation to Computability 
 
+Lawrence S. Moss
+
 This is a textbook on the basics of computability theory, originating in classes given by the author 
 at Indiana University for quite a few years.  My students are mainly graduate students in either mathematics or computer science, always with a few undergraduates and a few grad students from philosophy and other disciplines.
 
-In some ways, the content of the book is standard, and in some ways it is not. It treats the basic topics of the subject: the concept of computability, primitive recursion, mu-recursion, universal functions, the Recursion Theorem, and undecidability in computability theory, mathematics, and logic.  Of course we are living decades past the original proofs of these results, and so the presentation here will differ.  This book will try to make pointers to many of the developments in computability theory and computer science that have come from the classical material.  
+In some ways, the content of the book is standard, and in some ways it is not. It introduces the basic topics of the subject: the concept of computability, primitive recursion, mu-recursion, universal functions, the Recursion Theorem, relative computability, the arithmetic hierarchy, and undecidability in computability theory, mathematics, and logic.  Of course we are living decades past the original results on these topics, and so the presentation here will differ.  This book will try to make pointers to many of the developments in computability theory and computer science that have come from the classical material.  
 
 ## Why a Jupyter book?
 
@@ -13,42 +15,42 @@ book about computation theory should use up-to-date computational tools. This bo
 packages, Jupyter notebooks and everything needed to work with them, $\LaTeX$, github, and more.  In the 
 course of working on the book I became interested in using all of these computational artifacts, mainly as a 
 way of seeing what would work in a textbook, and what would not. Since working in this medium is new to me 
-(and pretty much everyone), I became as interested in those aspects of the project as in the content. Here are some of artifacts found here but not in a traditional book on computability theory: a executable Python code, especially in the beginning chapters; a variety of pictures and charts; the ability to hide technical passages and to otherwise structure a text; and clickable references to discussions, papers,
+(and pretty much everyone), I became as interested in those aspects of the project as in the content. Here are some of artifacts found here but not in a traditional book on computability theory: a executable Python code, especially in several chapters near the beginning; a variety of pictures and charts; the ability to hide technical passages and to otherwise structure a text; and clickable references to discussions, papers,
 [and even poems](http://www.lel.ed.ac.uk/~gpullum/loopsnoop.html), both inside and outside of the book  itself. In time I will consider adding animations to illustrate some of the dynamism that I sense with computably enumerable sets which is arrested in any print presentation.  I also would like to incorporate tools for readers to annotate and discuss matters, enabling a community of  readers.  In short, I am aiming for something which is both a short textbook and an intellectual version of a coffee-table book.
 
 # Intended audience
 
 This book is aimed at anyone who frequently encounters the very basic parts of computability theory and has the needed mathematical background to read it.  That background is a working familiarity with mathematical notation and discourse.   One should know how to read mathematics.  This would be the wrong place to learn basic abstract mathematics; the pace and level would be too much.   But if you can read mathematics, that is enough: nothing else is really assumed.  There are places where it would be good to have seen some induction on the natural numbers and even some basic topics in areas like logic, set theory, and computer programming.  But one could do without the background, I think.  And I hope to have provided enough background on those topics to make what is here accessible.
 
-Some of the people who will benefit from the book: those in the broad area of interdisciplinary logic but who are not specialists in computability theory per se; computer scientists in areas like programming languages and theory of computation; philosophers interested in areas like the philosophy of logic or philosophy of mathematics.  For others, such as those pursuing any area of mathematics, the subject will probably be an "extra".  But "extras" are important, too.  I really have in mind a broad audience of people who might find the topics here intersting.
+Some of the people who will benefit from the book: those in the broad area of interdisciplinary logic but who are not specialists in computability theory per se; computer scientists in areas like programming languages and theory of computation; philosophers interested in areas like the philosophy of logic or philosophy of mathematics.  For others, such as those pursuing any area of mathematics, especially areas that might be far from computability theory, the subject will probably be an "extra".  But "extras" are important, too.  Summing up: I have in mind a broad audience of people who might find the topics of the book intersting.
 
 (content:DistinctiveFeatures)=
 # Distinctive features
 
-The are three distinctive features of the book.   Theree of the first four chapters are mainly an online resource.  For this part of the book, this more important than the printed book.    Most of the chapters in that part of the book are Jupyter notebooks. Rather than simply read, these chapters are intended to be *run* and *programmed*. One way to use them is to save them and then run them locally.  Alternatively, one could open them on a hosting service like CoCalc, Binder, or Google Colab.  The Jupyter book format is not so important for the material that comes after the first sections, and for those a traditional print book is going to be available.
+The are three distinctive features of this book.   Three of the first four chapters are mainly an online resource.  For them, this more important than the printed book.    Most of the chapters in that part of the book are Jupyter notebooks. Rather than simply read, these chapters are intended to be *run* and *programmed*. One way to use them is to save them and then run them locally.  Alternatively, one could open them on a hosting service like CoCalc, Binder, or Google Colab.  The Jupyter book format is not so important for the material that comes after the first sections, and for those a traditional print book is going to be available.
 
 
 ## Text register machines
 
 Compared to the many other books on the subject, the treatment here is in some ways more concrete and in some ways more abstract and sophisticated.  How can this be?  It is more concrete in the beginning than other books, and more abstract later on.  It is more concrete in that it comes with a dedicated computer implementation and because it goes into full details on coding.  But later it is more abstract because it discusses matters like recursion on induction on a fairly abstract level and because it also discusses corecursion alongside recursion.
 
-The concrete part in the beginning develops a model of computation which is a variant of a register machine called a *text register machine*.  The "text" in "text register machine" is the feature (orignal here) that the programming language of the machine is the same as the language of programs.  This language the set of words on the two letter alphabet ```{1,#}```.  So the language is called ```1#```. This text comes with two interpreters for ```1#```, so the programs can be run.  The programs themselves are unreadable; that is, they are not intended to be human readable but rather to be used in this presentation of computabililty (and nowhere else).  The book comes with tool support to help people to write long programs in ```1#```; for example, one can turn a flowchart into a  ```1#``` program.  Another tool turns a decription of a primitive recursive function into ```1#``` code.   Those tools are in Python, and while one need not read the programs to use them, a class for computer science students could indeed do so.  Using ```1#``` and the accompanying tools, the main first theorems of computability theory are presented constructively in full detail, with no coding and no hand-waving.    One can write explicit universal programs, $s^m_n$ programs, self-writing programs, the T-predicate, and similar artifacts that essentially *are* the main first results in computability theory.   One can prove Kleene's Second Recursion Theorem in full detail, too.
+The concrete part in the beginning develops a model of computation which is a variant of a register machine called a *text register machine*.  The "text" in "text register machine" is the feature that the programming language of the machine is the same as the language of programs.  This language the set of words on the two letter alphabet ```{1,#}```.  So the language is called ```1#```. This text comes with two interpreters for ```1#```, so the programs can be run.  The programs themselves are unreadable; that is, they are not intended to be human readable but rather to be used in this presentation of computabililty (and nowhere else).  The book comes with tool support to help people to write long programs in ```1#```; for example, one can turn a flowchart into a  ```1#``` program.  Another tool turns a decription of a primitive recursive function into ```1#``` code.   Those tools are in Python, and while one need not read the programs to use them, a class for computer science students could indeed do so.  Using ```1#``` and the accompanying tools, the main first theorems of computability theory are presented constructively in full detail, with no coding and no hand-waving.    One can write explicit universal programs, $s^m_n$ programs, self-writing programs, the T-predicate, and similar artifacts that essentially *are* the main first results in computability theory.   One can prove Kleene's Second Recursion Theorem in full detail, too.
 
 
-The use of ```1#``` is why the treatment here is much more explicit than usual.   The way the book works is that those main first results are presented in full detail, and then after doing so it becomes more "hand wavy".  Probably every book on the topic is going becomes "hand wavy" at some point.  But this one does so much later, due to our use of ```1#``` and the extra tools.
+The use of ```1#``` is why the treatment here is much more explicit than usual.   The way the book works is that those main first results are presented in full detail, and then after doing so it becomes more "hand wavy".  Probably every book on the topic becomes "hand wavy" at some point.  But this one does fairly late, due to our use of ```1#``` and the extra tools.
 
 ## Unsolvable problems
 
-The book also presents quite a bit on undecidability matters and the main negative results of 20th century mathematical logic such as Church's Theorem that satisfiability in first-order logic is undecidable.   In this, we use other interesting undecidability results such as tiling and also matrix mortality.  Our treatment is fuller than any source we know of on these topics.  The reason that we can provide a full treatment is that we build on work done with ```1#``` earlier.  For example, the work done in writing the universal program gets called back when we prove the undecidability of tiling, and the undecidability of tiling leads to a fairly easy proof of Church's Theorem.   
+The book also presents quite a bit on undecidability matters and the main negative results of 20th century mathematical logic such as the Church-Turing Theorem (satisfiability in first-order logic is undecidable).   In this, we use other interesting undecidability results such as tiling and also matrix mortality.  Our treatment is fuller than any source we know of on these topics.  The reason that we can provide a full treatment is that we build on work done with ```1#``` earlier.  For example, the work done in writing the universal program gets called back when we prove the undecidability of tiling, and the undecidability of tiling leads to a fairly easy proof of Church's Theorem.   
 
 
-## Recursion principles and the categorical treament of recursion
+## Recursion principles and the categorical treatment of recursion
 
 Another way to make the point about the book being both more concrete and also more sophisticated: the text goes into details about coding in a fair amount of detail -- much more so than usual, since we can illustrate much of the coding work using actual programs.  But at the same time it discusses the overall issues of coding in an abstract way, using ideas originating in abstract data types.
 
 We include pointers to, and digressions on, topics such as recursion principles in very general settings, combinatory logic, and term rewriting.  For example, we discuss recursion on well-founded well-ordered sets.  This all comes in the second part of the book.   That part demands more mathematical maturity than the concrete work.  But the book is also designed so that the first part provides some help to students at beginning levels.
 
-The final distinctive feature of the book is a "gentle introduction" to areas of theoretical computer science related to *algebra* and *coalgebra*.   The goal here is to understand Lawvere's point that ordinary recursion on the natural numbers is equivalent to the initiality of the the natural numbers in a certain category.  Doing this leads to a deeper understanding of the relation of recursion and induction.  So all of this is presented from scratch.  The payoff comes when we "turn the arrows around" to see corecursion and bisimulation, matching recursion and induction.  These are not traditional topics for an introductory course on this subject, but I no reason why they would not be.   And for my intended audicence, they make more sense than the traditional topics which I have chosen to omit, such as oracle computation, c.e. sets and priority arguments, and complexity theory.  These all are the main focus topics of other textbooks and do not fit with what I am trying to do here.
+The final distinctive feature of the book is a "gentle introduction" to areas of theoretical computer science related to *algebra* and *coalgebra*.   The goal here is to understand the point that ordinary recursion on the natural numbers is equivalent to the initiality of the natural numbers in a certain category.  Doing this leads to a deeper understanding of the relation of recursion and induction.  So all of this is presented from scratch.  The payoff comes when we "turn the arrows around" to see corecursion and bisimulation, matching recursion and induction.  These are not traditional topics for an introductory course on this subject, but I no reason why they would not be.   And for my intended audience, they make more sense than the traditional topics which I have chosen to omit, such as oracle computation, c.e. sets and priority arguments, and complexity theory.  These all are the main focus topics of other textbooks and do not fit with what I am trying to do here.
 
 # Using it in a classroom or for self-study
 

booksource/_build/.doctrees/index.doctree

@@ -26,28 +26,10 @@
         "id": "kagQ3xd6nzIL"
       },
       "source": [
-        "\n",
-        "At this point we know what programs of   ```1#``` are and how they work.\n",
+        "At this point [we know what programs of   ```1#``` are and how they work](content:whatArePrograms).\n",
         "We are interested not just in the programs themselves\n",
         "but in *what* they compute.  \n",
         "\n",
-        "We call the set ```{1,#}```  our  *alphabet*, and we use the letter $A$  for it.\n",
-        "\n",
-        "\n",
-        "We know that it is odd to call such a small set an \"alphabet\",\n",
-        "even more so when that set doesn't have any letters in it!\n",
-        "But this usage is standard, and so we'll adopt it.\n",
-        "When used in situations like ours, the word \"alphabet\"\n",
-        "just means a set that you use to build words from.  \n",
-        "\n",
-        "But if ```{1,#}``` is our alphabet, what in\n",
-        "the world are our words?!\n",
-        "\n",
-        "Answer:\n",
-        "A *word* is just a sequence of  symbols from our alphabet.\n",
-        "\n",
-        " Examples of words include \n",
-        "```11#11####``` and also the empty word $\\varepsilon$.\n",
         "\n",
         " \n",
         "Let us be clear about the difference between\n",
@@ -57,15 +39,6 @@
         "in programs.  \n",
         " \n",
         "\n",
-        " \n",
-        "A *program* of ```1#``` is just a sequence of\n",
-        "instructions, \n",
-        "run together to make a big word.\n",
-        "An instruction counts as a program, \n",
-        "but programs of length $\\geq 2$ are not instructions.\n",
-        "\n",
-        "\n",
-        "\n",
         "```{prf:definition}\n",
         ":label: phi-notation\n",
         "Every word $p$ gives us a function\n",
@@ -149,7 +122,7 @@
         "id": "ZhaXDhZfFra5"
       },
       "source": [
-        "# Partial functions\n",
+        "## Partial functions\n",
         "\n",
         "Suppose we run a program $p$ with an input word $x$ in R1 and all other registers empty.  This run might, or might not, halt.  The first example of this is when $p$ is a loop $\\one\\hash^3\\one\\hash^4$.  For this program $p$, $\\phifn_p(x)$ is *undefined* for all $x$.\n",
         " \n",
@@ -247,7 +220,7 @@
         "id": "PQzllCr-Fu2y"
       },
       "source": [
-        "# Functions of two or more arguments\n",
+        "## Functions of two or more arguments\n",
         "\n",
         "A program $p$ of ```1#``` can also be used as a function of zero or more arguments.  Here is the relevant definition.\n",
         "\n",
@@ -388,7 +361,7 @@
         "id": "WOy1_0mpgsJ9"
       },
       "source": [
-        "# Functions of zero inputs\n",
+        "## Functions of zero inputs\n",
         "\n",
         "We started by associating to each program $p$ a function $\\phifn_p$ of one argument, and then for each $n \\geq 2$ we associated  a function $\\phifn_p^n$ of $n$ arguments.  This general definition works in case $n = 0$ also. "
       ]
@@ -611,8 +584,7 @@
         "\n",
         "For example, ```1###``` and ```1###1###``` are not equal, but they are strongly equivalent (and thus equivalent as one-place functions).\n",
         "\n",
-        "For an example of programs $p$ and $q$ which are equivalent as one-place functions but not strongly equivalent, let $p$ be ```1#```, and let $q$ be ```clear_2 + 1#```.\n",
-        "Running $q$ when R1 and R2 both have ```1``` results in a halting computation where R1 has ```11``` and R2 is empty.  But running $p$ this way preserves R2.\n",
+        "For an example of programs $p$ and $q$ which are equivalent as one-place functions but not strongly equivalent, let $p$ be ```1#```, and let $q$ be ```clear_2 + 1#```.  Running $q$ when R1 and R2 both have ```1``` results in a halting computation where R1 has ```11``` and R2 is empty.  But running $p$ this way preserves R2.\n",
         "\n"
       ]
     }