Construct Turing machines that compute the following number...

Construct Turing machines that compute the following number theoretic functions and relations. Do not use macros in the design of these machines. a) $f(n)=2 n+3$ b) half $(n)=\lfloor n / 2\rfloor$ where $\lfloor x\rfloor$ is the greatest integer less than or equal to $x$ c) $f\left(n_1, n_2, n_3\right)=n_1+n_2+n_3$ d) $\operatorname{even}(n)= \begin{cases}1 & \text { if } n \text { is even } \\ 0 & \text { otherwise }\end{cases}$ e) $e q(n, m)= \begin{cases}1 & \text { if } n=m \\ 0 & \text { fthwise }\end{cases}$ f) $\operatorname{lt}(n, m)=\{1$ if 1 otherwise f) $l t(n, m)= \begin{cases}1 & \text { if } n<m \\ 0 & \text { otherwise }\end{cases}$ g) $n-m=\left\{\begin{array}{l}n-m \text { if } n \geq m \\ 0\end{array}\right.$

Construct Turing machines that compute the following number theoretic functions and relations. Do not use macros in the design of these machines.
a) $f(n)=2 n+3$
b) half $(n)=\lfloor n / 2\rfloor$ where $\lfloor x\rfloor$ is the greatest integer less than or equal to $x$
c) $f\left(n_1, n_2, n_3\right)=n_1+n_2+n_3$
d) $\operatorname{even}(n)= \begin{cases}1 & \text { if } n \text { is even } \\ 0 & \text { otherwise }\end{cases}$
e) $e q(n, m)= \begin{cases}1 & \text { if } n=m \\ 0 & \text { fthwise }\end{cases}$
f) $\operatorname{lt}(n, m)=\{1$ if 1 otherwise
f) $l t(n, m)= \begin{cases}1 & \text { if } n<m \\ 0 & \text { otherwise }\end{cases}$
g) $n-m=\left\{\begin{array}{l}n-m \text { if } n \geq m \\ 0\end{array}\right.$

Key Concepts

Designing Without Macros

Designing Turing machines without the use of macros means that every operational detail must be explicitly implemented within the state transitions of the machine. This requires a meticulous breakdown of complex operations into more primitive actions, highlighting the fundamental, step-by-step nature of computation.

Arithmetic Operations in Turing Machines

Implementing arithmetic operations on a Turing machine involves designing state transitions that mimic the step-by-step process of computing functions such as doubling, halving, addition, subtraction, and more. These constructions illustrate how complex mathematical operations can be broken down into basic, reversible mechanical steps.

Constructing Decision Procedures

Decision procedures on Turing machines are algorithms designed to determine whether certain conditions hold true (such as checking if a number is even, or if two numbers are equal). These procedures typically produce a binary output reflecting the truth value of the condition, mapping to decision problems in computability.

Computable Functions

Computable functions are those for which an algorithm exists that can produce the function’s output for any given valid input within a finite number of steps. The construction of Turing machines to compute functions, including arithmetic and decision functions from number theory, is a core area of study in computability theory.

Turing Machines

A Turing machine is a formal model of computation that manipulates symbols on an infinite tape according to a set of predefined rules or transitions. It is used to rigorously define what it means for a function to be computable, serving as a foundational concept in theoretical computer science.

Representation of Numbers

In many Turing machine designs, numbers are encoded in a simple format, such as unary representation, where the number n is represented by a string of n identical symbols. This method simplifies the process of defining and executing arithmetic operations on the Turing machine's tape.

Transcript

00:01 We're asked to construct a touring machine that computes the function f of n equals n minus 3, if n is greater than or equal of 3, and is a non -negative integer, and f of n is equal to 0, if n is equal to 1, 2, or 0.

00:31 So this covers all non -negative integers.

00:36 So to do this, we'll use unary notation.

00:39 So essentially what we're seeing we want to do is we have an input string, which is, well, in the case of n greater than or equal to three, we're going to have n plus one ones, where n is greater than equal to three, and the output should be n minus three plus one, which is equal to n minus two ones.

01:15 Again, n is greater than equal to 3, so it follows that we'll have at least 1 -1, so this does make sense in unary notation.

01:25 Otherwise, if the input is going to be 1, 2, or 3 -1, the output should be 1 -1, which symbolizes that f -n is going to be 0.

02:01 So, if n is greater than equal to 3, we want our machine to erase 3 -3.

02:07 Of the ones so that we end up with n minus two ones in the end.

02:39 And the case that we have fewer than four ones, we really want to erase all the ones except for one.

02:53 So suppose the n is greater than or equal to three.

03:00 Well, starting out in state s zero, we're going to recognize a one.

03:07 And then we're going to want to shift into state s one, change the one to a blank and move right.

03:23 If we've erased one of the ones, we want to erase two more ones.

03:28 So in state s1, we encounter a 1.

03:31 We'll want to shift into state s2, change the one to a blank, and move right.

03:36 And finally, when we're in state s2, if we encounter a 1, we'll want to shift into the final state s3, change the one to a blank and move right.

03:49 And then we will obtain a string with three less ones than we started with.

04:05 Now, while s3 is a final state, we want to also account for the possibilities that n is less than three...

Please give Ace some feedback