Exactly the same instructions in exactly the same order with exactly the same before register values and exactly the same before data items and exactly the same operation with exactly the same results.
Yes, except for all of the storage instructions and locations in Run2, and all of the switching and swapping and whatnot in Run3.
Why are you arbitrarily labeling all this extra stuff as 'not part of the system' when it clearly is?
Lets use an easier to grasp example.
Suppose you write a program that instantiates a basic algorithm when it is run -- say, calculating the Fibonacci sequence. Pretty easy, right?
So for Run1 you start with 1, and 1, and then you add the previous two results together to get the next result.
For Run2 you do the same and, just like you said, you save the results of each step.
Now, in Run3, everything is kosher until the first context switch -- say it occurs after the value 5 is calculated. When the CPU returns to Run3, you load in the results from Run2 at the current point in the algorithm.
But now you have information that was calculated during Run2, not during Run3, being processed. And the same thing happens after the next context switch, and so on and so forth. Yes, you calculate 5
again, but it doesn't matter, because it has already been calculated and you are using the previous result.
So you are in effect doing nothing more than "re-running" Run2. Which is why I said it would be the
same consciousness! All of the calculations have already been made, all you are doing now is producing small snapshots of that original consciousness during the brief times when Run3 has CPU time.
And the proof that it is the original consciousness is trivial -- if anything
changes to desynchronize the state of Run3 from the saved state of Run2,
it will not be reflected in Run3 past the next context switch. Of course, the same thing can be said between Run1 and Run2 as well -- they are an identical consciousness because the information is identical.
But, if the input
had been different, at least Run2 would have caught it and the results would be different. Not so for Run3 vs. Run2.
By adding the extra instructions, you alter the algorithm, such that it is now making use of different type of data than it was before. Before, any changes in the inputs at any step of the run would alter the rest of the run. Now, you are locked into the conditions of Run2.
Think about it -- if you were to expand the entire sequence of Run3, at an arbitrary location in Run3, the vast majority of it would actually have occured during Run2. Only the portion since the last context switch can rightly be said to have occured during Run3.