Namely, I don't know how to enforce that some row (first column) in the tiling table does indeed contain the final configuration of the encoded TM. Without this constraint I can't conclude that a successful tiling implies that the string is accepted by the TM.

I am wondering if you could give me a small hint on how to go about thinking this.

I am trying to have the first tile f(1,1) = t1 somehow encode this for me, but have not able to do it yet.

I also tried to add row number information to each tile, but this blows up the number of times exponentially and my reduction is no longer in logspace. So this approach is clearly not right.

I suggest that you modify N to N' so that its computation on input w can fill up the r × r space iff w is in L(n) = L(N'). A hint is that N' can count up to n^k and it can see whether or not it is in an accept state.

Now ϕ is supposed to mean "α is satisfiable". To say that, you'd want ϕ to be talking about a universe with at least two elements -- for the boolean values 0 and 1. I suggest that you write your formula ϕ ≡ (there is only one element in the unverse) or (there are at least two elements in the universe and α is satisfiable). Finally, once you have ϕ, you want to show that if α is satisfiable, then ϕ has a short first-order proof. So assume that you have a satisfying assignment for α and see how you would turn that into a proof for ϕ. Feel free to use meta theorems as you are describing the construction of the proof. Finally, how much longer would the first-order proof have to be if you weren't allowed to use meta theorems. (This involves going back to the proof of the validity of the metatheorems -- almost all by induction on the length of a given proof, and seeing that the first-order proofs that we constructed are not much longer.)

log(CFL) = { A | for some CFL, S, A ≤ S}

This is the set of problems that are (logspace) reducible to some CFL. Since CFL is not closed under basic operations such as intersection, log(CFL) is a more robust class than CFL. log(CFL) is closed under reductions of course. Much less obviously, it is also closed under intersection and complementation, and has several elegant characterizations that I'll try to get to later when discussing parallel complexity classes.

Since log(n^k log n) = O(log n), the arity issues do not cause serious problems.

Thus FO-Unsat is r.e. complete. Thus it's complement, FO-Sat, is co-r.e. complete.

n ∈ L(M_i)      ⇔      ⊢ NT → ϕ_i(n)

Thus checking if a Turing machine accepts an input is the same thing as checking if a corresponding first-order formula is valid. That is one way of seeing that proving first-order theorems and doing computation is closely tied.

Concerning expressing properties in logic, we will see more later concerning descriptive complexity -- the close relationship between the computational complexity of a problem and the richness of a logical language needed to express the problem.

+ By first showing some lemma is FO - provable and then using that lemma in our proof ?

+ By assuming that some basic things like: if a is true, b is true -- then a ∧ b is true, without explicitly writing the AX0 axiom each time for this. ?

www.cs.umass.edu/ immerman/cs601/naturalDeductionRules.pdf

For structure S of universe, U = |S|, any subset of U corresponds to a unary relation on S, thus if U is finite with n elements, there are 2^n possible unary relations on U, and if U is infinite then there are uncountably many such relations.

∀ x ( ∀ y( Q(y,x) ) ∨ ∃ z( P(x,z) ) ),

I want to move all the quantifiers to the left so that I can get the formula in the form required for arithmetic hierarchy.

If x is not in free(α), then

Qx(α op β)      is equivalent to     α op Qx(β),

where Q ∈ {∀,∃}; op ∈ {∨, ∧}.

i. To prove S is not co-RE -- we just need to show that S is RE-Complete. Right ?

ii. To show S is recursive -- we should show S is RE, in co-RE _and_ give a function F that will decide (and halt) S.

iii. To show S is neither RE nor co-RE -- we need to show that S is RE complete _and_ co-Re complete. Right ?

ii: To show that S is recursive it would be most natural to give an algorithm that always halts and decides S. It does suffice to show that S is r.e. and co-r.e., but that is rarely a natural thing to do.

iii: Not quite: from my comment in (i), it does suffice to show that S is r.e hard and co.-r.e. hard.

on input x:
z = M_n(n)
if (z=1) return(a) else return(b)

In this case,

if M_n(n) = ↗ then M_f(n)(x) = ↗
else if M_n(n) = 1 then M_f(n)(x) = a
else M_f(n)(x) = b

M_n is Turing Machine number n, i.e., the Turing Machine whose program is encoded as n.

M_n(·) is the partial, recursive function computed by M_n .

M_n(x) is the output of M_n when it is started with input x.

M_n(N) = {M_n(x) | x in N} is the range of M_n(·)

In slide 6 -- is it also okay if we write:
for(i = 0 to infinite) { if ( M_r(i) == x ) return 1}

On Slide 7: Must a TM explicitly erase its input -- can't it just disregard its input ?. I.e just do whatever it wants without erasing its input ?

In Slide 6, your program is not correct because if M_r(0) does not halt then we will never look at M_r(1), etc., so you must dovetail, i.e. run M_r on each of its inputs for longer and longer waiting to see if any of them eventually output x.

On Slide 7, the reason I say "erase input and write n" is that I am describing a TM that first simulates M_n(n). Of course you could program this one of many ways, but this feels to me like the simplest because here I am explicitly running M_n, just modified so that where M_n would halt it instead goes on to the next stage: "if (M_n's answer is 1) then return(17) else loop".

The main point in all of these constructions is that we are given a string encoding some combination of inputs and Turing machine programs, and we do a simple modification of these inputs and programs to get an appropriate input for the problem we are reducing to. Thanks for your questions, I hope this helps.

It says that M_n(n) = 1 iff M_f(n)(0) = 17. What confuses me is the restriction that 0 must be the input. In M_f(n) you erase the input, so it has no effect on the proof. Wouldn't this imply that the above statement is true for all inputs and not just when its 0?

The reason that I only mention the condition M_f(n)(0) = 17 is that this is exactly the defining condition for f(n) to be a member of A_0,17.

I mean consider a function f defined on all natural numbers. A function is just a mapping that satisfies some constraints. Some of these mappings obey some property (like x -> x**2) or something but not all mappings need to be obey any computable property.

So my question is whether all total functions are computable, or is that not necessarily true. ?

See bloop1.rb and bloop2.rb

No, there is no explicit branching construct. This at first seems like a very limited language.

Now we can formally define an encoding as a total recursive function f: N → {0,1}^* that admits a universal TM, U_f, with the property that for all i and w,

M_i(w) = U_f(f(i),w), i.e., f(i) is an encoding of M_i that U_f understands.

According to the definition given in the book,

K(x) = min {|Mj| : Mj(epsilon) = x}

But the statement below that states:

K(x) is the length of the smallest "program" in our encoding that outputs the string x.

They dont talk about the input given to Mj in the statement. I was wondering whether is it necessary that only those TMs which produce x on input "epsilon" should be considered for calculating K(x).

1. if S is the range of a non-decreasing total recursive function, f, then S is recursive. Here you should assume that you have the Turing machine that computes f, and show how to design a TM that computes χ_S: S's characteristic function.

2. if S is non-empty and recursive, then S is the range of a total recursive function. Here you assume that S is non-empty and you have a TM that computes χ_S, and you want to produce f which enumerates S in non-decreasing order. It might be easier if you separately consider the cases where S is finite and where S is infinite.

This question may be challenging if you have not seen this kind of argument before. You might want to take a look in advance at the slides for Lecture 7 which contains some arguments of this kind.

(2). In the definition of an encoding, the universal TM U_f seems to have two input, f(i) and w, but our definition of TM always has one input, right? If U_f has only one input, then we must be doing some implicit transformation from f(i) and w into a new string. What will the definition look like, if we make this transformation explicit?

(1). The definitions: just program, or program and data pair are equivalent, but it is not obvious that they are. The idea is that there is really no way to look at a program and say definitively what is the program part and what is the data part.

(2). Our definition is that a TM is given one string as its input. Except in Kolmogorov complexity where we are counting number of bits, we could encode a pair of inputs in any simple way, e.g., having an input alphabet with symbols 0,1,# where # is a separator; or as we usually do in 601, interpreting an input string w as the pair P(x,y) and separating it that way. However, in Kolmogorov complexity we encode everything in binary so the above two definitions are both unacceptably wasteful.

To do part (a) of this problem, you need to create an encoding that is optimal up to an additive constant with respect to the data. It can be suboptimal with respect to program size.

This question turned out to be more subtle than I had intended, so I am changing part (a) of question 1 to be "extra credit".

ans = 0
ans = s(ans)

Thank you for pointing this out.

Are the two equivalent or should we follow one definition over the other ?.

I guess I am asking if say -- we are not able to cover the pumping lemma by Friday, will we still be supposed to do questions on the pumping lemma in HW1 ?

PS: Is there a mailing list for the course -- cs601@cs.umass.edu or something similar ?

There is no course mailing list, but I will post useful questions and answers on http://www.cs.umass.edu/~immerman/cs601/qa.html