On 7/4/24 10:51 AM, olcott wrote:
On 7/4/2024 9:25 AM, olcott wrote:
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
Python <python@invalid.org> writes:
Olcott (annotated):
If simulating halt decider H correctly simulates its input D until H >>>> correctly determines that its simulated D would never stop running >>>>
[comment: as D halts, the simulation is faulty, Pr. Sipser has been >>>> fooled by Olcott shell game confusion "pretending to simulate" and >>>> "correctly simulate"]
unless aborted then H can abort its simulation of D and correctly >>>> report that D specifies a non-halting sequence of configurations.
I don't think that is the shell game. PO really /has/ an H (it's
trivial to do for this one case) that correctly determines that P(P)
*would* never stop running *unless* aborted. He knows and accepts that >>> P(P) actually does stop. The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its input D
until H correctly determines that its simulated D would never
stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
It is the case that H must abort its simulation of P to prevent
its own non-termination. The directly executed P(P) benefits
from H already having aborted its simulation of P. P correctly
simulated H cannot reap this benefit proving that it is a different
sequence of configurations than the directly executed P(P).
(I've gone back to his previous names what P is Linz's H^.)
In other words: "if the simulation were right the answer would be
right".
I don't think that's the right paraphrase. He is saying if P were
different (built from a non-aborting H) H's answer would be the right
one.
But the simulation is not right. D actually halts.
But H determines (correctly) that D would not halt if it were not
halted. That much is a truism.
Thus H(D,D) must abort the simulation of its input to prevent
its own non-termination.
What's wrong is to pronounce that
answer as being correct for the D that does, in fact, stop.
*REPLACED PARAGRAPH*
The directly executed D(D) is executed in a different memory
process. D correctly simulated by H is simulated in its own
separate memory process. The executed D(D) only halts because
D correctly simulated by H was aborted.
A simpler example is show below so that one is not overwhelmed
with too much detail.
They are not the same instance of D.
void DDD()
{
HHH(DDD); // creates new process context
} // thus not the same DDD as the
// one that is directly executed.
int main()
{
DDD(DDD);
}
_DDD()
[00002163] 55 push ebp
[00002164] 8bec mov ebp,esp
[00002166] 6863210000 push 00002163
[0000216b] e853f4ffff call 000015c3
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
_main()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6863210000 push 00002163 ; push DDD
[0000218b] e8d3ffffff call 00002163 ; call DDD(DDD)
[00002190] 83c404 add esp,+04
[00002193] 33c0 xor eax,eax
[00002195] 5d pop ebp
[00002196] c3 ret
Size in bytes:(0020) [00002196]
Adding level markers
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
1 [00002183][001037dd][00000000] 55 push ebp ; housekeeping
1 [00002184][001037dd][00000000] 8bec mov ebp,esp ; housekeeping
1 [00002186][001037d9][00002163] 6863210000 push 00002163 ; push DDD
1 [0000218b][001037d5][00002190] e8d3ffffff call 00002163 ; call HHH(DDD)
1 [00002163][001037d1][001037dd] 55 push ebp ; housekeeping
1 [00002164][001037d1][001037dd] 8bec mov ebp,esp ; housekeeping
1 [00002166][001037cd][00002163] 6863210000 push 00002163 ; push DDD
1 [0000216b][001037c9][00002170] e853f4ffff call 000015c3 ; call HHH(DDD)
1 New slave_stack at:103881 ; Create new process context
So we have stopped showing level 1 simulation (by x86UTM) and now
showing the level 2 simulation that HHH(DDD) is performing.
The level 1 simulation should show the actual simuation of the
instructions that do this.
2 Begin Local Halt Decider Simulation Execution Trace Stored at:113889 >> 2 [00002163][00113879][0011387d] 55 push ebp ; housekeeping
2 [00002164][00113879][0011387d] 8bec mov ebp,esp ; housekeeping
2 [00002166][00113875][00002163] 6863210000 push 00002163 ; push DDD
2 [0000216b][00113871][00002170] e853f4ffff call 000015c3 ; call HHH(DDD)
And now we have stopped showing the level 2 simulation and are now
showing the level 3 simulation.
3 New slave_stack at:14e2a9 ; Create new process context
3 [00002163][0015e2a1][0015e2a5] 55 push ebp ; housekeeping
3 [00002164][0015e2a1][0015e2a5] 8bec mov ebp,esp ; housekeeping
3 [00002166][0015e29d][00002163] 6863210000 push 00002163 ; push DDD
3 [0000216b][0015e299][00002170] e853f4ffff call 000015c3 ; call HHH(DDD)
3 Local Halt Decider: Infinite Recursion Detected Simulation Stopped
So now the level 1 simulation is stopping its level 2 simulation and is claiming that this level 2 simulation, if correctly completed, would not
halt.
1 [00002170][001037d1][001037dd] 83c404 add esp,+04; executed DDD(DDD)
1 [00002173][001037d5][00002190] 5d pop ebp ; executed DDD(DDD)
1 [00002174][001037d9][00002163] c3 ret ; executed DDD(DDD)
1 [00002190][001037dd][00000000] 83c404 add esp,+04
1 [00002193][001037dd][00000000] 33c0 xor eax,eax
1 [00002195][001037e1][00000018] 5d pop ebp
1 [00002196][001037e5][00000000] c3 ret
1 Number of Instructions Executed(10073) == 150 Pages
Right, so DDD() Halts.
The simulation done by HHH(DDD) concluded that a complete simulation of
its input (that is DDD() ) would not halt.
But, if we give this input to a actual complete simultor, or somehow
change JUST THE OUTER H to not abort (which you structure doesn't allow,
except perhaps by using a debugger to change values) then the level 3
will create a level 4 simulation that looks just like the level 2 and 3,
and then the level 2 will abort its simulation just like level 1 did,
and then return to its caller, just like the level 1 did, and then return.
Thus, the CORRECT behavior represented by the input is shown to be halting.
You STILL don't understand that the partial simulation done by the
decider doesn't DEFINE the behavior of that input, it only OBSERVES it.
The behavior comes from the bytes of the input and the rules of
representaiton (that it is an x86 program) and thus the behavior doesn't
stop just because the decider stopped its simulation.
You make your claims about the behavior of the PARTIAL simulation done
by the decider but try to imply they are the actual behavior of the
complete behavior of the input, which is just a LIE.
Yes, the PARTIAL SIMULATION doesn't reach the the return, but that
doesn't mean that the program DDD or a COMPLETE simuliaton of it doesn't.
You are just showing you utter ignorance of the basics of the field.
--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)