HINTS FOR PROVING THEOREM A:

	VTIME(t) is contained in DSPACE(t^2)

I am assuming t(n)\ge log n, to simplify
the arguments slightly.   You can do the same. 

So let V be a VM that accepts in time t=t(n).
We want to construct a TM that accepts the same
language as L(V) in space t^2.

Let us make another simplifying assumption:
the function t(n) is space-constructible.  Hence
you can also assume the first thing your TM does
is to mark out t(n) tape cell.  Feel free to make
others if you like (but be explicit and indicate
roughly how to remove these assumptions).

Note that a VM can only access a finite number of
registers, say R_1, R_2, ... , R_k (for some constant k).
These include the shift registers and vector registers.

The first hint is this:  get a bound on the length
of the shift registers and on the length of the vector registers!
Show the following:
	In t steps, the shift register lengths is at most t.
	In t stpes, the vector register lengths is at most t.2^t < 4^t.

We can now do a naive simulation of the VM: just use one
tape to store the contents of each register R_i.  Unfortunately,
this requires space 4^t.

So you need the second hint: instead of explicitly storing the
contents of registers, we ONLY store the execution sequence of the
VM instructions.
Let us say tape 1 stores this sequence of instructions:

	1, 2, 3, 4, ?

The first four instructions are easy because there is no JUMP instructions
encountered.  But suppose the 4th instruction is "JUMP 2, 10".  This
means that the next instruction number is 10 if register R_2 is zero;
otherwise the next instruction number is 5.  

How can we decide this?  
This is the 3rd hint:
define a recursive function BIT(i,j,k) which returns the
j-th bit of the register R_i at time k.  Below we discuss how to
compute this function recursively.  But assuming this is available,
You can check if register R_2 is zero at the 4th step using
the following loop:

	IsZero <- TRUE;
	For j=1 to 4^t DO
		If BIT(2,j,4)=1 then
			IsZero <- FALSE; Break;
	Return(IsZero);

Let us suppose R_2 turns out to be zero.  Then your instruction sequence 
in tape 1 can now be extended:

	1,2,3,4,10,11,12,...

until you come to another JUMP instruction, and you do the loop again.
If you come to an instruction with no successor, you reject.
If you come to an ACCEPT instruction, you accept.


Let us discuss how to do BIT(i,j,k).

You can scan the instructions on tape 1, going backwards
in time, starting from time k.  Suppose time k_1 is the first
time that you find an instruction which modifies register i.
The instruction is one of the following:

	(1) ZERO i.	In this case, you can return 0 immediately.
	(2) AND i,m.	In this case you have to recursively compute

			BIT(i,j,k_1) AND BIT(m,j,k_1).

		(similarly for OR and NOT)

	(3) SHIFT i,m	This is somewhat involved, but conceptually it should
			not be hard.  I SUGGEST THAT YOU CAN DEFER THIS PART
			UNTIL THE LAST MOMENT.

		(similarly for SHIFTLEFT i, SHIFTRIGHT i).

One other possibility: if there is NO previous instruction which modifies
register i, then you should be able to determine the bit directly
(the registers are initially zero, except for the input register).

Now comes the analysis: how much space is needed by BIT(i,j,k)?
You can answer this question using answers to the following:
	(1) What is the depth of recursion?
	(2) How much space do you need to store the arguments (i,j,k) for
		each recursive call?


Hope this is helpful.  Feel free to come to see
me (by tomorrow, since I will not be around next week) 
if you still need help.

--Chee