SLOa - First Homework

Roth, Michael
[email protected]

March 15, 2023

1 Design a Turing Machine, which implements a reversion of the input

To satisfy this problem, we will define a Turing Machine with two tapes, where the first tape stores the input string
and the final output.

First, the Machine writes the symbol from the first tape to the second tape, then shifts both tapes to the right.
This step is repeated until the Machine reaches the first empty symbol. At this point, both tapes contain the same
string.

When the first empty symbol is reached, we rewrite the empty symbol to # and shift the first tape right.

Lastly, the machine writes the symbol from the second tape to the first tape, then shifts the first tape right and
the second tape left. This step is repeated until the second tape reaches an empty symbol at the start of the tape.
Then, the machine halts.

Estimating space complexity is trivial, as the machine will take the input, double its length and add one additional
symbol. Additionally, it will need the amount of extra space on the second tape equal to the length of the input string.
Therefore, its space complexity is 3n + 1.

2 Design a RAM program, which for the input I = (min, max, n) computes
the number k such that min ≤ (k ∗ n) ≤ max. Let us assume, that all
the input numbers are greater than zero. After the HALT instruction,
the register r0 will contain the number k or -1 if such k does not exist.

RAM program calculating the k from the above problem will use these steps:

1. load the number n into r1 ,

3. load the number n from r1 into accumulator and check, if equation min ≤ r0 ≤ max holds. If it holds, load the
current r2 into the accumulator and halt. If r0 < min, continue to the next step, and if r0 > max, load -1 to r0
and halt.
4. increment the number in r2 by 1, add n from input to r1 and jump to step 3.

Note that in step 3, the order of evaluating the conditions matter.

1
 The uniform space complexity of such a program will be constant, as the program will always use 3 input numbers,
accumulator and two extra registers. Therefore, it’s uniform space complexity is
uni
SΠ (I) = 6

The uniform time complexity of this program is proportional to the ratio of the min input and n input:

tuni
Π (I) = ⌈min/n⌉ × 9 + 4

The increment loop (step 3) takes 9 instructions, loading the values to registers at the start and end oof the
program takes 2 instructions each for a total of 4 extra instructions.

3 Let L be a regular language. Estimate functions f (n) and g(n) such that
L ∈ DT IM E(f (n)) and L ∈ DSP ACE(g(n))

For any regular language L we can define a Turing machine, that simulates the function of a finite automaton. Such
a Turing machine would have the same states and transition function as the simulated finite automaton. With every
transition will such a TM shift right, it will never rewrite anything on the tape nor will it ever shift left. Therefore,
the space needed on the tape is directly proportional to the length of the input and the space complexity is therefore
linear.

Regarding the time complexity, for the reasons described above, the TM will always perform at most the number
of steps equal to the length of the input string, as it will never add nor rewrite any symbol on the tape, only shift
right as long as the input string belongs to the regular language L. Therefore, the time complexity is also linear.

f (n) = g(n) = n (1)

Powered by TCPDF (www.tcpdf.org)