int DD()I wonder why Olcott keeps repeating that HHH fails to reach the 'ret' instruction, where the direct execution or world-class simulators have
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
On 3/3/2025 9:33 PM, dbush wrote:Why are you repeating the failure of HHH to reach the 'ret' instruction?
On 3/3/2025 10:07 PM, olcott wrote:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Suppose we accept that HHH is able to correctly determine that
replacing the code of HHH with an unconditional simulator and running
HHH(DD) will not halt.
Then what?
That is not a valid rebuttal and your paraphrase of
these words is inaccurate:
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the 'ret'
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
instruction, where the direct execution or world-class simulators have
no problem to reach the 'ret' instruction of exactly the same finite
string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
On 3/4/2025 4:06 AM, Bonita Montero wrote:Cool. Now that you've made your point, would you please shut up?
Am 04.03.2025 um 04:07 schrieb olcott:
I am not wrong and no one can show that I wrongDD correctly emulated by HHH cannot possibly reach its own "ret"You're wrong; your program will never stop - like your halting problem
instruction and terminate normally.
The only valid rebuttal is to show all of the steps of exactly how DD
correctly emulated by HHH reaches its own "ret" instruction.
investigations.
The only valid rebuttal is to show all of the steps of exactly how DD correctly emulated by HHH reaches its own "ret" instruction. NO ONE CAN
DO THAT BECAUSE I AM CORRECT
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:DD always calls HHH.
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
Likewise I never attempt to show exactly how all squares are round.And that is exactly what Olcott does not show.The only valid rebuttal is to show all of the steps of exactly how DDDD correctly emulated by HHH cannot possibly reach its own "ret"I wonder why Olcott keeps repeating that HHH fails to reach the 'ret'
instruction and terminate normally.
instruction, where the direct execution or world-class simulators
have no problem to reach the 'ret' instruction of exactly the same
finite string as input.
correctly emulated by HHH reaches its own "ret" instruction.
So, my claim remains: HHH fails to reach the 'ret' instruction, whereDD calls its own emulator when emulated by HHH.
the direct execution and some world-class simulators have no problem to
reach it.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Assuming that the pathological relationship between HHH and DD has noThat's the problem of whatever is simulating DD, if anything.
effect on the behavior of DD when it is easily proven that it does IS
STUPID.
On 3/4/2025 9:38 AM, joes wrote:I have bad news for you.
Am Tue, 04 Mar 2025 08:21:39 -0600 schrieb olcott:Agree that I am correct or prove that I am wrong.
On 3/4/2025 4:06 AM, Bonita Montero wrote:Cool. Now that you've made your point, would you please shut up?
Am 04.03.2025 um 04:07 schrieb olcott:
I am not wrong and no one can show that I wrong The only validDD correctly emulated by HHH cannot possibly reach its own "ret"You're wrong; your program will never stop - like your halting
instruction and terminate normally.
The only valid rebuttal is to show all of the steps of exactly how
DD correctly emulated by HHH reaches its own "ret" instruction.
problem investigations.
rebuttal is to show all of the steps of exactly how DD correctly
emulated by HHH reaches its own "ret" instruction. NO ONE CAN DO THAT
BECAUSE I AM CORRECT
I MUST HAVE CLOSURE!!!
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of exactly
the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
So, my claim remains: HHH fails to reach the 'ret' instruction, where
the direct execution and some world-class simulators have no problem
to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Assuming that the pathological relationship between HHH
and DD has no effect on the behavior of DD when it is
easily proven that it does IS STUPID.
On 3/4/2025 3:14 PM, dbush wrote:
On 3/4/2025 2:58 PM, olcott wrote:
On 3/4/2025 1:33 PM, dbush wrote:
On 3/4/2025 2:20 PM, olcott wrote:
On 3/4/2025 12:44 PM, joes wrote:
Am Tue, 04 Mar 2025 10:11:30 -0600 schrieb olcott:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
Likewise I never attempt to show exactly how all squares are round. >>>>>>>And that is exactly what Olcott does not show.The only valid rebuttal is to show all of the steps of exactly >>>>>>>>> how DDDD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>> instruction and terminate normally.I wonder why Olcott keeps repeating that HHH fails to reach >>>>>>>>>> the 'ret'
instruction, where the direct execution or world-class simulators >>>>>>>>>> have no problem to reach the 'ret' instruction of exactly the >>>>>>>>>> same
finite string as input.
correctly emulated by HHH reaches its own "ret" instruction.
So, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>> whereDD calls its own emulator when emulated by HHH.
the direct execution and some world-class simulators have no
problem to
reach it.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
DD always calls HHH.
Thus only has a pathological relationship that changes its
behavior when the code of HHH is replaced with an unconditional
simulator and HHH(DD) is run
Well of course the behavior changes if you change the code
DD is the exact same sequence of machine code bytes
executed in three different execution contexts.
That would mean that no_numbers_greater_than_10 is the exact same
sequence of machine code bytes executed in different execution
contexts, and no_numbers_greater_than_10 simulated by F can't reach
its own "ret" instruction, therefore no_numbers_greater_than_10 is
correctly reported as non-halting, and because it doesn't halt we can
conclude that there is no natural number greater than 10.
Agreed? If not, explain why the above is wrong. Failure to do so,
either in your next response to this message or within 1 hour of your
next post in this newsgroup, will be taken as your on-the-record
admission that the above is correct and that you therefore believe
that no natural number exists that is greater than 10.
Let The Record Show that Peter Olcott made the following post in this newsgroup:
On 3/4/2025 7:34 PM, olcott wrote:
It is not my stupidity it is your dishonestly using
the straw-man deception to change the subject away from:
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
And more than one hour has passed since this posting and he has not
responded to this post.
He has therefore satisfied the requirements listed above for admitting
the above asserted statement is correct.
Therefore:
Let The Record Show:
That Peter Olcott has officially admitted:
That no_numbers_greater_than_10 simulated by F can't reach its own "ret" instruction, therefore no_numbers_greater_than_10 is correctly reported
as non-halting, and because it doesn't halt we can conclude that there
is no natural number greater than 10.
And that he believes the above to be TRUE.
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:17 AM, olcott wrote:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of exactly
the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
No,
Meaning:
(a) You don't have a clue how to do this all of your
rebuttals have been pure bluster with zero technical
competence behind them.
(b) You know that I am correct and are simply lying.
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:32 AM, olcott wrote:
On 3/4/2025 6:29 AM, Richard Damon wrote:
On 3/3/25 10:07 PM, olcott wrote:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
No, it proves that the HHH that rejects the input, didn't do a correct
simulation, and thus was looking at the wrong input, because you don't
understand what a program is.
DD only is non-halting if *THE* HHH (and there is only one at any
time) never aborts. SInce HHH musts abort its emulation to "reject"
the input, it proves it didn't do the needed correct emulation, and
you are shown to be just a blantant liar.
Nope, I have shown why your logic is wrong,
And the HHH that correctly emulated DD, can't be a decider and answer. >>>>
Also. "the HHH", defined in your Halt7.c doesn't do that,
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Failing to provide the above proves that you are clueless
about this code.
If that was true you could show this with
something besides rhetoric and double-talk.
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the >>>>>>>> 'ret' instruction, where the direct execution or world-class
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
So, my claim remains: HHH fails to reach the 'ret' instruction,
where the direct execution and some world-class simulators have no >>>>>> problem to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Which just show your stupidity, as DD doesn't HAVE its own emulator,
and CAN'T know who or if it is being emulated.
It is not my stupidity it is your dishonestly using
the straw-man deception to change the subject away from:
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
WHich is the strawman, that you are too stupid to recogines.
I will show that it is not straw-man after you quit
dodging that point.
On 3/4/2025 10:45 PM, Richard Damon wrote:
On 3/4/25 7:42 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:32 AM, olcott wrote:
On 3/4/2025 6:29 AM, Richard Damon wrote:
On 3/3/25 10:07 PM, olcott wrote:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
No, it proves that the HHH that rejects the input, didn't do a
correct simulation, and thus was looking at the wrong input, because
you don't understand what a program is.
DD only is non-halting if *THE* HHH (and there is only one at any
time) never aborts. SInce HHH musts abort its emulation to "reject"
the input, it proves it didn't do the needed correct emulation, and
you are shown to be just a blantant liar.
Nope, I have shown why your logic is wrong,
And the HHH that correctly emulated DD, can't be a decider and
answer.
Also. "the HHH", defined in your Halt7.c doesn't do that,
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Failing to provide the above proves that you are clueless
about this code.
If that was true you could show this with
something besides rhetoric and double-talk.
That you call all I say as just rhetoric just shows how stupid you are.
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
AND YOU CAN'T SHOW OTHERWISE
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of exactly
the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
So, my claim remains: HHH fails to reach the 'ret' instruction, where
the direct execution and some world-class simulators have no problem
to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Assuming that the pathological relationship between HHH
and DD has no effect on the behavior of DD when it is
easily proven that it does IS STUPID.
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
So, my claim remains: HHH fails to reach the 'ret' instruction,
where the direct execution and some world-class simulators have no
problem to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Which just show your stupidity, as DD doesn't HAVE its own emulator,
and CAN'T know who or if it is being emulated.
It is not my stupidity it is your dishonestly using
the straw-man deception to change the subject away from:
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
On 3/4/2025 10:44 PM, Richard Damon wrote:And therefore it correctly reports its failure to do a correct simulation.
On 3/4/25 7:39 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:17 AM, olcott wrote:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
No,
Meaning:
(a) You don't have a clue how to do this all of your
rebuttals have been pure bluster with zero technical
competence behind them.
(b) You know that I am correct and are simply lying.
Nope, it just proves that
Dodging this point is your only rebuttal to it:
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
On 3/4/2025 12:44 PM, joes wrote:
Am Tue, 04 Mar 2025 10:11:30 -0600 schrieb olcott:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
Likewise I never attempt to show exactly how all squares are round.And that is exactly what Olcott does not show.The only valid rebuttal is to show all of the steps of exactly how DD >>>>> correctly emulated by HHH reaches its own "ret" instruction.DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.I wonder why Olcott keeps repeating that HHH fails to reach the 'ret' >>>>>> instruction, where the direct execution or world-class simulators
have no problem to reach the 'ret' instruction of exactly the same >>>>>> finite string as input.
So, my claim remains: HHH fails to reach the 'ret' instruction, whereDD calls its own emulator when emulated by HHH.
the direct execution and some world-class simulators have no problem to >>>> reach it.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
DD always calls HHH.
Thus only has a pathological relationship that changes its
behavior when DD is correctly emulated by HHH.
Assuming that the pathological relationship between HHH and DD has noThat's the problem of whatever is simulating DD, if anything.
effect on the behavior of DD when it is easily proven that it does IS
STUPID.
It makes HHH(DD) correct to reject DD as non-terminating.
On 3/4/2025 12:42 PM, joes wrote:is wrong.
Am Tue, 04 Mar 2025 10:18:09 -0600 schrieb olcott:That Joes is only a troll and does not understand these things well
On 3/4/2025 9:38 AM, joes wrote:I have bad news for you.
Am Tue, 04 Mar 2025 08:21:39 -0600 schrieb olcott:Agree that I am correct or prove that I am wrong.
On 3/4/2025 4:06 AM, Bonita Montero wrote:Cool. Now that you've made your point, would you please shut up?
Am 04.03.2025 um 04:07 schrieb olcott:
I am not wrong and no one can show that I wrong The only validDD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.You're wrong; your program will never stop - like your halting
The only valid rebuttal is to show all of the steps of exactly how >>>>>>> DD correctly emulated by HHH reaches its own "ret" instruction.
problem investigations.
rebuttal is to show all of the steps of exactly how DD correctly
emulated by HHH reaches its own "ret" instruction. NO ONE CAN DO
THAT BECAUSE I AM CORRECT
I MUST HAVE CLOSURE!!!
enough to provide any technically correct rebuttal, yet still remains a naysayer out of trollish pleasure
On 3/4/2025 11:08 PM, Richard Damon wrote:No, the simulated HHH is aborted.
On 3/4/25 11:53 PM, olcott wrote:
On 3/4/2025 10:45 PM, Richard Damon wrote:
On 3/4/25 7:42 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:32 AM, olcott wrote:
On 3/4/2025 6:29 AM, Richard Damon wrote:
On 3/3/25 10:07 PM, olcott wrote:
The code proves that it does answer yet code is over your head. All youRight, but the HHH that does that doesn't answer,DD correctly emulated by HHH cannot possibly reach its own "ret"That you call all I say as just rhetoric just shows how stupid youIf that was true you could show this with something besides rhetoric >>>>> and double-talk.Nope, I have shown why your logic is wrong,And the HHH that correctly emulated DD, can't be a decider and >>>>>>>> answer.The only valid rebuttal is to show all of the steps of exactly how >>>>>>> DD correctly emulated by HHH reaches its own "ret" instruction.
Also. "the HHH", defined in your Halt7.c doesn't do that,
Failing to provide the above proves that you are clueless about
this code.
are.
instruction and terminate normally. AND YOU CAN'T SHOW OTHERWISE
have is rhetoric anchored ignorance.
No. Simulation does not mean the code runs on the processor. Otherwiseand there is only one HHH in existance at a time in the given memoryIf you were not clueless you would know that the code proves that you
locations, so you claim is worthless and based on lies.
are wrong.
On 3/4/2025 11:07 PM, Richard Damon wrote:Ys it fails to do a correct simulation, because it cannot possibly reach
On 3/4/25 11:51 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:39 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:17 AM, olcott wrote:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the >>>>>>>> 'ret' instruction, where the direct execution or world-class
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
No,
Meaning:
(a) You don't have a clue how to do this all of your
rebuttals have been pure bluster with zero technical
competence behind them.
(b) You know that I am correct and are simply lying.
Nope, it just proves that
Dodging this point is your only rebuttal to it:
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
And you are just dodging that the HHH that correctly emualates its
input, will never answer when given a DD built on it, so it isn't the
needed decider.
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
On 3/4/2025 11:08 PM, Richard Damon wrote:The code cheating with the Root variable and many other cheats is
On 3/4/25 11:53 PM, olcott wrote:
On 3/4/2025 10:45 PM, Richard Damon wrote:
On 3/4/25 7:42 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 9:32 AM, olcott wrote:
On 3/4/2025 6:29 AM, Richard Damon wrote:No, it proves that the HHH that rejects the input, didn't do a
On 3/3/25 10:07 PM, olcott wrote:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>>
correct simulation, and thus was looking at the wrong input,
because you don't understand what a program is.
DD only is non-halting if *THE* HHH (and there is only one at any
time) never aborts. SInce HHH musts abort its emulation to
"reject" the input, it proves it didn't do the needed correct
emulation, and you are shown to be just a blantant liar.
Nope, I have shown why your logic is wrong,
And the HHH that correctly emulated DD, can't be a decider and >>>>>>>> answer.
Also. "the HHH", defined in your Halt7.c doesn't do that,
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Failing to provide the above proves that you are clueless
about this code.
If that was true you could show this with
something besides rhetoric and double-talk.
That you call all I say as just rhetoric just shows how stupid you are. >>>>
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
AND YOU CAN'T SHOW OTHERWISE
Right, but the HHH that does that doesn't answer,
The code proves that it does answer yet code is
over your head.
On 3/4/2025 12:44 PM, joes wrote:*HHH* has a pathological relationship when it is trying to simulate
Am Tue, 04 Mar 2025 10:11:30 -0600 schrieb olcott:Thus only has a pathological relationship that changes its behavior when
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:DD always calls HHH.
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
Likewise I never attempt to show exactly how all squares are round.And that is exactly what Olcott does not show.The only valid rebuttal is to show all of the steps of exactly howDD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.I wonder why Olcott keeps repeating that HHH fails to reach the
'ret'
instruction, where the direct execution or world-class simulators
have no problem to reach the 'ret' instruction of exactly the same >>>>>> finite string as input.
DD correctly emulated by HHH reaches its own "ret" instruction.
So, my claim remains: HHH fails to reach the 'ret' instruction, whereDD calls its own emulator when emulated by HHH.
the direct execution and some world-class simulators have no problem
to reach it.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
DD is correctly emulated by HHH.
No, it's just saying it can't simulate it.It makes HHH(DD) correct to reject DD as non-terminating.Assuming that the pathological relationship between HHH and DD has noThat's the problem of whatever is simulating DD, if anything.
effect on the behavior of DD when it is easily proven that it does IS
STUPID.
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
lol "I will explain why this is your argument after you agree to it" smhI WILL NOT TOLERATE ANY OTHER ORDERWrong order,I will show that it is not straw-man after you quit dodging thatWHich is the strawman, that you are too stupid to recogines.It is not my stupidity it is your dishonestly using the straw-manWhich just show your stupidity, as DD doesn't HAVE its ownSo, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>> where the direct execution and some world-class simulators have >>>>>>>> no problem to reach it.DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1. DD DOES >>>>>>> NOT call its own emulator when directly executed.
emulator, and CAN'T know who or if it is being emulated.
deception to change the subject away from:
DD correctly emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally.
point.
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach >>>>>>>>>> the 'ret' instruction, where the direct execution or world- >>>>>>>>>> class simulators have no problem to reach the 'ret'
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
instruction of exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
So, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>> where the direct execution and some world-class simulators have >>>>>>>> no problem to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Which just show your stupidity, as DD doesn't HAVE its own
emulator, and CAN'T know who or if it is being emulated.
It is not my stupidity it is your dishonestly using
the straw-man deception to change the subject away from:
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
WHich is the strawman, that you are too stupid to recogines.
I will show that it is not straw-man after you quit
dodging that point.
Wrong order,
I WILL NOT TOLERATE ANY OTHER ORDER
On 3/5/2025 6:19 AM, Richard Damon wrote:What is the next step?
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even though logicallyI WILL NOT TOLERATE ANY OTHER ORDERWrong order,I will show that it is not straw-man after you quit dodging thatWHich is the strawman, that you are too stupid to recogines.It is not my stupidity it is your dishonestly using the straw-man >>>>>>> deception to change the subject away from:Which just show your stupidity, as DD doesn't HAVE its ownSo, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>>>> where the direct execution and some world-class simulators have >>>>>>>>>> no problem to reach it.DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1. DD DOES >>>>>>>>> NOT call its own emulator when directly executed.
emulator, and CAN'T know who or if it is being emulated.
DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
point.
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten.
DD correctly emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof
On 3/5/2025 3:27 AM, joes wrote:Nope. HHH1 doesn't simulate itself.
Am Tue, 04 Mar 2025 23:09:42 -0600 schrieb olcott:When DD emulated by HHH calls HHH(DD) (its own emulator)
On 3/4/2025 11:07 PM, Richard Damon wrote:lol "I will explain why this is your argument after you agree to it"
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
I WILL NOT TOLERATE ANY OTHER ORDERWrong order,I will show that it is not straw-man after you quit dodging thatWHich is the strawman, that you are too stupid to recogines.It is not my stupidity it is your dishonestly using the straw-man >>>>>>> deception to change the subject away from:Which just show your stupidity, as DD doesn't HAVE its ownSo, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>>>> where the direct execution and some world-class simulators have >>>>>>>>>> no problem to reach it.DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1. DD DOES >>>>>>>>> NOT call its own emulator when directly executed.
emulator, and CAN'T know who or if it is being emulated.
DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
point.
it tells HHH to emulate itself again in recursive emulation until
aborted because DD is calling its own emulator.
When DD emulated by HHH1 calls HHH(DD) (not its own emulator)
it tells HHH to emulate itself again yet not in recursive emulation
because DD is NOT calling its own emulator.
On 3/5/2025 3:27 AM, joes wrote:
Am Tue, 04 Mar 2025 23:09:42 -0600 schrieb olcott:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
lol "I will explain why this is your argument after you agree to it" smhI WILL NOT TOLERATE ANY OTHER ORDERWrong order,I will show that it is not straw-man after you quit dodging thatWHich is the strawman, that you are too stupid to recogines.It is not my stupidity it is your dishonestly using the straw-man >>>>>>> deception to change the subject away from:Which just show your stupidity, as DD doesn't HAVE its ownSo, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>>>> where the direct execution and some world-class simulators have >>>>>>>>>> no problem to reach it.DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1. DD DOES >>>>>>>>> NOT call its own emulator when directly executed.
emulator, and CAN'T know who or if it is being emulated.
DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
point.
When DD emulated by HHH calls HHH(DD) (its own emulator)
it tells HHH to emulate itself again in recursive emulation
until aborted because DD is calling its own emulator.
When DD emulated by HHH1 calls HHH(DD) (not its own emulator)
it tells HHH to emulate itself again yet not in recursive
emulation because DD is NOT calling its own emulator.
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:What is the next step?
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even though logically >>>> requried, because you need to hide your fraud.I WILL NOT TOLERATE ANY OTHER ORDERWrong order,I will show that it is not straw-man after you quit dodging that >>>>>>> point.WHich is the strawman, that you are too stupid to recogines.It is not my stupidity it is your dishonestly using the straw-man >>>>>>>>> deception to change the subject away from:Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>> emulator, and CAN'T know who or if it is being emulated.So, my claim remains: HHH fails to reach the 'ret' instruction, >>>>>>>>>>>> where the direct execution and some world-class simulators have >>>>>>>>>>>> no problem to reach it.DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1. DD DOES >>>>>>>>>>> NOT call its own emulator when directly executed.
DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>> instruction and terminate normally.
One cannot learn algebra before one has learned to count to ten.
DD correctly emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:The only valid rebuttal is to show all of the steps of
int DD()instruction of exactly the same finite string as input. >>>>>>>>>>>
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally. >>>>>>>>>>>> I wonder why Olcott keeps repeating that HHH fails to reach >>>>>>>>>>>> the 'ret' instruction, where the direct execution or world- >>>>>>>>>>>> class simulators have no problem to reach the 'ret'
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
So, my claim remains: HHH fails to reach the 'ret'
instruction, where the direct execution and some world-class >>>>>>>>>> simulators have no problem to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Which just show your stupidity, as DD doesn't HAVE its own
emulator, and CAN'T know who or if it is being emulated.
It is not my stupidity it is your dishonestly using
the straw-man deception to change the subject away from:
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
WHich is the strawman, that you are too stupid to recogines.
I will show that it is not straw-man after you quit
dodging that point.
Wrong order,
I WILL NOT TOLERATE ANY OTHER ORDER
In other words, you CAN'T handle any other order, even though
logically requried, because you need to hide your fraud.
My proof requires a specific prerequisite order.
One cannot learn algebra before one has learned to count to ten.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:What is the next step?
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even thoughI WILL NOT TOLERATE ANY OTHER ORDERWrong order,I will show that it is not straw-man after you quit dodging that >>>>>>>> point.WHich is the strawman, that you are too stupid to recogines.It is not my stupidity it is your dishonestly using the straw-man >>>>>>>>>> deception to change the subject away from:Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated.So, my claim remains: HHH fails to reach the 'ret'DD calls its own emulator when emulated by HHH.
instruction,
where the direct execution and some world-class simulators >>>>>>>>>>>>> have
no problem to reach it.
DD DOES NOT call its own emulator when emulated by HHH1. DD >>>>>>>>>>>> DOES
NOT call its own emulator when directly executed.
DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>> instruction and terminate normally.
logically
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten.
DD correctly emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on the
question.
On 3/5/2025 3:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:What is the next step?
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even thoughI WILL NOT TOLERATE ANY OTHER ORDERWrong order,WHich is the strawman, that you are too stupid to recogines. >>>>>>>>> I will show that it is not straw-man after you quit dodging that >>>>>>>>> point.straw-manWhich just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated. >>>>>>>>>>> It is not my stupidity it is your dishonestly using theSo, my claim remains: HHH fails to reach the 'ret' >>>>>>>>>>>>>> instruction,DD calls its own emulator when emulated by HHH.
where the direct execution and some world-class simulators >>>>>>>>>>>>>> have
no problem to reach it.
DD DOES NOT call its own emulator when emulated by HHH1. DD >>>>>>>>>>>>> DOES
NOT call its own emulator when directly executed.
deception to change the subject away from:
DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>> instruction and terminate normally.
logically
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten.
DD correctly emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on the
question.
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
This is irrefutable. Every attempt to show otherwise
has been a change of subject.
Until we have mutual agreement on that key most
important point upon which all other points depend
this point will be repeated.
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the 'ret'
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
instruction, where the direct execution or world-class simulators have
no problem to reach the 'ret' instruction of exactly the same finite
string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words, you know that what you're working on has nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT THE SHIT! >>>
You want people to accept that HHH(DD) does in fact report that
changing the code of HHH to an unconditional simulator and running
HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
It took me over two years to come up with those irrefutable
words that sum of the key essence of my whole proof.
On 3/5/2025 9:57 PM, dbush wrote:You used to have enough time.
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that
In other words, you know that what you're working on has nothing to >>>>>> do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT THE
SHIT!
changing the code of HHH to an unconditional simulator and running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an unconditional
simulator and subsequently running HHH(DD) does not halt, which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
On 2/22/2025 11:10 AM, dbush wrote:
On 2/22/2025 11:43 AM, olcott wrote:Wow finally someone that totally gets it.
The first point is DD correctly simulated by HHH cannot possibly
terminate normally by reaching its own "return" instruction.
In other words, if the code of HHH is replaced with an
unconditional simulator then it can be shown that DD is
non-halting and therefore HHH(DD)==0 is correct.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is
different from replacing the code of Y with an unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go through anything but the exact point.
The purpose of these posts is so that my posthumous reviewers will understand.There won't be any.
On 3/5/2025 5:36 PM, Richard Damon wrote:Yes, that is what HHH reports: I cannot complete the simulation up to
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:What is the next step?
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even thoughI WILL NOT TOLERATE ANY OTHER ORDERWrong order,WHich is the strawman, that you are too stupid to recogines. >>>>>>>>>> I will show that it is not straw-man after you quit dodging that >>>>>>>>>> point.deception to change the subject away from:Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated. >>>>>>>>>>>> It is not my stupidity it is your dishonestly using the >>>>>>>>>>>> straw-manSo, my claim remains: HHH fails to reach the 'ret' >>>>>>>>>>>>>>> instruction,DD calls its own emulator when emulated by HHH.
where the direct execution and some world-class
simulators have
no problem to reach it.
DD DOES NOT call its own emulator when emulated by HHH1. >>>>>>>>>>>>>> DD DOES
NOT call its own emulator when directly executed.
DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>> "ret"
instruction and terminate normally.
logically
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten.
DD correctly emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on the
question.
Which is the problem, since you don't have the correct question.
If HHH is a Halt Decider / Termination analyzer, the ONLY behavior
that matters is the behavior of the directly executed program whose
description is provided.
That is a stupid thing to say.
HHH computes the mapping to a return value on the
basis of what its finite string INPUT specifies.
THIS IS WHAT IT SPECIFIES
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
On 3/5/2025 2:58 AM, Fred. Zwarts wrote:Olcott assumes that aborting is the only way to prevent that HHH
Op 04.mrt.2025 om 17:11 schreef olcott:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:And that is exactly what Olcott does not show.
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD()I wonder why Olcott keeps repeating that HHH fails to reach the
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
Likewise I never attempt to show exactly how
all squares are round.
But it is very similar.
So, my claim remains: HHH fails to reach the 'ret' instruction,
where the direct execution and some world-class simulators have no
problem to reach it.
DD calls its own emulator when emulated by HHH.
DD DOES NOT call its own emulator when emulated by HHH1.
DD DOES NOT call its own emulator when directly executed.
Assuming that the pathological relationship between HHH
and DD has no effect on the behavior of DD when it is
easily proven that it does IS STUPID.
It has no effect on the behaviour of DD, but on the behaviour of the
simulator.
When DD emulated by HHH calls HHH(DD) (its own emulator)
it tells HHH to emulate itself again in recursive emulation
until aborted because DD is calling its own emulator.
On 3/5/2025 5:39 PM, Richard Damon wrote:
On 3/5/25 4:37 PM, olcott wrote:
On 3/5/2025 3:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even thoughI WILL NOT TOLERATE ANY OTHER ORDERWrong order,WHich is the strawman, that you are too stupid to recogines. >>>>>>>>>>> I will show that it is not straw-man after you quit dodging that >>>>>>>>>>> point.deception to change the subject away from:So, my claim remains: HHH fails to reach the 'ret' >>>>>>>>>>>>>>>> instruction,DD calls its own emulator when emulated by HHH.
where the direct execution and some world-class >>>>>>>>>>>>>>>> simulators have
no problem to reach it.
DD DOES NOT call its own emulator when emulated by HHH1. >>>>>>>>>>>>>>> DD DOES
NOT call its own emulator when directly executed. >>>>>>>>>>>>>> Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated. >>>>>>>>>>>>> It is not my stupidity it is your dishonestly using the >>>>>>>>>>>>> straw-man
DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "ret"
instruction and terminate normally.
logically
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten. >>>>>>> DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof >>>>>> What is the next step?
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on the
question.
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
Right, and thus any HHH that does a correct emulation can not return
to its caller,
We have been over this point too many times you are
just a liar. Liar and Christian is a combination with
very bad consequences.
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that
In other words, you know that what you're working on has nothing to >>>>>>>> do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT THE >>>>>>> SHIT!
changing the code of HHH to an unconditional simulator and running >>>>>> HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an unconditional
simulator and subsequently running HHH(DD) does not halt, which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot possibly >>>> >>> terminate normally by reaching its own "return" instruction.
>>
>> In other words, if the code of HHH is replaced with an
>> unconditional simulator then it can be shown that DD is
>> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is
different from replacing the code of Y with an unconditional simulator >>>> and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice.
The purpose of these posts is so that my posthumous reviewers will
understand.
There won't be any.
On 3/6/2025 6:37 PM, Richard Damon wrote:So what's the next step?
On 3/6/25 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
*DD correctly emulated by HHH cannot possibly reach*What is the next step?My proof requires a specific prerequisite order.I WILL NOT TOLERATE ANY OTHER ORDERIn other words, you CAN'T handle any other order, even though >>>>>>>>>>> logically requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to >>>>>>>>>> ten. DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>> "ret" instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my >>>>>>>>>> proof
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it is >>>>>>>> the the simplest way to state the key element of the whole proof >>>>>>>> and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT IS
DISHONEST.
Yes, that is the directly executed program.That is a stupid thing to say.Before agreeing on an answer, it is first required to agree on the >>>>>>> question.Which is the problem, since you don't have the correct question.
If HHH is a Halt Decider / Termination analyzer, the ONLY behavior >>>>>> that matters is the behavior of the directly executed program whose >>>>>> description is provided.
HHH computes the mapping to a return value on the basis of what its
finite string INPUT specifies.
No, DD doesn't specify anything about what is to simulate it.THIS IS WHAT IT SPECIFIES *DD correctly emulated by HHH cannot
possibly reach its own "ret" instruction and terminate normally*
No, HHH aborts.Yes, that is what HHH reports: I cannot complete the simulation up toThe finite string of DD correctly emulated by HHH specifies recursive
the end. No more, no less.
There are easier ways to make a program to report the failure of a
simulation.
emulation that cannot possibly reach its own "ret" instruction BECAUSE
IT SPECIFIES RECURSINVE EMULATION.
And the actual code of DD specifies that it halts.But the HHH that decides are returns can't be that HHH, so the DD givenThat seems to be a little incoherent so I cannot tell what you are
to that HHH doesn't call the correctly emulating HHH, so you whole
argument is shown to be the fraud you have admitted to.
saying yet you are at least attempting to use reasoning.
I am just saying what the actual x86 machine code actually specifies therefore any rebuttal is necessarily incorrect.
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>> changing the code of HHH to an unconditional simulator and running >>>>>>>> HHH(DD) will not halt.
In other words, you know that what you're working on has
nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT THE >>>>>>>>> SHIT!
In other words, replacing the code of HHH with an unconditional
simulator and subsequently running HHH(DD) does not halt, which you >>>>>> previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot
possibly
>>> terminate normally by reaching its own "return" instruction. >>>>>> >>
>> In other words, if the code of HHH is replaced with an
>> unconditional simulator then it can be shown that DD is
>> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is
different from replacing the code of Y with an unconditional
simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go >>>>> through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice.
Which really means you need to abandon your fraudulent methods
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too uninteresting that >>>> it would need a rebuttal, and so is the question that does it reach its >>>> "ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
As "DD correctly emulated by HHH" does not exist
*No one has made any attempt to show that*
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words, you know that what you're working on has nothing
to do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT THE
SHIT!
You want people to accept that HHH(DD) does in fact report that
changing the code of HHH to an unconditional simulator and running
HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction,
Despicably dishonest attempt at the straw-man deception.
On 3/6/2025 1:49 AM, Mikko wrote:
On 2025-03-04 14:17:56 +0000, olcott said:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE:I wonder why Olcott keeps repeating that HHH fails to reach the
goto HERE; return Halt_Status; }
_DD() [00002133] 55 push ebp ; housekeeping [00002134]
8bec mov ebp,esp ; housekeeping [00002136]
51 push ecx ; make space for local [00002137]
6833210000 push 00002133 ; push DD [0000213c] e882f4ffff call
000015c3 ; call HHH(DD) [00002141] 83c404 add esp,+04 [00002144] >>>>> 8945fc mov [ebp-04],eax [00002147] 837dfc00
cmp dword [ebp-04],+00 [0000214b] 7402 jz 0000214f [0000214d]
ebfe jmp 0000214d [0000214f] 8b45fc mov
eax,[ebp-04] [00002152] 8be5 mov esp,ebp [00002154]
5d pop ebp [00002155] c3 ret Size in bytes:
(0035) [00002155]
DD correctly emulated by HHH cannot possibly reach its own
"ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of exactly how
DD correctly emulated by HHH reaches its own "ret" instruction.
Not true. A sufficient rebuttal is anything that makes a reader to
notice that you have not proven one (or more) of your claims.
A specific rebuttal of this specific claim
Requires a specific rebuttal of that claimDD correctly emulated by HHH cannot possibly reach its own
"ret" instruction and terminate normally.
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too uninteresting
that
it would need a rebuttal, and so is the question that does it reach its >>>> "ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
As "DD correctly emulated by HHH" does not exist
*No one has made any attempt to show that*
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:Yes, that is what HHH reports: I cannot complete the simulation up to
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even though >>>>>>>>> logicallyI WILL NOT TOLERATE ANY OTHER ORDERWrong order,point.WHich is the strawman, that you are too stupid to recogines. >>>>>>>>>>>> I will show that it is not straw-man after you quit dodging >>>>>>>>>>>> thatdeception to change the subject away from:So, my claim remains: HHH fails to reach the 'ret' >>>>>>>>>>>>>>>>> instruction,DD calls its own emulator when emulated by HHH. >>>>>>>>>>>>>>>> DD DOES NOT call its own emulator when emulated by HHH1. >>>>>>>>>>>>>>>> DD DOES
where the direct execution and some world-class >>>>>>>>>>>>>>>>> simulators have
no problem to reach it.
NOT call its own emulator when directly executed. >>>>>>>>>>>>>>> Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated. >>>>>>>>>>>>>> It is not my stupidity it is your dishonestly using the >>>>>>>>>>>>>> straw-man
DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>>> "ret"
instruction and terminate normally.
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten. >>>>>>>> DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>> instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof >>>>>>> What is the next step?
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on the
question.
Which is the problem, since you don't have the correct question.
If HHH is a Halt Decider / Termination analyzer, the ONLY behavior
that matters is the behavior of the directly executed program whose
description is provided.
That is a stupid thing to say.
HHH computes the mapping to a return value on the
basis of what its finite string INPUT specifies.
THIS IS WHAT IT SPECIFIES
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
the end. No more, no less.
There are easier ways to make a program to report the failure of a
simulation.
The finite string of DD correctly emulated by HHH
specifies recursive emulation that cannot possibly
reach its own "ret" instruction BECAUSE IT SPECIFIES
RECURSINVE EMULATION.
On 3/6/2025 2:28 PM, dbush wrote:
On 3/6/2025 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:Yes, that is what HHH reports: I cannot complete the simulation up
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott: >>>>>>>>>>>>>>>>>>>> On 3/4/2025 3:14 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>> Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even though >>>>>>>>>>> logicallyI WILL NOT TOLERATE ANY OTHER ORDERWrong order,point.WHich is the strawman, that you are too stupid to recogines. >>>>>>>>>>>>>> I will show that it is not straw-man after you quit >>>>>>>>>>>>>> dodging thatdeception to change the subject away from:So, my claim remains: HHH fails to reach the 'ret' >>>>>>>>>>>>>>>>>>> instruction,DD calls its own emulator when emulated by HHH. >>>>>>>>>>>>>>>>>> DD DOES NOT call its own emulator when emulated by >>>>>>>>>>>>>>>>>> HHH1. DD DOES
where the direct execution and some world-class >>>>>>>>>>>>>>>>>>> simulators have
no problem to reach it.
NOT call its own emulator when directly executed. >>>>>>>>>>>>>>>>> Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated. >>>>>>>>>>>>>>>> It is not my stupidity it is your dishonestly using the >>>>>>>>>>>>>>>> straw-man
DD correctly emulated by HHH cannot possibly reach its >>>>>>>>>>>>>>>> own "ret"
instruction and terminate normally.
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten. >>>>>>>>>> DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>> instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof >>>>>>>>> What is the next step?
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute. >>>>>>>>
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on
the question.
Which is the problem, since you don't have the correct question.
If HHH is a Halt Decider / Termination analyzer, the ONLY behavior >>>>>> that matters is the behavior of the directly executed program
whose description is provided.
That is a stupid thing to say.
HHH computes the mapping to a return value on the
basis of what its finite string INPUT specifies.
THIS IS WHAT IT SPECIFIES
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
to the end. No more, no less.
There are easier ways to make a program to report the failure of a
simulation.
The finite string of replacing the code of HHH with an unconditional
simulator and subsequently running HHH(DD)
specifies recursive emulation that cannot possibly
reach its own "ret" instruction BECAUSE IT SPECIFIES
RECURSINVE EMULATION.
Makes sense
Whether or not the code of HHH is replaced
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally.
In the latter case HHH can (and does) report that
its input finite string specifies a non-terminating
sequence of instructions.
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>> changing the code of HHH to an unconditional simulator and running >>>>>>>> HHH(DD) will not halt.
In other words, you know that what you're working on has
nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT THE >>>>>>>>> SHIT!
In other words, replacing the code of HHH with an unconditional
simulator and subsequently running HHH(DD) does not halt, which you >>>>>> previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot
possibly
>>> terminate normally by reaching its own "return" instruction. >>>>>> >>
>> In other words, if the code of HHH is replaced with an
>> unconditional simulator then it can be shown that DD is
>> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is
different from replacing the code of Y with an unconditional
simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go >>>>> through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice.
Which really means you need to abandon your fraudulent methods
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/7/2025 2:26 AM, Mikko wrote:Indeed, HHH reports that it cannot possibly perform a complete (correct) simulation of itself.
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it
reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
As "DD correctly emulated by HHH" does not exist
*No one has made any attempt to show that*
Maybe not. Perhaps every demonstration of that was just a byproduct of
some other attempt. Anyway, HHH does not emulate DD correctly to the end.
Simulating termination analyzer HHH simulates its input DD until HHH correctly determines that DD cannot possibly reach its own "return" instruction and terminate normally.
On 3/7/2025 2:02 AM, joes wrote:
Am Thu, 06 Mar 2025 20:59:49 -0600 schrieb olcott:
On 3/6/2025 6:37 PM, Richard Damon wrote:So what's the next step?
On 3/6/25 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
*DD correctly emulated by HHH cannot possibly reach*What is the next step?One cannot learn algebra before one has learned to count to >>>>>>>>>>>> ten. DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>> "ret" instruction and terminate normally.I WILL NOT TOLERATE ANY OTHER ORDERIn other words, you CAN'T handle any other order, even though >>>>>>>>>>>>> logically requried, because you need to hide your fraud. >>>>>>>>>>>> My proof requires a specific prerequisite order.
Is the first step of the mandatory prerequisite order of my >>>>>>>>>>>> proof
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it is >>>>>>>>>> the the simplest way to state the key element of the whole proof >>>>>>>>>> and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT IS >>>>>>>>>> DISHONEST.
Yes, that is the directly executed program.That is a stupid thing to say.Before agreeing on an answer, it is first required to agree on the >>>>>>>>> question.Which is the problem, since you don't have the correct question. >>>>>>>> If HHH is a Halt Decider / Termination analyzer, the ONLY behavior >>>>>>>> that matters is the behavior of the directly executed program whose >>>>>>>> description is provided.
HHH computes the mapping to a return value on the basis of what its >>>>>>> finite string INPUT specifies.
No, DD doesn't specify anything about what is to simulate it.THIS IS WHAT IT SPECIFIES *DD correctly emulated by HHH cannot
possibly reach its own "ret" instruction and terminate normally*
No, HHH aborts.Yes, that is what HHH reports: I cannot complete the simulation up to >>>>>> the end. No more, no less.The finite string of DD correctly emulated by HHH specifies recursive >>>>> emulation that cannot possibly reach its own "ret" instruction BECAUSE >>>>> IT SPECIFIES RECURSINVE EMULATION.
There are easier ways to make a program to report the failure of a >>>>>> simulation.
But the HHH that decides are returns can't be that HHH, so the DD given >>>> to that HHH doesn't call the correctly emulating HHH, so you wholeThat seems to be a little incoherent so I cannot tell what you are
argument is shown to be the fraud you have admitted to.
saying yet you are at least attempting to use reasoning.
I am just saying what the actual x86 machine code actually specifies
therefore any rebuttal is necessarily incorrect.
And the actual code of DD specifies that it halts.*Straw-man deception*
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/7/2025 3:09 AM, Fred. Zwarts wrote:rebuttal at all.
Op 06.mrt.2025 om 21:11 schreef olcott:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it
reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
As "DD correctly emulated by HHH" does not exist
*No one has made any attempt to show that*
There is no proof that it does exist.
Failing to understand this code is less than no rebuttal at all. https://github.com/plolcott/x86utm/blob/master/Halt7.c
Failing to understand that no HHH can correctly simulate itself is no
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words, you know that what you're working on has nothing >>>>>>>> to do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
You have proven that you know these things pretty well SO QUIT
THE SHIT!
You want people to accept that HHH(DD) does in fact report that
changing the code of HHH to an unconditional simulator and running >>>>>> HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction,
Despicably dishonest attempt at the straw-man deception.
No rebuttal. So, we agree that HHH fails to reach the 'ret' instruction.
Not at all. Trying to get away with changing the subject
WILL NOT BE TOLERATED.
On 3/7/2025 9:15 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 15:49 schreef olcott:
On 3/7/2025 2:02 AM, joes wrote:Strawman. HHH fails to reach the 'ret' instruction, so HHH fails to do
Am Thu, 06 Mar 2025 20:59:49 -0600 schrieb olcott:*Straw-man deception*
On 3/6/2025 6:37 PM, Richard Damon wrote:So what's the next step?
On 3/6/25 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
*DD correctly emulated by HHH cannot possibly reach*What is the next step?"ret" instruction and terminate normally.I WILL NOT TOLERATE ANY OTHER ORDERIn other words, you CAN'T handle any other order, even >>>>>>>>>>>>>>> though
logically requried, because you need to hide your fraud. >>>>>>>>>>>>>> My proof requires a specific prerequisite order. >>>>>>>>>>>>>> One cannot learn algebra before one has learned to count to >>>>>>>>>>>>>> ten. DD correctly emulated by HHH cannot possibly reach >>>>>>>>>>>>>> its own
Is the first step of the mandatory prerequisite order of my >>>>>>>>>>>>>> proof
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that >>>>>>>>>>>> it is
the the simplest way to state the key element of the whole >>>>>>>>>>>> proof
and make this element impossible to correctly refute.
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT IS >>>>>>>>>>>> DISHONEST.
Yes, that is the directly executed program.That is a stupid thing to say.Before agreeing on an answer, it is first required to agree >>>>>>>>>>> on theWhich is the problem, since you don't have the correct question. >>>>>>>>>> If HHH is a Halt Decider / Termination analyzer, the ONLY
question.
behavior
that matters is the behavior of the directly executed program >>>>>>>>>> whose
description is provided.
HHH computes the mapping to a return value on the basis of what >>>>>>>>> its
finite string INPUT specifies.
No, DD doesn't specify anything about what is to simulate it.THIS IS WHAT IT SPECIFIES *DD correctly emulated by HHH cannot >>>>>>>>> possibly reach its own "ret" instruction and terminate normally*
No, HHH aborts.Yes, that is what HHH reports: I cannot complete the simulation >>>>>>>> up toThe finite string of DD correctly emulated by HHH specifies
the end. No more, no less.
There are easier ways to make a program to report the failure of a >>>>>>>> simulation.
recursive
emulation that cannot possibly reach its own "ret" instruction
BECAUSE
IT SPECIFIES RECURSINVE EMULATION.
But the HHH that decides are returns can't be that HHH, so the DDThat seems to be a little incoherent so I cannot tell what you are
given
to that HHH doesn't call the correctly emulating HHH, so you whole >>>>>> argument is shown to be the fraud you have admitted to.
saying yet you are at least attempting to use reasoning.
I am just saying what the actual x86 machine code actually specifies >>>>> therefore any rebuttal is necessarily incorrect.
And the actual code of DD specifies that it halts.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
a compete simulation.
Simulating termination analyzer HHH simulates its input DD until HHH correctly determines that DD cannot possibly reach its own "return" instruction and terminate normally.
On 3/7/2025 3:03 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:16 schreef olcott:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:Yes, that is what HHH reports: I cannot complete the simulation up
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott:
On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
On 3/4/2025 11:07 PM, Richard Damon wrote:
On 3/4/25 11:48 PM, olcott wrote:
On 3/4/2025 10:44 PM, Richard Damon wrote:
On 3/4/25 7:34 PM, olcott wrote:
On 3/4/2025 5:45 PM, Richard Damon wrote:
On 3/4/25 11:11 AM, olcott wrote:
On 3/4/2025 9:08 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 15:17 schreef olcott: >>>>>>>>>>>>>>>>>>>> On 3/4/2025 3:14 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>> Op 04.mrt.2025 om 04:07 schreef olcott:
My proof requires a specific prerequisite order.In other words, you CAN'T handle any other order, even though >>>>>>>>>>> logicallyI WILL NOT TOLERATE ANY OTHER ORDERWrong order,point.WHich is the strawman, that you are too stupid to recogines. >>>>>>>>>>>>>> I will show that it is not straw-man after you quit >>>>>>>>>>>>>> dodging thatdeception to change the subject away from:So, my claim remains: HHH fails to reach the 'ret' >>>>>>>>>>>>>>>>>>> instruction,DD calls its own emulator when emulated by HHH. >>>>>>>>>>>>>>>>>> DD DOES NOT call its own emulator when emulated by >>>>>>>>>>>>>>>>>> HHH1. DD DOES
where the direct execution and some world-class >>>>>>>>>>>>>>>>>>> simulators have
no problem to reach it.
NOT call its own emulator when directly executed. >>>>>>>>>>>>>>>>> Which just show your stupidity, as DD doesn't HAVE its own >>>>>>>>>>>>>>>>> emulator, and CAN'T know who or if it is being emulated. >>>>>>>>>>>>>>>> It is not my stupidity it is your dishonestly using the >>>>>>>>>>>>>>>> straw-man
DD correctly emulated by HHH cannot possibly reach its >>>>>>>>>>>>>>>> own "ret"
instruction and terminate normally.
requried, because you need to hide your fraud.
One cannot learn algebra before one has learned to count to ten. >>>>>>>>>> DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>> instruction and terminate normally.
Is the first step of the mandatory prerequisite order of my proof >>>>>>>>> What is the next step?
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
It has taken two years to create this first step such that it
is the the simplest way to state the key element of the
whole proof and make this element impossible to correctly refute. >>>>>>>>
EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT
IS DISHONEST.
Before agreeing on an answer, it is first required to agree on
the question.
Which is the problem, since you don't have the correct question.
If HHH is a Halt Decider / Termination analyzer, the ONLY behavior >>>>>> that matters is the behavior of the directly executed program
whose description is provided.
That is a stupid thing to say.
HHH computes the mapping to a return value on the
basis of what its finite string INPUT specifies.
THIS IS WHAT IT SPECIFIES
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
to the end. No more, no less.
There are easier ways to make a program to report the failure of a
simulation.
The finite string of DD correctly emulated by HHH
specifies recursive emulation that cannot possibly
reach its own "ret" instruction BECAUSE IT SPECIFIES
RECURSINVE EMULATION.
Only a finite recursion, as proven by direct execution and the
simulation by world-class simulators.
But HHH fails to reach the 'ret' instruction of DD. It is correct that
HHH reports its failure to complete the simulation.
HHH/DD recursive emulation
main/DD no recursive emulation
HHH1/DD no recursive emulation
On 3/7/2025 9:18 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 15:58 schreef olcott:
On 3/7/2025 2:26 AM, Mikko wrote:Indeed, HHH reports that it cannot possibly perform a complete
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:As "DD correctly emulated by HHH" does not exist
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it
reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>>
*No one has made any attempt to show that*
Maybe not. Perhaps every demonstration of that was just a byproduct of >>>> some other attempt. Anyway, HHH does not emulate DD correctly to the
end.
Simulating termination analyzer HHH simulates its input DD until HHH
correctly determines that DD cannot possibly reach its own "return"
instruction and terminate normally.
(correct) simulation of itself.
This is the only possible correct interpretation of the result of HHH.
Any other interpretation has no grounds.
No matter how many times you stupidly ignore the verified
fact that DD calls HHH(DD) in recursive emulation this does
not change the fact that DD cannot possibly reach its own
"ret" instruction because it calls HHH(DD) in recursive emulation.
On 3/7/2025 9:18 AM, Fred. Zwarts wrote:Only when HHH tries to simulate it, not DD by itself.
Op 07.mrt.2025 om 15:58 schreef olcott:
On 3/7/2025 2:26 AM, Mikko wrote:
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
No matter how many times you stupidly ignore the verified fact that DDIndeed, HHH reports that it cannot possibly perform a completeSimulating termination analyzer HHH simulates its input DD until HHHMaybe not. Perhaps every demonstration of that was just a byproduct*No one has made any attempt to show that**Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>> As "DD correctly emulated by HHH" does not existDD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>> instruction and terminate normally.The question whether DD emulated by HHH exists is too
The only valid rebuttal is to show all of the steps of exactly >>>>>>>>> how DD correctly emulated by HHH reaches its own "ret"
instruction.
uninteresting that it would need a rebuttal, and so is the
question that does it reach its "ret" instruction if it exsists. >>>>>>> DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally.
of some other attempt. Anyway, HHH does not emulate DD correctly to
the end.
correctly determines that DD cannot possibly reach its own "return"
instruction and terminate normally.
(correct)
simulation of itself.
This is the only possible correct interpretation of the result of HHH.
Any other interpretation has no grounds.
calls HHH(DD) in recursive emulation this does not change the fact that
DD cannot possibly reach its own "ret" instruction because it calls
HHH(DD) in recursive emulation.
On 3/7/2025 6:32 AM, Richard Damon wrote:
On 3/6/25 9:31 PM, olcott wrote:
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>> changing the code of HHH to an unconditional simulator and >>>>>>>>>> running
In other words, you know that what you're working on has >>>>>>>>>>>> nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>> QUIT THE
SHIT!
HHH(DD) will not halt.
In other words, replacing the code of HHH with an unconditional >>>>>>>> simulator and subsequently running HHH(DD) does not halt, which you >>>>>>>> previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot >>>>>>>> possibly
>>> terminate normally by reaching its own "return" instruction. >>>>>>>> >>
>> In other words, if the code of HHH is replaced with an
>> unconditional simulator then it can be shown that DD is
>> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>> different from replacing the code of Y with an unconditional
simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and
endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice.
Which really means you need to abandon your fraudulent methods
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No,
You could show the machine-address by machine-address
correct execution trace if i was wrong. You only
dodge this because you k ow that I am correct.
and your problem is still that you are trying to hold to you admitted
FRAUD.
Using ad hominem instead of reasoning makes you
look very foolish.
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:If you do not agree that HHH fails to reach the 'ret' instruction
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
In other words, you know that what you're working on has
nothing to do with the halting problem, but you don't care. >>>>>>>>>
You have proven that you know these things pretty well SO QUIT >>>>>>>>> THE SHIT!
You want people to accept that HHH(DD) does in fact report that >>>>>>>> changing the code of HHH to an unconditional simulator and
running HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction,
Despicably dishonest attempt at the straw-man deception.
No rebuttal. So, we agree that HHH fails to reach the 'ret'
instruction.
Not at all. Trying to get away with changing the subject
WILL NOT BE TOLERATED.
(that world-class simulators do reach, just as the direct execution
does), show how it reaches the 'ret' instruction.
*set X*
When-so-ever any input to any simulating termination
analyzer calls the simulator that is simulating itself
*result of set X*
this input cannot possibly reach its own final state
and terminate normally because it remains stuck in
recursive emulation.
*Ridiculously stupid dishonest fake rebuttal*
That members of different sets having different behavior
proves that inputs calling their own simulator must have
this same behavior.
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:If you do not agree that HHH fails to reach the 'ret' instruction
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION.
In other words, you know that what you're working on has
nothing to do with the halting problem, but you don't care. >>>>>>>>>
You have proven that you know these things pretty well SO QUIT >>>>>>>>> THE SHIT!
You want people to accept that HHH(DD) does in fact report that >>>>>>>> changing the code of HHH to an unconditional simulator and
running HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction,
Despicably dishonest attempt at the straw-man deception.
No rebuttal. So, we agree that HHH fails to reach the 'ret'
instruction.
Not at all. Trying to get away with changing the subject
WILL NOT BE TOLERATED.
(that world-class simulators do reach, just as the direct execution
does), show how it reaches the 'ret' instruction.
*set X*
When-so-ever any input to any simulating termination
analyzer calls the simulator that is simulating itself
*result of set X*
this input cannot possibly reach its own final state
and terminate normally because it remains stuck in
recursive emulation.
On 3/7/2025 10:35 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:34 schreef olcott:
On 3/7/2025 9:18 AM, Fred. Zwarts wrote:Why do you ignore the fact that that we agree that HHH fails to reach
Op 07.mrt.2025 om 15:58 schreef olcott:
On 3/7/2025 2:26 AM, Mikko wrote:Indeed, HHH reports that it cannot possibly perform a complete
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:As "DD correctly emulated by HHH" does not exist
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it >>>>>>>>>> reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>>>>
*No one has made any attempt to show that*
Maybe not. Perhaps every demonstration of that was just a
byproduct of
some other attempt. Anyway, HHH does not emulate DD correctly to
the end.
Simulating termination analyzer HHH simulates its input DD until
HHH correctly determines that DD cannot possibly reach its own
"return" instruction and terminate normally.
(correct) simulation of itself.
This is the only possible correct interpretation of the result of HHH. >>>> Any other interpretation has no grounds.
No matter how many times you stupidly ignore the verified
fact that DD calls HHH(DD) in recursive emulation this does
not change the fact that DD cannot possibly reach its own
"ret" instruction because it calls HHH(DD) in recursive emulation.
the 'ret' instruction after a finite recursion?
Agreeing is not a rebuttal.
We agree that HHH correctly reports that it cannot possibly reach the
'ret' instruction and that it aborted the simulation before the
simulation has been completed correctly.
A smart bot knows better than this.
https://www.researchgate.net/ publication/385090708_ChatGPT_Analyzes_Simulating_Termination_AnalyzerIrrelevant! Such smart bots can be trained by an idiot to say anything
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>> changing the code of HHH to an unconditional simulator and running >>>>>>>>>> HHH(DD) will not halt.
In other words, you know that what you're working on has nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>> You have proven that you know these things pretty well SO QUIT THE >>>>>>>>>>> SHIT!
In other words, replacing the code of HHH with an unconditional >>>>>>>> simulator and subsequently running HHH(DD) does not halt, which you >>>>>>>> previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot possibly
>>> terminate normally by reaching its own "return" instruction. >>>>>>>> >>
>> In other words, if the code of HHH is replaced with an
>> unconditional simulator then it can be shown that DD is
>> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>> different from replacing the code of Y with an unconditional simulator >>>>>>>> and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go >>>>>>> through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice.
Which really means you need to abandon your fraudulent methods
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches the
call to HHH:
1) It just follows the call and starts simulating the code of HHH. This
might eventually lead to infinite recursion. So, no correct simulation.
On 3/7/2025 9:33 AM, dbush wrote:
On 3/7/2025 10:30 AM, olcott wrote:
On 3/7/2025 9:15 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 15:49 schreef olcott:
On 3/7/2025 2:02 AM, joes wrote:Strawman. HHH fails to reach the 'ret' instruction, so HHH fails to
Am Thu, 06 Mar 2025 20:59:49 -0600 schrieb olcott:*Straw-man deception*
On 3/6/2025 6:37 PM, Richard Damon wrote:So what's the next step?
On 3/6/25 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott: >>>>>>>>>>>>>>>> On 3/5/2025 6:19 AM, Richard Damon wrote:
On 3/5/25 12:09 AM, olcott wrote:
*DD correctly emulated by HHH cannot possibly reach* >>>>>>>>>>>>>> *its own "ret" instruction and terminate normally* >>>>>>>>>>>>>> It has taken two years to create this first step such that >>>>>>>>>>>>>> it isWhat is the next step?"ret" instruction and terminate normally.I WILL NOT TOLERATE ANY OTHER ORDERIn other words, you CAN'T handle any other order, even >>>>>>>>>>>>>>>>> though
logically requried, because you need to hide your fraud. >>>>>>>>>>>>>>>> My proof requires a specific prerequisite order. >>>>>>>>>>>>>>>> One cannot learn algebra before one has learned to count to >>>>>>>>>>>>>>>> ten. DD correctly emulated by HHH cannot possibly reach >>>>>>>>>>>>>>>> its own
Is the first step of the mandatory prerequisite order of my >>>>>>>>>>>>>>>> proof
the the simplest way to state the key element of the whole >>>>>>>>>>>>>> proof
and make this element impossible to correctly refute. >>>>>>>>>>>>>> EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT IS >>>>>>>>>>>>>> DISHONEST.
Yes, that is the directly executed program.That is a stupid thing to say.Before agreeing on an answer, it is first required to agree >>>>>>>>>>>>> on theWhich is the problem, since you don't have the correct >>>>>>>>>>>> question.
question.
If HHH is a Halt Decider / Termination analyzer, the ONLY >>>>>>>>>>>> behavior
that matters is the behavior of the directly executed
program whose
description is provided.
HHH computes the mapping to a return value on the basis of >>>>>>>>>>> what its
finite string INPUT specifies.
No, HHH aborts.THIS IS WHAT IT SPECIFIES *DD correctly emulated by HHH cannot >>>>>>>>>>> possibly reach its own "ret" instruction and terminate normally* >>>>>> No, DD doesn't specify anything about what is to simulate it.
Yes, that is what HHH reports: I cannot complete theThe finite string of DD correctly emulated by HHH specifies
simulation up to
the end. No more, no less.
There are easier ways to make a program to report the failure >>>>>>>>>> of a
simulation.
recursive
emulation that cannot possibly reach its own "ret" instruction >>>>>>>>> BECAUSE
IT SPECIFIES RECURSINVE EMULATION.
But the HHH that decides are returns can't be that HHH, so the >>>>>>>> DD givenThat seems to be a little incoherent so I cannot tell what you are >>>>>>> saying yet you are at least attempting to use reasoning.
to that HHH doesn't call the correctly emulating HHH, so you whole >>>>>>>> argument is shown to be the fraud you have admitted to.
I am just saying what the actual x86 machine code actually specifies >>>>>>> therefore any rebuttal is necessarily incorrect.
And the actual code of DD specifies that it halts.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
do a compete simulation.
Simulating termination analyzer HHH
So you're saying it maps the halting function?
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/7/2025 6:32 AM, Richard Damon wrote:
On 3/6/25 9:31 PM, olcott wrote:
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>> changing the code of HHH to an unconditional simulator and running >>>>>>>>>> HHH(DD) will not halt.
In other words, you know that what you're working on has nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>> You have proven that you know these things pretty well SO QUIT THE >>>>>>>>>>> SHIT!
In other words, replacing the code of HHH with an unconditional >>>>>>>> simulator and subsequently running HHH(DD) does not halt, which you >>>>>>>> previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot possibly
>>> terminate normally by reaching its own "return" instruction. >>>>>>>> >>
>> In other words, if the code of HHH is replaced with an
>> unconditional simulator then it can be shown that DD is
>> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>> different from replacing the code of Y with an unconditional simulator >>>>>>>> and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go >>>>>>> through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice.
Which really means you need to abandon your fraudulent methods
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No,
You could show the machine-address by machine-address
correct execution trace if i was wrong. You only
dodge this because you k ow that I am correct.
and your problem is still that you are trying to hold to you admitted FRAUD.
Using ad hominem instead of reasoning makes you
look very foolish.
On 3/7/2025 2:22 AM, Mikko wrote:
On 2025-03-06 20:09:24 +0000, olcott said:
On 3/6/2025 1:49 AM, Mikko wrote:
On 2025-03-04 14:17:56 +0000, olcott said:
On 3/4/2025 3:14 AM, Fred. Zwarts wrote:
Op 04.mrt.2025 om 04:07 schreef olcott:
int DD() { int Halt_Status = HHH(DD); if (Halt_Status) HERE:I wonder why Olcott keeps repeating that HHH fails to reach the
goto HERE; return Halt_Status; }
_DD() [00002133] 55 push ebp ; housekeeping [00002134]
8bec mov ebp,esp ; housekeeping [00002136]
51 push ecx ; make space for local [00002137] >>>>>>> 6833210000 push 00002133 ; push DD [0000213c] e882f4ffff call
000015c3 ; call HHH(DD) [00002141] 83c404 add esp,+04 [00002144]
8945fc mov [ebp-04],eax [00002147] 837dfc00
cmp dword [ebp-04],+00 [0000214b] 7402 jz 0000214f [0000214d]
ebfe jmp 0000214d [0000214f] 8b45fc mov
eax,[ebp-04] [00002152] 8be5 mov esp,ebp [00002154]
5d pop ebp [00002155] c3 ret Size in bytes:
(0035) [00002155]
DD correctly emulated by HHH cannot possibly reach its own
"ret" instruction and terminate normally.
'ret' instruction, where the direct execution or world-class
simulators have no problem to reach the 'ret' instruction of
exactly the same finite string as input.
The only valid rebuttal is to show all of the steps of exactly how
DD correctly emulated by HHH reaches its own "ret" instruction.
Not true. A sufficient rebuttal is anything that makes a reader to
notice that you have not proven one (or more) of your claims.
A specific rebuttal of this specific claim
Requires a specific rebuttal of that claimDD correctly emulated by HHH cannot possibly reach its own
"ret" instruction and terminate normally.
The claim is vacuous as DD correctly emulated by HHH does not exist.
The code proves otherwise by providing the correct execution
trace of DD that no one has been able to show any mistake.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
On 3/7/2025 2:26 AM, Mikko wrote:
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too uninteresting that >>>>>> it would need a rebuttal, and so is the question that does it reach its >>>>>> "ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting*
As "DD correctly emulated by HHH" does not exist
*No one has made any attempt to show that*
Maybe not. Perhaps every demonstration of that was just a byproduct of
some other attempt. Anyway, HHH does not emulate DD correctly to the end.
Simulating termination analyzer HHH simulates its input DD until HHH correctly determines that DD cannot possibly reach its own "return" instruction and terminate normally.
On 3/7/2025 10:23 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:22 schreef olcott:
On 3/7/2025 3:09 AM, Fred. Zwarts wrote:rebuttal at all.
Op 06.mrt.2025 om 21:11 schreef olcott:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:As "DD correctly emulated by HHH" does not exist
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it
reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>>
*No one has made any attempt to show that*
There is no proof that it does exist.
Failing to understand this code is less than no rebuttal at all.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Failing to understand that no HHH can correctly simulate itself is no
Failing to understand that Fred. Zwarts is only
a not very bright bot is my mistake.
On 3/7/2025 8:23 PM, dbush wrote:It isn't claimed to be total. Have you tried running it on itself or
On 3/7/2025 9:19 PM, olcott wrote:
On 3/7/2025 7:52 PM, dbush wrote:
On 3/7/2025 8:49 PM, olcott wrote:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
Automated Termination Analysis of C Programs https://publications.rwth-aachen.de/record/972440/files/972440.pdfWe know termination analyzers don't exist because no algorithm existsI thought that you demonstrated knowledge of these things.Not an issue, since termination analyzers don't exist.*set X*If you do not agree that HHH fails to reach the 'ret' instructionNot at all. Trying to get away with changing the subject WILL NOT >>>>>>> BE TOLERATED.No rebuttal. So, we agree that HHH fails to reach the 'ret'Yes, we agree that HHH fails to reach the 'ret' instruction, >>>>>>>>> Despicably dishonest attempt at the straw-man deception.DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>> "ret" instruction and terminate normally.You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>>>> and running HHH(DD) will not halt.In other words, you know that what you're working on has >>>>>>>>>>>>>> nothing to do with the halting problem, but you don't care. >>>>>>>>>>>>> In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>> QUIT THE SHIT!
instruction.
(that world-class simulators do reach, just as the direct execution >>>>>> does), show how it reaches the 'ret' instruction.
When-so-ever any input to any simulating termination analyzer calls
the simulator that is simulating itself
Maybe I was wrong.
that maps the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
AProVE seems to be the leading authority on what you say DOES NOT EXIST
On 3/7/2025 8:44 PM, dbush wrote:AHA HAHAHA
On 3/7/2025 9:42 PM, olcott wrote:
On 3/7/2025 8:23 PM, dbush wrote:That you don't understand that termination analyzers and halt deciders
Yes I did grossly over-estimate you technical knowledge.
We know termination analyzers don't exist because no algorithm exists
that maps the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
Are you a mere troll then?
are stipulated to map the halting function is not a rebuttal.
In computer science, termination analysis is program analysis which
attempts attempts attempts attempts attempts to determine whether the evaluation of a given program halts for each input. https://en.wikipedia.org/wiki/Termination_analysis
I switched to the term {termination analyzer} because they are not
required to be infallible.
infallible or wrong is a stupid dichotomy.
On 3/7/2025 10:35 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:34 schreef olcott:
On 3/7/2025 9:18 AM, Fred. Zwarts wrote:Why do you ignore the fact that that we agree that HHH fails to reach
Op 07.mrt.2025 om 15:58 schreef olcott:
On 3/7/2025 2:26 AM, Mikko wrote:Indeed, HHH reports that it cannot possibly perform a complete
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:As "DD correctly emulated by HHH" does not exist
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it >>>>>>>>>> reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>>>>
*No one has made any attempt to show that*
Maybe not. Perhaps every demonstration of that was just a
byproduct of
some other attempt. Anyway, HHH does not emulate DD correctly to
the end.
Simulating termination analyzer HHH simulates its input DD until
HHH correctly determines that DD cannot possibly reach its own
"return" instruction and terminate normally.
(correct) simulation of itself.
This is the only possible correct interpretation of the result of HHH. >>>> Any other interpretation has no grounds.
No matter how many times you stupidly ignore the verified
fact that DD calls HHH(DD) in recursive emulation this does
not change the fact that DD cannot possibly reach its own
"ret" instruction because it calls HHH(DD) in recursive emulation.
the 'ret' instruction after a finite recursion?
Agreeing is not a rebuttal.
We agree that HHH correctly reports that it cannot possibly reach the
'ret' instruction and that it aborted the simulation before the
simulation has been completed correctly.
A smart bot knows better than this.
https://www.researchgate.net/ publication/385090708_ChatGPT_Analyzes_Simulating_Termination_Analyzer
On 3/8/2025 3:17 AM, joes wrote:Neither do they disprove the undecidability of halting.
Am Fri, 07 Mar 2025 21:40:56 -0600 schrieb olcott:Termination analyzers are not required to be infallible.
On 3/7/2025 8:23 PM, dbush wrote:It isn't claimed to be total. Have you tried running it on itself or on
On 3/7/2025 9:19 PM, olcott wrote:
On 3/7/2025 7:52 PM, dbush wrote:
On 3/7/2025 8:49 PM, olcott wrote:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
Automated Termination Analysis of C ProgramsWe know termination analyzers don't exist because no algorithm existsI thought that you demonstrated knowledge of these things.Not an issue, since termination analyzers don't exist.*set X*If you do not agree that HHH fails to reach the 'ret' instruction >>>>>>>> (that world-class simulators do reach, just as the directNot at all. Trying to get away with changing the subject WILL >>>>>>>>> NOT BE TOLERATED.No rebuttal. So, we agree that HHH fails to reach the 'ret' >>>>>>>>>> instruction.Yes, we agree that HHH fails to reach the 'ret' instruction, >>>>>>>>>>> Despicably dishonest attempt at the straw-man deception.DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "ret" instruction and terminate normally.You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>>>>>> and running HHH(DD) will not halt.In other words, you know that what you're working on has >>>>>>>>>>>>>>>> nothing to do with the halting problem, but you don't >>>>>>>>>>>>>>>> care.In other words I WILL NOT TOLERATE ANY BULLSHIT
DEFLECTION.
You have proven that you know these things pretty well SO >>>>>>>>>>>>>>> QUIT THE SHIT!
execution does), show how it reaches the 'ret' instruction.
When-so-ever any input to any simulating termination analyzer
calls the simulator that is simulating itself
Maybe I was wrong.
that maps the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
AProVE seems to be the leading authority on what you say DOES NOT
EXIST
a program similar to DD (instead of calling HHH, ...)?
On 3/8/2025 2:47 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 02:49 schreef olcott:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:If you do not agree that HHH fails to reach the 'ret' instruction
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>> QUIT THE SHIT!
In other words, you know that what you're working on has >>>>>>>>>>>> nothing to do with the halting problem, but you don't care. >>>>>>>>>>>
You want people to accept that HHH(DD) does in fact report >>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>> and running HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction,
Despicably dishonest attempt at the straw-man deception.
No rebuttal. So, we agree that HHH fails to reach the 'ret'
instruction.
Not at all. Trying to get away with changing the subject
WILL NOT BE TOLERATED.
(that world-class simulators do reach, just as the direct execution
does), show how it reaches the 'ret' instruction.
*set X*
When-so-ever any input to any simulating termination
analyzer calls the simulator that is simulating itself
*result of set X*
this input cannot possibly reach its own final state
and terminate normally because it remains stuck in
recursive emulation.
So, we agree that any simulator that tries to simulate *itself* cannot
possibly reach the end of its simulation.
Apparently you don't understand that inputs to a
simulating termination analyzer specifying infinite
recursion or recursive emulation cannot possibly
reach their own final state and terminate normally.
Why would we want to use such an analyser that reports that it fails
to complete the simulation?
Perhaps you incorrectly expect infinite loops to end?
On 3/8/2025 3:06 AM, Mikko wrote:Yes, even if there are error in the program, it does what it does.
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>>>> changing the code of HHH to an unconditional simulator and >>>>>>>>>>>> running
In other words, you know that what you're working on has >>>>>>>>>>>>>> nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>> QUIT THE
SHIT!
HHH(DD) will not halt.
In other words, replacing the code of HHH with an unconditional >>>>>>>>>> simulator and subsequently running HHH(DD) does not halt,
which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot >>>>>>>>>> possibly
>>> terminate normally by reaching its own "return"
instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>>>> different from replacing the code of Y with an unconditional >>>>>>>>>> simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and
endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches the
call to HHH:
1) It just follows the call and starts simulating the code of HHH.
This might eventually lead to infinite recursion. So, no correct
simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does.
On 3/8/2025 2:54 AM, Fred. Zwarts wrote:Did you read what I said, or are your responses from a random sentence selector?
Op 08.mrt.2025 om 02:09 schreef olcott:
On 3/7/2025 9:33 AM, dbush wrote:
On 3/7/2025 10:30 AM, olcott wrote:
On 3/7/2025 9:15 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 15:49 schreef olcott:
On 3/7/2025 2:02 AM, joes wrote:Strawman. HHH fails to reach the 'ret' instruction, so HHH fails
Am Thu, 06 Mar 2025 20:59:49 -0600 schrieb olcott:*Straw-man deception*
On 3/6/2025 6:37 PM, Richard Damon wrote:So what's the next step?
On 3/6/25 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>> On 3/5/2025 6:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 3/5/25 12:09 AM, olcott wrote:
*DD correctly emulated by HHH cannot possibly reach* >>>>>>>>>>>>>>>> *its own "ret" instruction and terminate normally* >>>>>>>>>>>>>>>> It has taken two years to create this first step such >>>>>>>>>>>>>>>> that it isWhat is the next step?ten. DD correctly emulated by HHH cannot possibly >>>>>>>>>>>>>>>>>> reach its ownI WILL NOT TOLERATE ANY OTHER ORDERIn other words, you CAN'T handle any other order, >>>>>>>>>>>>>>>>>>> even though
logically requried, because you need to hide your fraud. >>>>>>>>>>>>>>>>>> My proof requires a specific prerequisite order. >>>>>>>>>>>>>>>>>> One cannot learn algebra before one has learned to >>>>>>>>>>>>>>>>>> count to
"ret" instruction and terminate normally.
Is the first step of the mandatory prerequisite order >>>>>>>>>>>>>>>>>> of my
proof
the the simplest way to state the key element of the >>>>>>>>>>>>>>>> whole proof
and make this element impossible to correctly refute. >>>>>>>>>>>>>>>> EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS POINT IS >>>>>>>>>>>>>>>> DISHONEST.
Yes, that is the directly executed program.That is a stupid thing to say.Before agreeing on an answer, it is first required to >>>>>>>>>>>>>>> agree on theWhich is the problem, since you don't have the correct >>>>>>>>>>>>>> question.
question.
If HHH is a Halt Decider / Termination analyzer, the ONLY >>>>>>>>>>>>>> behavior
that matters is the behavior of the directly executed >>>>>>>>>>>>>> program whose
description is provided.
HHH computes the mapping to a return value on the basis of >>>>>>>>>>>>> what its
finite string INPUT specifies.
No, DD doesn't specify anything about what is to simulate it.THIS IS WHAT IT SPECIFIES *DD correctly emulated by HHH cannot >>>>>>>>>>>>> possibly reach its own "ret" instruction and terminate >>>>>>>>>>>>> normally*
No, HHH aborts.Yes, that is what HHH reports: I cannot complete theThe finite string of DD correctly emulated by HHH specifies >>>>>>>>>>> recursive
simulation up to
the end. No more, no less.
There are easier ways to make a program to report the
failure of a
simulation.
emulation that cannot possibly reach its own "ret"
instruction BECAUSE
IT SPECIFIES RECURSINVE EMULATION.
But the HHH that decides are returns can't be that HHH, so the >>>>>>>>>> DD givenThat seems to be a little incoherent so I cannot tell what you are >>>>>>>>> saying yet you are at least attempting to use reasoning.
to that HHH doesn't call the correctly emulating HHH, so you >>>>>>>>>> whole
argument is shown to be the fraud you have admitted to.
I am just saying what the actual x86 machine code actually
specifies
therefore any rebuttal is necessarily incorrect.
And the actual code of DD specifies that it halts.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
to do a compete simulation.
Simulating termination analyzer HHH
So you're saying it maps the halting function?
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Yes. And what is the advantage of a simulator HHH that reports that it
cannot possibly complete the simulation of a proven halting program up
to the end, because it gets stuck in simulating *itself*?
It is ridiculously stupid to expect a simulating
termination analyzer to continue to simulate an
input that specifies it cannot possibly reach its
own final state and terminate normally.
On 3/8/2025 2:59 AM, Fred. Zwarts wrote:Why do you need ChatGPT to prove that we agree?
Op 08.mrt.2025 om 02:57 schreef olcott:
On 3/7/2025 10:35 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:34 schreef olcott:
On 3/7/2025 9:18 AM, Fred. Zwarts wrote:Why do you ignore the fact that that we agree that HHH fails to
Op 07.mrt.2025 om 15:58 schreef olcott:
On 3/7/2025 2:26 AM, Mikko wrote:Indeed, HHH reports that it cannot possibly perform a complete
On 2025-03-06 20:11:34 +0000, olcott said:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally. >>>>>>>>>>>>>
The only valid rebuttal is to show all of the steps of >>>>>>>>>>>>> exactly how DD correctly emulated by HHH reaches its >>>>>>>>>>>>> own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does >>>>>>>>>>>> it reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non- >>>>>>>>>>> halting*
As "DD correctly emulated by HHH" does not exist
*No one has made any attempt to show that*
Maybe not. Perhaps every demonstration of that was just a
byproduct of
some other attempt. Anyway, HHH does not emulate DD correctly to >>>>>>>> the end.
Simulating termination analyzer HHH simulates its input DD until >>>>>>> HHH correctly determines that DD cannot possibly reach its own
"return" instruction and terminate normally.
(correct) simulation of itself.
This is the only possible correct interpretation of the result of
HHH.
Any other interpretation has no grounds.
No matter how many times you stupidly ignore the verified
fact that DD calls HHH(DD) in recursive emulation this does
not change the fact that DD cannot possibly reach its own
"ret" instruction because it calls HHH(DD) in recursive emulation.
reach the 'ret' instruction after a finite recursion?
Agreeing is not a rebuttal.
We agree that HHH correctly reports that it cannot possibly reach
the 'ret' instruction and that it aborted the simulation before the
simulation has been completed correctly.
A smart bot knows better than this.
Why do you have a problem with my agreement?
We agree that HHH correctly reports that it cannot possibly reach the
'ret' instruction and that it aborted the simulation before the
simulation has been completed correctly.
I only wonder what you are going to do with this result.
Irrelevant! Such smart bots can be trained by an idiot to say anything
https://www.researchgate.net/
publication/385090708_ChatGPT_Analyzes_Simulating_Termination_Analyzer
he likes.
ChagtGPT 100% totally understand my simplified proof in
its own words. It shows the details of the error of
any rebuttal.
On 3/8/2025 3:12 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 02:48 schreef olcott:
On 3/7/2025 10:23 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:22 schreef olcott:
On 3/7/2025 3:09 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:11 schreef olcott:
On 3/6/2025 2:02 AM, Mikko wrote:
On 2025-03-04 14:26:39 +0000, olcott said:
On 3/4/2025 4:36 AM, Mikko wrote:As "DD correctly emulated by HHH" does not exist
On 2025-03-04 03:07:56 +0000, olcott said:
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
The only valid rebuttal is to show all of the steps of
exactly how DD correctly emulated by HHH reaches its
own "ret" instruction.
The question whether DD emulated by HHH exists is too
uninteresting that
it would need a rebuttal, and so is the question that does it >>>>>>>>>> reach its
"ret" instruction if it exsists.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
*Proves that the input to HHH(DD) can be rejected as non-halting* >>>>>>>>
*No one has made any attempt to show that*
There is no proof that it does exist.
Failing to understand this code is less than no rebuttal at all.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Failing to understand that no HHH can correctly simulate itself is no >>>> rebuttal at all.
Failing to understand that Fred. Zwarts is only
a not very bright bot is my mistake.
Irrelevant. Again no rebuttal.
So, since there is no rebuttal after two reactions from Olcott, I
conclude that we agree that no HHH exists that correctly simulates
itself up to the end.
There is no end (reaching its final state) to the simulation
of non-terminating input dumb bunny.
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>>>> changing the code of HHH to an unconditional simulator and >>>>>>>>>>>> running
In other words, you know that what you're working on has >>>>>>>>>>>>>> nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>> QUIT THE
SHIT!
HHH(DD) will not halt.
In other words, replacing the code of HHH with an unconditional >>>>>>>>>> simulator and subsequently running HHH(DD) does not halt,
which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot >>>>>>>>>> possibly
>>> terminate normally by reaching its own "return"
instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>>>> different from replacing the code of Y with an unconditional >>>>>>>>>> simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and
endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches the
call to HHH:
1) It just follows the call and starts simulating the code of HHH.
This might eventually lead to infinite recursion. So, no correct
simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
On 3/8/2025 3:17 AM, joes wrote:
Am Fri, 07 Mar 2025 21:40:56 -0600 schrieb olcott:
On 3/7/2025 8:23 PM, dbush wrote:It isn't claimed to be total. Have you tried running it on itself or
On 3/7/2025 9:19 PM, olcott wrote:
On 3/7/2025 7:52 PM, dbush wrote:
On 3/7/2025 8:49 PM, olcott wrote:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
Automated Termination Analysis of C ProgramsWe know termination analyzers don't exist because no algorithm existsI thought that you demonstrated knowledge of these things.Not an issue, since termination analyzers don't exist.*set X*If you do not agree that HHH fails to reach the 'ret' instruction >>>>>>>> (that world-class simulators do reach, just as the direct execution >>>>>>>> does), show how it reaches the 'ret' instruction.Not at all. Trying to get away with changing the subject WILL NOT >>>>>>>>> BE TOLERATED.No rebuttal. So, we agree that HHH fails to reach the 'ret' >>>>>>>>>> instruction.Yes, we agree that HHH fails to reach the 'ret' instruction, >>>>>>>>>>> Despicably dishonest attempt at the straw-man deception.DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "ret" instruction and terminate normally.You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>>>>>> and running HHH(DD) will not halt.In other words, you know that what you're working on has >>>>>>>>>>>>>>>> nothing to do with the halting problem, but you don't care. >>>>>>>>>>>>>>> In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>>>> QUIT THE SHIT!
When-so-ever any input to any simulating termination analyzer calls >>>>>>> the simulator that is simulating itself
Maybe I was wrong.
that maps the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
AProVE seems to be the leading authority on what you say DOES NOT EXIST
on a program similar to DD (instead of calling HHH, ...)?
Termination analyzers are not required to be infallible.
On 3/8/2025 9:00 AM, dbush wrote:
On 3/8/2025 9:03 AM, olcott wrote:
Apparently you don't understand that inputs to a
simulating termination analyzer specifying infinite
recursion or recursive emulation cannot possibly
reach their own final state and terminate normally.
Apparently you don't understand that inputs to a termination analyzer,
simulating or otherwise, are specified by the specification that is
the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
And HHH(DD)==0 fails to meet the above specification
*THIS IS A SEMANTIC TAUTOLOGY THUS IMPOSSIBLY FALSE*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
It is ridiculously stupid to believe that HHH must
report on behavior other than the above behavior.
On 3/8/2025 5:01 PM, dbush wrote:
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
The code proves otherwise
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no >>>>>>>> different program exists.
The source code 100% perfectly proves exactly what it
actually does.
The source code contains a finite sequence of truth preserving
steps between axioms and a statement?
The source code 100% completely specifies every single detail
of exactly what it does on each specific input.
Saying that it does not do this is counter-factual.
In other words, the source code does not meet the definition of a
proof, so your claim is false.
Dumb Bunny:
*Proof[0] is anything that shows that X is necessarily true*
*and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH
conclusively proves every detail of the behavior of HHH on
this input. Disagreeing this is either foolish or dishonest.
A proof is a finite sequence of truth preserving steps between the
axioms of a system and a true statement that show the statement is true.
Proof[math] tries unsuccessfully to inherit from proof[0].
I am stipulating that I have always been referring to proof[0].
If you cannot understand the Halt7.c conclusively proves[0]
the actual behavior of HHH(DD) this is merely your lack of
understanding and nothing more.
On 3/8/2025 5:11 PM, Richard Damon wrote:
On 3/8/25 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>>>> that
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>>>> QUIT THE
In other words, you know that what you're working on has >>>>>>>>>>>>>>>> nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>
SHIT!
changing the code of HHH to an unconditional simulator and >>>>>>>>>>>>>> running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an unconditional >>>>>>>>>>>> simulator and subsequently running HHH(DD) does not halt, >>>>>>>>>>>> which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH >>>>>>>>>>>> cannot possibly
>>> terminate normally by reaching its own "return" >>>>>>>>>>>> instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>> >>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by >>>>>>>>>>>> Y is
different from replacing the code of Y with an unconditional >>>>>>>>>>>> simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and >>>>>>>>>>> endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches
the call to HHH:
1) It just follows the call and starts simulating the code of HHH. >>>>>> This might eventually lead to infinite recursion. So, no correct
simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
Which is that HHH will look at memory not defined to be part of its
input, and thus HHH is not the pure function you have agreed it must be.
THIS IS A SEMANTIC TAUTOLOGY AGREE OR STFU !!!
DD correctly emulated by HHH cannot possibly
reach its own final state and terminate normally.
On 3/8/2025 5:54 PM, dbush wrote:
On 3/8/2025 6:41 PM, olcott wrote:
On 3/8/2025 5:11 PM, Richard Damon wrote:
On 3/8/25 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:_DD()
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its >>>>>>>>>>>>>>> own "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact >>>>>>>>>>>>>>>> report that
In other words I WILL NOT TOLERATE ANY BULLSHIT >>>>>>>>>>>>>>>>> DEFLECTION.
In other words, you know that what you're working on >>>>>>>>>>>>>>>>>> has nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>>>
You have proven that you know these things pretty well >>>>>>>>>>>>>>>>> SO QUIT THE
SHIT!
changing the code of HHH to an unconditional simulator >>>>>>>>>>>>>>>> and running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an
unconditional
simulator and subsequently running HHH(DD) does not halt, >>>>>>>>>>>>>> which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH >>>>>>>>>>>>>> cannot possibly
>>> terminate normally by reaching its own "return" >>>>>>>>>>>>>> instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>>>> >>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated >>>>>>>>>>>>>> by Y is
different from replacing the code of Y with an
unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and >>>>>>>>>>>>> endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed >>>>>>>>>>> twice.
Which really means you need to abandon your fraudulent methods >>>>>>>>>
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches >>>>>>>> the call to HHH:
1) It just follows the call and starts simulating the code of
HHH. This might eventually lead to infinite recursion. So, no
correct simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no >>>>>> different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
Which is that HHH will look at memory not defined to be part of its
input, and thus HHH is not the pure function you have agreed it must
be.
THIS IS A SEMANTIC TAUTOLOGY AGREE OR STFU !!!
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly
reach its own final state and terminate normally.
Two people with masters degrees in computer science
agreed. Gaslighting me on this makes you look like
a complete nitwit.
I think everyone would agree, as you said, that if the code of HHH is
replaced with an unconditional simulator and HHH(DD) is run, that it
will not halt.
So now what?
We add the mandatory required details to your simplistic
idea such that additional elaboration from this full set
of details:
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
COMPLETES MY PROOF
On 3/8/2025 9:41 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:09 schreef olcott:
On 3/8/2025 3:06 AM, Mikko wrote:Yes, even if there are error in the program, it does what it does.
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>>>> that
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>>>> QUIT THE
In other words, you know that what you're working on has >>>>>>>>>>>>>>>> nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>
SHIT!
changing the code of HHH to an unconditional simulator and >>>>>>>>>>>>>> running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an unconditional >>>>>>>>>>>> simulator and subsequently running HHH(DD) does not halt, >>>>>>>>>>>> which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH >>>>>>>>>>>> cannot possibly
>>> terminate normally by reaching its own "return" >>>>>>>>>>>> instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>> >>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by >>>>>>>>>>>> Y is
different from replacing the code of Y with an unconditional >>>>>>>>>>>> simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and >>>>>>>>>>> endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches
the call to HHH:
1) It just follows the call and starts simulating the code of HHH. >>>>>> This might eventually lead to infinite recursion. So, no correct
simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does.
There is no error.
On 3/8/2025 9:24 PM, dbush wrote:
On 3/8/2025 10:20 PM, olcott wrote:
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
And when that code is not replaced HHH does a partial simulation of a
computation that halts, as demonstrated by DD halting when executed
directly.
That Straw-man deception looks ridiculously stupid
when I challenge you to provide the line-by-line
machine code addresses of DD correctly emulated by
HHH such that DD reaches its own "ret" instruction
and terminates normally.
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
On 3/8/2025 8:22 AM, joes wrote:
Am Sat, 08 Mar 2025 08:06:04 -0600 schrieb olcott:
On 3/8/2025 3:17 AM, joes wrote:Neither do they disprove the undecidability of halting.
Am Fri, 07 Mar 2025 21:40:56 -0600 schrieb olcott:Termination analyzers are not required to be infallible.
On 3/7/2025 8:23 PM, dbush wrote:It isn't claimed to be total. Have you tried running it on itself or on >>>> a program similar to DD (instead of calling HHH, ...)?
On 3/7/2025 9:19 PM, olcott wrote:
On 3/7/2025 7:52 PM, dbush wrote:
On 3/7/2025 8:49 PM, olcott wrote:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
Automated Termination Analysis of C ProgramsWe know termination analyzers don't exist because no algorithm exists >>>>>> that maps the halting function:I thought that you demonstrated knowledge of these things.Not an issue, since termination analyzers don't exist.When-so-ever any input to any simulating termination analyzer >>>>>>>>> calls the simulator that is simulating itselfIf you do not agree that HHH fails to reach the 'ret' instruction >>>>>>>>>> (that world-class simulators do reach, just as the directNot at all. Trying to get away with changing the subject WILL >>>>>>>>>>> NOT BE TOLERATED.Yes, we agree that HHH fails to reach the 'ret' instruction, >>>>>>>>>>>>> Despicably dishonest attempt at the straw-man deception. >>>>>>>>>>>> No rebuttal. So, we agree that HHH fails to reach the 'ret' >>>>>>>>>>>> instruction.DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>>>> "ret" instruction and terminate normally.You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>>>>>>>> and running HHH(DD) will not halt.In other words, you know that what you're working on has >>>>>>>>>>>>>>>>>> nothing to do with the halting problem, but you don't >>>>>>>>>>>>>>>>>> care.In other words I WILL NOT TOLERATE ANY BULLSHIT >>>>>>>>>>>>>>>>> DEFLECTION.
You have proven that you know these things pretty well SO >>>>>>>>>>>>>>>>> QUIT THE SHIT!
execution does), show how it reaches the 'ret' instruction. >>>>>>>>> *set X*
Maybe I was wrong.
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
https://publications.rwth-aachen.de/record/972440/files/972440.pdf
AProVE seems to be the leading authority on what you say DOES NOT
EXIST
The actual behavior that Halt7.c specifies combined with
the semantics of the x86 language conclusively proves:
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/8/2025 7:52 PM, dbush wrote:
On 3/8/2025 8:19 PM, olcott wrote:
On 3/8/2025 6:54 PM, dbush wrote:
On 3/8/2025 7:10 PM, olcott wrote:
On 3/8/2025 5:54 PM, dbush wrote:
On 3/8/2025 6:41 PM, olcott wrote:
On 3/8/2025 5:11 PM, Richard Damon wrote:
On 3/8/25 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach >>>>>>>>>>>>>>>>>>> its own "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact >>>>>>>>>>>>>>>>>>>> report that
In other words I WILL NOT TOLERATE ANY BULLSHIT >>>>>>>>>>>>>>>>>>>>> DEFLECTION.
In other words, you know that what you're working >>>>>>>>>>>>>>>>>>>>>> on has nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>>>>>>>
You have proven that you know these things pretty >>>>>>>>>>>>>>>>>>>>> well SO QUIT THE
SHIT!
changing the code of HHH to an unconditional >>>>>>>>>>>>>>>>>>>> simulator and running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an >>>>>>>>>>>>>>>>>> unconditional
simulator and subsequently running HHH(DD) does not >>>>>>>>>>>>>>>>>> halt, which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote: >>>>>>>>>>>>>>>>>> >>> The first point is DD correctly simulated by HHH >>>>>>>>>>>>>>>>>> cannot possibly
>>> terminate normally by reaching its own "return" >>>>>>>>>>>>>>>>>> instruction.
>>
>> In other words, if the code of HHH is replaced >>>>>>>>>>>>>>>>>> with an
>> unconditional simulator then it can be shown that >>>>>>>>>>>>>>>>>> DD is
>> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>>>>>>>> >>
> Wow finally someone that totally gets it. >>>>>>>>>>>>>>>>>>
If you disagree, explain why this is different. >>>>>>>>>>>>>>>>>> In particular, give an example where X correctly >>>>>>>>>>>>>>>>>> emulated by Y is
different from replacing the code of Y with an >>>>>>>>>>>>>>>>>> unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject >>>>>>>>>>>>>>>>> and endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process >>>>>>>>>>>>>>> failed twice.
Which really means you need to abandon your fraudulent >>>>>>>>>>>>>> methods
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally >>>>>>>>>>>>> because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH >>>>>>>>>>>> reaches the call to HHH:
1) It just follows the call and starts simulating the code >>>>>>>>>>>> of HHH. This might eventually lead to infinite recursion. >>>>>>>>>>>> So, no correct simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove >>>>>>>>>> that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
Which is that HHH will look at memory not defined to be part of >>>>>>>> its input, and thus HHH is not the pure function you have agreed >>>>>>>> it must be.
THIS IS A SEMANTIC TAUTOLOGY AGREE OR STFU !!!
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly
reach its own final state and terminate normally.
Two people with masters degrees in computer science
agreed. Gaslighting me on this makes you look like
a complete nitwit.
I think everyone would agree, as you said, that if the code of HHH >>>>>> is replaced with an unconditional simulator and HHH(DD) is run,
that it will not halt.
So now what?
We add the mandatory required details to your simplistic
idea such that additional elaboration from this full set
of details:
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Obviously. So now what?
You still don't understand that we get the same effect
whether we replace the code or not.
Right, because a partial (and therefore incorrect) simulation doesn't
prove anything.
So then what?
Thus a partial thus incomplete emulation of an
infinite loop cannot possibly determine that this
loop will not terminate.
On 3/8/2025 8:38 PM, dbush wrote:
On 3/8/2025 9:33 PM, olcott wrote:
On 3/8/2025 7:52 PM, dbush wrote:
On 3/8/2025 8:19 PM, olcott wrote:
On 3/8/2025 6:54 PM, dbush wrote:
On 3/8/2025 7:10 PM, olcott wrote:
On 3/8/2025 5:54 PM, dbush wrote:
On 3/8/2025 6:41 PM, olcott wrote:
On 3/8/2025 5:11 PM, Richard Damon wrote:
On 3/8/25 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:A program does not prove. In particular, it does not prove >>>>>>>>>>>> that no
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/5/2025 7:10 PM, dbush wrote: >>>>>>>>>>>>>>>>>>>>>>>>DD correctly emulated by HHH cannot possibly reach >>>>>>>>>>>>>>>>>>>>> its own "ret"
You want people to accept that HHH(DD) does in >>>>>>>>>>>>>>>>>>>>>> fact report thatIn other words, you know that what you're >>>>>>>>>>>>>>>>>>>>>>>> working on has nothing toIn other words I WILL NOT TOLERATE ANY BULLSHIT >>>>>>>>>>>>>>>>>>>>>>> DEFLECTION.
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>>>>>>>>>
You have proven that you know these things pretty >>>>>>>>>>>>>>>>>>>>>>> well SO QUIT THE
SHIT!
changing the code of HHH to an unconditional >>>>>>>>>>>>>>>>>>>>>> simulator and running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an >>>>>>>>>>>>>>>>>>>> unconditional
simulator and subsequently running HHH(DD) does not >>>>>>>>>>>>>>>>>>>> halt, which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote: >>>>>>>>>>>>>>>>>>>> >> On 2/22/2025 11:43 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>> >>> The first point is DD correctly simulated by >>>>>>>>>>>>>>>>>>>> HHH cannot possibly
>>> terminate normally by reaching its own >>>>>>>>>>>>>>>>>>>> "return" instruction.
>>
>> In other words, if the code of HHH is replaced >>>>>>>>>>>>>>>>>>>> with an
>> unconditional simulator then it can be shown >>>>>>>>>>>>>>>>>>>> that DD is
>> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>>>>>>>>>> >>
> Wow finally someone that totally gets it. >>>>>>>>>>>>>>>>>>>>
If you disagree, explain why this is different. >>>>>>>>>>>>>>>>>>>> In particular, give an example where X correctly >>>>>>>>>>>>>>>>>>>> emulated by Y is
different from replacing the code of Y with an >>>>>>>>>>>>>>>>>>>> unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject >>>>>>>>>>>>>>>>>>> and endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process >>>>>>>>>>>>>>>>> failed twice.
Which really means you need to abandon your fraudulent >>>>>>>>>>>>>>>> methods
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD) >>>>>>>>>>>>>>> [00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally >>>>>>>>>>>>>>> because DD calls HHH(DD) in recursive emulation. >>>>>>>>>>>>>>>
No such HHH exists.
The programmer of HHH has the following options when HHH >>>>>>>>>>>>>> reaches the call to HHH:
1) It just follows the call and starts simulating the code >>>>>>>>>>>>>> of HHH. This might eventually lead to infinite recursion. >>>>>>>>>>>>>> So, no correct simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
Which is that HHH will look at memory not defined to be part >>>>>>>>>> of its input, and thus HHH is not the pure function you have >>>>>>>>>> agreed it must be.
THIS IS A SEMANTIC TAUTOLOGY AGREE OR STFU !!!
Replacing the code of HHH with an unconditional simulator and >>>>>>>>> subsequently running HHH(DD) cannot possibly
reach its own final state and terminate normally.
Two people with masters degrees in computer science
agreed. Gaslighting me on this makes you look like
a complete nitwit.
I think everyone would agree, as you said, that if the code of >>>>>>>> HHH is replaced with an unconditional simulator and HHH(DD) is >>>>>>>> run, that it will not halt.
So now what?
We add the mandatory required details to your simplistic
idea such that additional elaboration from this full set
of details:
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Obviously. So now what?
You still don't understand that we get the same effect
whether we replace the code or not.
Right, because a partial (and therefore incorrect) simulation
doesn't prove anything.
So then what?
Thus a partial thus incomplete emulation of an
infinite loop cannot possibly determine that this
loop will not terminate.
It's a partial simulation of a halting computation, as demonstrated by
DD halting when executed directly.
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/8/2025 7:54 AM, Richard Damon wrote:
On 3/7/25 9:21 PM, olcott wrote:
On 3/7/2025 8:00 PM, Richard Damon wrote:
On 3/7/25 8:49 PM, olcott wrote:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:If you do not agree that HHH fails to reach the 'ret' instruction
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:Despicably dishonest attempt at the straw-man deception.
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>> QUIT THE SHIT!
In other words, you know that what you're working on has >>>>>>>>>>>>>> nothing to do with the halting problem, but you don't care. >>>>>>>>>>>>>
You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>>>> and running HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction, >>>>>>>>>
No rebuttal. So, we agree that HHH fails to reach the 'ret'
instruction.
Not at all. Trying to get away with changing the subject
WILL NOT BE TOLERATED.
(that world-class simulators do reach, just as the direct
execution does), show how it reaches the 'ret' instruction.
*set X*
When-so-ever any input to any simulating termination
analyzer calls the simulator that is simulating itself
*result of set X*
this input cannot possibly reach its own final state
and terminate normally because it remains stuck in
recursive emulation.
But the failure of the PARTIAL emulatipon done by the termination
analyzer doesn't show that the input is non-haltiong
That is stupidly wrong and you know it.
What is wrong with it?
A proof is anything and everything that shows a
statement is necessarily true and impossibly false.
The code 100% perfectly proves exactly what it does,
making any disagreements with what it does necessarily
incorrect.
Apparently you don't understand that inputs to a
simulating termination analyzer specifying infinite
recursion or recursive emulation cannot possibly
reach their own final state and terminate normally.
It is ridiculously stupid to expect a simulating
termination analyzer to continue to simulate an
input that specifies it cannot possibly reach its
own final state and terminate normally.
When anyone says that DD emulated by HHH according to
the semantics of the x86 language can possibly reach
its own"ret" instruction and terminate normally they are
conclusively proven wrong.
On 3/8/2025 4:58 PM, dbush wrote:
On 3/8/2025 5:42 PM, olcott wrote:
On 3/8/2025 9:00 AM, dbush wrote:
On 3/8/2025 9:03 AM, olcott wrote:
Apparently you don't understand that inputs to a
simulating termination analyzer specifying infinite
recursion or recursive emulation cannot possibly
reach their own final state and terminate normally.
Apparently you don't understand that inputs to a termination
analyzer, simulating or otherwise, are specified by the
specification that is the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
And HHH(DD)==0 fails to meet the above specification
*THIS IS A SEMANTIC TAUTOLOGY THUS IMPOSSIBLY FALSE*
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
It is ridiculously stupid to believe that HHH must
report on behavior other than the above behavior.
It must if it is to be classified as a halt decider or termination
analyzer as per the definition.
In other words you believe that HHH should just ignore the
fact that DD makes a call that prevents DD from ever reaching
its own final state? *THAT IS FREAKING MORONIC*
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>>>> changing the code of HHH to an unconditional simulator and running >>>>>>>>>>>> HHH(DD) will not halt.
In other words, you know that what you're working on has nothing to
do with the halting problem, but you don't care.
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>> You have proven that you know these things pretty well SO QUIT THE
SHIT!
In other words, replacing the code of HHH with an unconditional >>>>>>>>>> simulator and subsequently running HHH(DD) does not halt, which you >>>>>>>>>> previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot possibly
>>> terminate normally by reaching its own "return" instruction. >>>>>>>>>> >>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct.
>>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>>>> different from replacing the code of Y with an unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches the
call to HHH:
1) It just follows the call and starts simulating the code of HHH. This >>>> might eventually lead to infinite recursion. So, no correct simulation. >>>>
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
The code proves otherwise
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no >>>>>> different program exists.
The source code 100% perfectly proves exactly what it
actually does.
The source code contains a finite sequence of truth preserving steps
between axioms and a statement?
The source code 100% completely specifies every single detail
of exactly what it does on each specific input.
Saying that it does not do this is counter-factual.
In other words, the source code does not meet the definition of a
proof, so your claim is false.
Dumb Bunny:
*Proof[0] is anything that shows that X is necessarily true*
*and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH
conclusively proves every detail of the behavior of HHH on
this input. Disagreeing this is either foolish or dishonest.
On 3/8/2025 10:16 PM, dbush wrote:
On 3/8/2025 11:07 PM, olcott wrote:
On 3/8/2025 9:59 PM, dbush wrote:
On 3/8/2025 10:53 PM, olcott wrote:
On 3/8/2025 9:49 PM, dbush wrote:
On 3/8/2025 10:43 PM, olcott wrote:
On 3/8/2025 9:35 PM, dbush wrote:
Your copy-paste answer to multiple threads indicates you have no >>>>>>>> real rebuttal for what others have said.
*This is all you get from me until this point is fully addressed* >>>>>>>
<copy-paste response>
In other words, you have no rebuttal.
*This is all you get from me until this point is fully addressed*
*UNTIL YOU FULLY UNDERSTAND THIS YOU CAN'T POSSIBLY UNDERSTAND*
*THE NEXT STEP THAT ADDRESSES ALL OF THE OTHER ISSUES*
<copy-paste response>
Doesn't matter, as you've already accepted that your HHH isn't a
solution to the halting problem
*I never said that*
Yes you did, by making no attempt to explain otherwise:
*This is all you get from me until this point is fully addressed*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
On 3/8/2025 4:58 PM, dbush wrote:
On 3/8/2025 5:42 PM, olcott wrote:
On 3/8/2025 9:00 AM, dbush wrote:
On 3/8/2025 9:03 AM, olcott wrote:
Apparently you don't understand that inputs to a simulating
termination analyzer specifying infinite recursion or recursive
emulation cannot possibly reach their own final state and terminate
normally.
Apparently you don't understand that inputs to a termination
analyzer, simulating or otherwise, are specified by the specification
that is the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
And HHH(DD)==0 fails to meet the above specification
*THIS IS A SEMANTIC TAUTOLOGY THUS IMPOSSIBLY FALSE* Replacing the
code of HHH with an unconditional simulator and subsequently running
HHH(DD) cannot possibly reach its own "ret" instruction and terminate
normally because DD calls HHH(DD) in recursive emulation.
It must if it is to be classified as a halt decider or termination
analyzer as per the definition.
In other words you believe that HHH should just ignore the fact that DD
makes a call that prevents DD from ever reaching its own final state?
Neither HHH nor DD have any idea that DD calls its own emulator inNot reaching *the* final state (which undoubtedly exists) cannot be
recursive emulation.
None-the-less both HHH and anyone with sufficient technical competence
can see that DD correctly emulated by HHH cannot possibly reach its own
final state.
On 3/8/2025 9:46 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:03 schreef olcott:
On 3/8/2025 2:47 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 02:49 schreef olcott:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:If you do not agree that HHH fails to reach the 'ret' instruction
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:Despicably dishonest attempt at the straw-man deception.
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>> QUIT THE SHIT!
In other words, you know that what you're working on has >>>>>>>>>>>>>> nothing to do with the halting problem, but you don't care. >>>>>>>>>>>>>
You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>> that changing the code of HHH to an unconditional simulator >>>>>>>>>>>> and running HHH(DD) will not halt.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.
Yes, we agree that HHH fails to reach the 'ret' instruction, >>>>>>>>>
No rebuttal. So, we agree that HHH fails to reach the 'ret'
instruction.
Not at all. Trying to get away with changing the subject
WILL NOT BE TOLERATED.
(that world-class simulators do reach, just as the direct
execution does), show how it reaches the 'ret' instruction.
*set X*
When-so-ever any input to any simulating termination
analyzer calls the simulator that is simulating itself
*result of set X*
this input cannot possibly reach its own final state
and terminate normally because it remains stuck in
recursive emulation.
So, we agree that any simulator that tries to simulate *itself*
cannot possibly reach the end of its simulation.
Apparently you don't understand that inputs to a
simulating termination analyzer specifying infinite
recursion or recursive emulation cannot possibly
reach their own final state and terminate normally.
If we agree, what is the problem?
We agree that HHH correctly reports that it cannot possibly bring the
simulation of itself to a correct end.
Why would we want to use such an analyser that reports that it fails
to complete the simulation?
Perhaps you incorrectly expect infinite loops to end?
Wrong. I understand perfectly that HHH cannot possible reach the end
of the simulation of itself and it correctly reports that it could not
complete the simulation.
DD specifies non-termination.
On 3/8/2025 9:50 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:19 schreef olcott:
On 3/8/2025 2:54 AM, Fred. Zwarts wrote:Did you read what I said, or are your responses from a random sentence
Op 08.mrt.2025 om 02:09 schreef olcott:
On 3/7/2025 9:33 AM, dbush wrote:
On 3/7/2025 10:30 AM, olcott wrote:
On 3/7/2025 9:15 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 15:49 schreef olcott:
On 3/7/2025 2:02 AM, joes wrote:Strawman. HHH fails to reach the 'ret' instruction, so HHH fails >>>>>>>> to do a compete simulation.
Am Thu, 06 Mar 2025 20:59:49 -0600 schrieb olcott:*Straw-man deception*
On 3/6/2025 6:37 PM, Richard Damon wrote:So what's the next step?
On 3/6/25 3:16 PM, olcott wrote:
On 3/6/2025 3:17 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 05:46 schreef olcott:
On 3/5/2025 5:36 PM, Richard Damon wrote:
On 3/5/25 4:03 PM, dbush wrote:
On 3/5/2025 3:55 PM, olcott wrote:
On 3/5/2025 10:14 AM, joes wrote:
Am Wed, 05 Mar 2025 08:10:00 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>> On 3/5/2025 6:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 3/5/25 12:09 AM, olcott wrote:
*DD correctly emulated by HHH cannot possibly reach* >>>>>>>>>>>>>>>>>> *its own "ret" instruction and terminate normally* >>>>>>>>>>>>>>>>>> It has taken two years to create this first step such >>>>>>>>>>>>>>>>>> that it isWhat is the next step?My proof requires a specific prerequisite order. >>>>>>>>>>>>>>>>>>>> One cannot learn algebra before one has learned to >>>>>>>>>>>>>>>>>>>> count toI WILL NOT TOLERATE ANY OTHER ORDER >>>>>>>>>>>>>>>>>>>>> In other words, you CAN'T handle any other order, >>>>>>>>>>>>>>>>>>>>> even thoughlogically requried, because you need to hide your >>>>>>>>>>>>>>>>>>>>> fraud.
ten. DD correctly emulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> reach its own
"ret" instruction and terminate normally. >>>>>>>>>>>>>>>>>>>> Is the first step of the mandatory prerequisite >>>>>>>>>>>>>>>>>>>> order of my
proof
the the simplest way to state the key element of the >>>>>>>>>>>>>>>>>> whole proof
and make this element impossible to correctly refute. >>>>>>>>>>>>>>>>>> EVERY ATTEMPT TO CHANGE THE SUBJECT AWAY FROM THIS >>>>>>>>>>>>>>>>>> POINT IS
DISHONEST.
Yes, that is the directly executed program.That is a stupid thing to say.Before agreeing on an answer, it is first required to >>>>>>>>>>>>>>>>> agree on theWhich is the problem, since you don't have the correct >>>>>>>>>>>>>>>> question.
question.
If HHH is a Halt Decider / Termination analyzer, the >>>>>>>>>>>>>>>> ONLY behavior
that matters is the behavior of the directly executed >>>>>>>>>>>>>>>> program whose
description is provided.
HHH computes the mapping to a return value on the basis >>>>>>>>>>>>>>> of what its
finite string INPUT specifies.
No, DD doesn't specify anything about what is to simulate it. >>>>>>>>>>THIS IS WHAT IT SPECIFIES *DD correctly emulated by HHH >>>>>>>>>>>>>>> cannot
possibly reach its own "ret" instruction and terminate >>>>>>>>>>>>>>> normally*
No, HHH aborts.Yes, that is what HHH reports: I cannot complete the >>>>>>>>>>>>>> simulation up toThe finite string of DD correctly emulated by HHH specifies >>>>>>>>>>>>> recursive
the end. No more, no less.
There are easier ways to make a program to report the >>>>>>>>>>>>>> failure of a
simulation.
emulation that cannot possibly reach its own "ret"
instruction BECAUSE
IT SPECIFIES RECURSINVE EMULATION.
But the HHH that decides are returns can't be that HHH, so >>>>>>>>>>>> the DD givensaying yet you are at least attempting to use reasoning. >>>>>>>>>>> I am just saying what the actual x86 machine code actually >>>>>>>>>>> specifies
to that HHH doesn't call the correctly emulating HHH, so you >>>>>>>>>>>> whole
argument is shown to be the fraud you have admitted to. >>>>>>>>>>> That seems to be a little incoherent so I cannot tell what >>>>>>>>>>> you are
therefore any rebuttal is necessarily incorrect.
And the actual code of DD specifies that it halts.
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Simulating termination analyzer HHH
So you're saying it maps the halting function?
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Yes. And what is the advantage of a simulator HHH that reports that
it cannot possibly complete the simulation of a proven halting
program up to the end, because it gets stuck in simulating *itself*?
It is ridiculously stupid to expect a simulating
termination analyzer to continue to simulate an
input that specifies it cannot possibly reach its
own final state and terminate normally.
selector?
If we agree, what is the problem?
DD emulated by HHH proves that IT DOES NOT HALT
DD emulated by HHH proves that IT DOES NOT HALT
DD emulated by HHH proves that IT DOES NOT HALT
DD emulated by HHH proves that IT DOES NOT HALT
DD emulated by HHH proves that IT DOES NOT HALT
DD emulated by HHH proves that IT DOES NOT HALT
DD emulated by HHH proves that IT DOES NOT HALT
On 3/8/2025 9:46 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:03 schreef olcott:
On 3/8/2025 2:47 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 02:49 schreef olcott:
On 3/7/2025 10:25 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 16:17 schreef olcott:
On 3/7/2025 2:59 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 21:13 schreef olcott:
On 3/6/2025 3:13 AM, Fred. Zwarts wrote:
Op 06.mrt.2025 om 04:53 schreef olcott:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:
On 3/5/2025 7:10 PM, dbush wrote:
Apparently you don't understand that inputs to a simulatingIf we agree, what is the problem?
termination analyzer specifying infinite recursion or recursive
emulation cannot possibly reach their own final state and terminate
normally.
We agree that HHH correctly reports that it cannot possibly bring the
simulation of itself to a correct end.
Now that is just wrong.DD specifies non-termination.Wrong. I understand perfectly that HHH cannot possible reach the end ofWhy would we want to use such an analyser that reports that it failsPerhaps you incorrectly expect infinite loops to end?
to complete the simulation?
the simulation of itself and it correctly reports that it could not
complete the simulation.
On 3/8/2025 10:32 PM, dbush wrote:In other words, you realise you're twisting meanings?
On 3/8/2025 11:25 PM, olcott wrote:Erasing and replacing my words with your words is a real scumbag move.
On 3/8/2025 10:16 PM, dbush wrote:In other words, HHH fails to meet the requirement to be classified as a
On 3/8/2025 11:07 PM, olcott wrote:*This is all you get from me until this point is fully addressed*
On 3/8/2025 9:59 PM, dbush wrote:Yes you did, by making no attempt to explain otherwise:
On 3/8/2025 10:53 PM, olcott wrote:*I never said that*
On 3/8/2025 9:49 PM, dbush wrote:Doesn't matter, as you've already accepted that your HHH isn't a
On 3/8/2025 10:43 PM, olcott wrote:
On 3/8/2025 9:35 PM, dbush wrote:In other words, you have no rebuttal.
*This is all you get from me until this point is fully
Your copy-paste answer to multiple threads indicates you have >>>>>>>>>> no real rebuttal for what others have said.
addressed*
<copy-paste response>
*This is all you get from me until this point is fully addressed* >>>>>>> *UNTIL YOU FULLY UNDERSTAND THIS YOU CAN'T POSSIBLY UNDERSTAND*
*THE NEXT STEP THAT ADDRESSES ALL OF THE OTHER ISSUES*
<copy-paste response>
solution to the halting problem
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach its own "ret"
instruction and terminate normally because DD calls HHH(DD) in
recursive emulation.
solution to the halting problem, as you have already admitted.
On 3/8/2025 9:49 PM, dbush wrote:What is the next step?
On 3/8/2025 10:43 PM, olcott wrote:
On 3/8/2025 9:35 PM, dbush wrote:In other words, you have no rebuttal.
*This is all you get from me until this point is fully addressed*
Your copy-paste answer to multiple threads indicates you have no real
rebuttal for what others have said.
<copy-paste response>
*This is all you get from me until this point is fully addressed*
*UNTIL YOU FULLY UNDERSTAND THIS YOU CAN'T POSSIBLY UNDERSTAND* *THE
NEXT STEP THAT ADDRESSES ALL OF THE OTHER ISSUES*
On 3/8/2025 9:24 PM, dbush wrote:
On 3/8/2025 10:20 PM, olcott wrote:
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG* Replacing the
code of HHH with an unconditional simulator and subsequently running
HHH(DD) cannot possibly reach its own "ret" instruction and terminate
normally because DD calls HHH(DD) in recursive emulation.
That's the thing, HHH can't do it.And when that code is not replaced HHH does a partial simulation of aThat Straw-man deception looks ridiculously stupid when I challenge you
computation that halts, as demonstrated by DD halting when executed
directly.
to provide the line-by-line machine code addresses of DD correctly
emulated by HHH such that DD reaches its own "ret" instruction and
terminates normally.
On 3/8/2025 7:43 PM, dbush wrote:Such as your HHH simulating not itself, but *what it would do if it
On 3/8/2025 8:24 PM, olcott wrote:
On 3/8/2025 6:56 PM, dbush wrote:In other words, you have no rebuttal to the fact that HHH doesn't meet
On 3/8/2025 7:29 PM, olcott wrote:In the same way that Sum(5,3) == 9 That is misconception is very
On 3/8/2025 5:31 PM, dbush wrote:
On 3/8/2025 6:23 PM, olcott wrote:HHH must map from the input finite string DD to the behavior that
On 3/8/2025 4:58 PM, dbush wrote:
On 3/8/2025 5:42 PM, olcott wrote:
On 3/8/2025 9:00 AM, dbush wrote:It must if it is to be classified as a halt decider or
On 3/8/2025 9:03 AM, olcott wrote:
Apparently you don't understand that inputs to a simulating >>>>>>>>>>> termination analyzer specifying infinite recursion or
recursive emulation cannot possibly reach their own final >>>>>>>>>>> state and terminate normally.
Apparently you don't understand that inputs to a termination >>>>>>>>>> analyzer, simulating or otherwise, are specified by the
specification that is the halting function:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed
directly (<X>,Y) maps to 0 if and only if X(Y) does not halt >>>>>>>>>> when executed
And HHH(DD)==0 fails to meet the above specification
*THIS IS A SEMANTIC TAUTOLOGY THUS IMPOSSIBLY FALSE* Replacing >>>>>>>>> the code of HHH with an unconditional simulator and subsequently >>>>>>>>> running HHH(DD) cannot possibly reach its own "ret" instruction >>>>>>>>> and terminate normally because DD calls HHH(DD) in recursive >>>>>>>>> emulation.
It is ridiculously stupid to believe that HHH must report on >>>>>>>>> behavior other than the above behavior.
termination analyzer as per the definition.
In other words you believe that HHH
Is required to map the halting function to meet the requirements to >>>>>> be a halt decider / termination analyzer.
this finite string specifies
And what it specifies, to be considered a solution to the halting
problem, is given by the specification:
Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
widely held does not make it not a misconception.
the requirements to be a solution to the halting problem.
If the halting problem actually requires that the "decider"
report on behavior other than what the input specifies then its notion
of a halting decider is not even a decider in computer science.
On 3/8/2025 5:12 PM, Richard Damon wrote:
On 3/8/25 9:37 AM, olcott wrote:
On 3/8/2025 3:07 AM, Mikko wrote:
On 2025-03-07 15:28:38 +0000, olcott said:
On 3/7/2025 6:32 AM, Richard Damon wrote:
On 3/6/25 9:31 PM, olcott wrote:
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
You could show the machine-address by machine-address correctDD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>> instruction and terminate normally because DD calls HHH(DD) inNo,
recursive emulation.
execution trace if i was wrong. You only dodge this because you k ow >>>>> that I am correct.
heheUsing ad hominem instead of reasoning makes you look very foolish.No ad hominem above.
Exactly, and HHH is really not simulating itself but rather DD's call toHHH(DD) is not equivalent to HHH1(DD) and you know that you are lyingPersistently falling go show the line-by-line execution trace of theThe line-by-line emulation of the equivalemt program has been posted,
correct emulation that would prove that the emulation by HHH is
incorrect
BECAUSE YOU ALREADY KNOW THAT THE EXECUTION TRACE BY HHH IS CORRECT!!!
and was even posted by you.
about this because you know that with HHH(DD) DD calls its own emulator
in recursive emulation and with HHH1(DD) DD DOES NOT CALL HHH1.
On 3/8/2025 6:54 PM, dbush wrote:
On 3/8/2025 7:10 PM, olcott wrote:
On 3/8/2025 5:54 PM, dbush wrote:
On 3/8/2025 6:41 PM, olcott wrote:
On 3/8/2025 5:11 PM, Richard Damon wrote:
On 3/8/25 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:
The code proves otherwiseDD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>> "ret" instruction and terminate normally because DD calls >>>>>>>>>>> HHH(DD) in recursive emulation.No such HHH exists.
The programmer of HHH has the following options when HHH
reaches the call to HHH:
1) It just follows the call and starts simulating the code of >>>>>>>>>> HHH. This might eventually lead to infinite recursion. So, no >>>>>>>>>> correct simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Why change the input though?THIS IS A SEMANTIC TAUTOLOGY AGREE OR STFU !!!Which is that HHH will look at memory not defined to be part of its >>>>>> input, and thus HHH is not the pure function you have agreed itA program does not prove. In particular, it does not prove that >>>>>>>> no different program exists.The source code 100% perfectly proves exactly what it actually
does. Whenever anyone disagrees with what it actually does (as
most people here have tried to get away with) they are necessarily >>>>>>> incorrect.
must be.
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach its own final
state and terminate normally.
That's not true. HHH and HHH1 behave differently.Obviously. So now what?We add the mandatory required details to your simplistic idea suchTwo people with masters degrees in computer science agreed.I think everyone would agree, as you said, that if the code of HHH is
Gaslighting me on this makes you look like a complete nitwit.
replaced with an unconditional simulator and HHH(DD) is run, that it
will not halt. So now what?
that additional elaboration from this full set of details:
Replacing the code of HHH with an unconditional simulator and
subsequently running HHH(DD) cannot possibly reach its own "ret"
instruction and terminate normally because DD calls HHH(DD) in
recursive emulation.
You still don't understand that we get the same effect whether we
replace the code or not.
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:41 PM, olcott wrote:
On 3/8/2025 5:11 PM, Richard Damon wrote:
On 3/8/25 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:_DD()
On 3/6/2025 3:20 AM, joes wrote:
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its >>>>>>>>>>>>>>> own "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact >>>>>>>>>>>>>>>> report that
In other words I WILL NOT TOLERATE ANY BULLSHIT >>>>>>>>>>>>>>>>> DEFLECTION.
In other words, you know that what you're working on >>>>>>>>>>>>>>>>>> has nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>>>
You have proven that you know these things pretty well >>>>>>>>>>>>>>>>> SO QUIT THE
SHIT!
changing the code of HHH to an unconditional simulator >>>>>>>>>>>>>>>> and running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an
unconditional
simulator and subsequently running HHH(DD) does not halt, >>>>>>>>>>>>>> which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH >>>>>>>>>>>>>> cannot possibly
>>> terminate normally by reaching its own "return" >>>>>>>>>>>>>> instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>>>> >>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated >>>>>>>>>>>>>> by Y is
different from replacing the code of Y with an
unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and >>>>>>>>>>>>> endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed >>>>>>>>>>> twice.
Which really means you need to abandon your fraudulent methods >>>>>>>>>
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches >>>>>>>> the call to HHH:
1) It just follows the call and starts simulating the code of
HHH. This might eventually lead to infinite recursion. So, no
correct simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no >>>>>> different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
Which is that HHH will look at memory not defined to be part of its
input, and thus HHH is not the pure function you have agreed it must
be.
THIS IS A SEMANTIC TAUTOLOGY AGREE OR STFU !!!
DD correctly emulated by HHH cannot possibly
reach its own final state and terminate normally.
Right, but that "TAUTOLOGY" also is about an HHH that isn't the one
that we have in the problem,
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
and thus isn't actually a real tautology, but a fictional one.
You have no clue that semantic tautology is any
expression of language that proves itself completely
true and thus impossibly false entirely on the basis
of its meaning.
On 3/9/2025 9:28 AM, dbush wrote:Oh really? I do understand what you mean. What's next? Or do you have
On 3/9/2025 10:26 AM, olcott wrote:
On 3/9/2025 9:11 AM, dbush wrote:
On 3/9/2025 10:08 AM, olcott wrote:
On 3/9/2025 8:50 AM, dbush wrote:
You cannot possibly understand anything that I say about that until youIn other words, you're disagreeing with a stipulative definition.When we assume that HHH emulates N steps of DD thenIt is stipulated that a solution to the halting problem perform the
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
*because DD calls HHH(DD) in recursive emulation*
I am not going to address any other point until this point is fully
understood because the other points cannot possibly be understood
until this one is totally understood.
Whether or not and how it applies to the Halting Theorem cannot
possibly be understood at all until after the above words are 100%
totally and perfectly understood.
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
If you went to play head games you can play by yourself.
As you yourself said:
after you first understand this:
[spam]
On 3/9/2025 10:48 AM, joes wrote:
Am Sun, 09 Mar 2025 09:37:12 -0500 schrieb olcott:
On 3/9/2025 9:28 AM, dbush wrote:Oh really? I do understand what you mean. What's next? Or do you have
On 3/9/2025 10:26 AM, olcott wrote:
On 3/9/2025 9:11 AM, dbush wrote:
On 3/9/2025 10:08 AM, olcott wrote:
On 3/9/2025 8:50 AM, dbush wrote:
You cannot possibly understand anything that I say about that until youIn other words, you're disagreeing with a stipulative definition.When we assume that HHH emulates N steps of DD thenIt is stipulated that a solution to the halting problem perform the >>>>>> following mapping:
*DD correctly emulated by HHH cannot possibly reach*
*its own "ret" instruction and terminate normally*
*because DD calls HHH(DD) in recursive emulation*
I am not going to address any other point until this point is fully >>>>>>> understood because the other points cannot possibly be understood >>>>>>> until this one is totally understood.
Whether or not and how it applies to the Halting Theorem cannot
possibly be understood at all until after the above words are 100% >>>>>>> totally and perfectly understood.
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly
If you went to play head games you can play by yourself.
As you yourself said:
after you first understand this:
[spam]
nothing?
If you totally understood what I mean you would
not have given me such a hard time about it.
When we assume that HHH emulates N steps of DD then
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
If you do not agree that HHH it correct to reject
DD as non-terminating then you do not understand.
On 3/9/2025 2:24 PM, Richard Damon wrote:
On 3/9/25 9:25 AM, olcott wrote:
On 3/9/2025 6:17 AM, Richard Damon wrote:
On 3/8/25 10:24 PM, olcott wrote:
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:30 PM, olcott wrote:
On 3/8/2025 5:01 PM, dbush wrote:
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
The code proves otherwiseA program does not prove. In particular, it does not prove >>>>>>>>>>>>>> that no
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>
different program exists.
The source code 100% perfectly proves exactly what it >>>>>>>>>>>>> actually does.
The source code contains a finite sequence of truth
preserving steps between axioms and a statement?
The source code 100% completely specifies every single detail >>>>>>>>>>> of exactly what it does on each specific input.
Saying that it does not do this is counter-factual.
In other words, the source code does not meet the definition >>>>>>>>>> of a proof, so your claim is false.
Dumb Bunny:
*Proof[0] is anything that shows that X is necessarily true* >>>>>>>>> *and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH
conclusively proves every detail of the behavior of HHH on
this input. Disagreeing this is either foolish or dishonest. >>>>>>>>>
A proof is a finite sequence of truth preserving steps between >>>>>>>> the axioms of a system and a true statement that show the
statement is true.
Proof[math] tries unsuccessfully to inherit from proof[0].
I am stipulating that I have always been referring to proof[0].
And I am pointing out that it IS the same, it is just that you
don't understand that "Show" implies FINITE.
In that single aspect you are correct.
Show that X is definitely true and thus impossibly false
by any means what-so-ever is not proof[math].
or proof[0], since you can not SHOW something "by any means" if
those means are not showable due to not being finite.
You are just proving your stupidity by repeating your disproved
claim.
If you cannot understand the Halt7.c conclusively proves[0]
the actual behavior of HHH(DD) this is merely your lack of
understanding and nothing more.
Sure I can understand what it does, as Halt7.c shows that the
behavior of the input is to HALT since that is what DD will do
when main calls it.
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
But The HHH You are talking about doesn't do a correct simulation,
so this statment is not applicable.
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
WHich is *NOT* a program, as it has an external reference.
*When we assume that HHH emulates N steps of DD then*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Wrong, because emulaiting for "N Steps" is NOT correctly emulation.
Correctly emulating N steps is emulating N steps correctly.
Everyone here that has sufficient technical competence can
see that for any N steps of DD correctly emulated by HHH
that DD cannot possibly reach its own final state and
terminate normally.
On 3/9/2025 4:43 PM, Richard Damon wrote:
On 3/9/25 3:36 PM, olcott wrote:
On 3/9/2025 2:24 PM, Richard Damon wrote:
On 3/9/25 9:25 AM, olcott wrote:
On 3/9/2025 6:17 AM, Richard Damon wrote:
On 3/8/25 10:24 PM, olcott wrote:
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:30 PM, olcott wrote:
On 3/8/2025 5:01 PM, dbush wrote:And I am pointing out that it IS the same, it is just that you >>>>>>>> don't understand that "Show" implies FINITE.
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
The code proves otherwiseA program does not prove. In particular, it does not >>>>>>>>>>>>>>>> prove that no
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>>
different program exists.
The source code 100% perfectly proves exactly what it >>>>>>>>>>>>>>> actually does.
The source code contains a finite sequence of truth >>>>>>>>>>>>>> preserving steps between axioms and a statement?
The source code 100% completely specifies every single detail >>>>>>>>>>>>> of exactly what it does on each specific input.
Saying that it does not do this is counter-factual.
In other words, the source code does not meet the definition >>>>>>>>>>>> of a proof, so your claim is false.
Dumb Bunny:
*Proof[0] is anything that shows that X is necessarily true* >>>>>>>>>>> *and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH >>>>>>>>>>> conclusively proves every detail of the behavior of HHH on >>>>>>>>>>> this input. Disagreeing this is either foolish or dishonest. >>>>>>>>>>>
A proof is a finite sequence of truth preserving steps between >>>>>>>>>> the axioms of a system and a true statement that show the
statement is true.
Proof[math] tries unsuccessfully to inherit from proof[0].
I am stipulating that I have always been referring to proof[0]. >>>>>>>>
In that single aspect you are correct.
Show that X is definitely true and thus impossibly false
by any means what-so-ever is not proof[math].
or proof[0], since you can not SHOW something "by any means" if
those means are not showable due to not being finite.
You are just proving your stupidity by repeating your disproved >>>>>>>> claim.
If you cannot understand the Halt7.c conclusively proves[0]
the actual behavior of HHH(DD) this is merely your lack of
understanding and nothing more.
Sure I can understand what it does, as Halt7.c shows that the
behavior of the input is to HALT since that is what DD will do >>>>>>>> when main calls it.
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
But The HHH You are talking about doesn't do a correct simulation, >>>>>> so this statment is not applicable.
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
WHich is *NOT* a program, as it has an external reference.
*When we assume that HHH emulates N steps of DD then*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Wrong, because emulaiting for "N Steps" is NOT correctly emulation.
Correctly emulating N steps is emulating N steps correctly.
Which is only partially emulating it correctly, and only partially
correct is incorrect.
Everyone here that has sufficient technical competence can
see that for any N steps of DD correctly emulated by HHH
that DD cannot possibly reach its own final state and
terminate normally.
So? As has been pointed out, since HHH can't do enough steps to get to
the actual answer, it never CORRECTLY emulated the input enough to get
the answer if it aborts.
If HHH can see the same pattern that every competent
programmer sees then HHH does not need to emulate DD
more than twice to know that HHH cannot possibly reach
its own final state and terminate normally.
On 3/9/2025 4:36 AM, Mikko wrote:
On 2025-03-08 14:09:58 +0000, olcott said:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>>>> instruction and terminate normally.
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report that >>>>>>>>>>>>>> changing the code of HHH to an unconditional simulator and running
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>>>> You have proven that you know these things pretty well SO QUIT THE
In other words, you know that what you're working on has nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>
SHIT!
HHH(DD) will not halt.
In other words, replacing the code of HHH with an unconditional >>>>>>>>>>>> simulator and subsequently running HHH(DD) does not halt, which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH cannot possibly
>>> terminate normally by reaching its own "return" instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>> >>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by Y is >>>>>>>>>>>> different from replacing the code of Y with an unconditional simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches the >>>>>> call to HHH:
1) It just follows the call and starts simulating the code of HHH. This >>>>>> might eventually lead to infinite recursion. So, no correct simulation. >>>>>>
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
No, it does not. It does not even specify any claim. It only specifies
a behavior, and much of it only inplicitly. A proof ends with the
sentence that is proven but the source code does not. Unless you only
want to clalim tnat }.
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
When we assume that HHH emulates N steps of DD then
On 3/9/2025 4:05 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 18:47 schreef olcott:
On 3/8/2025 9:41 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:09 schreef olcott:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Yes, even if there are error in the program, it does what it does.
The source code 100% perfectly proves exactly what it
actually does.
There is no error.
That is a claim, not a proof. Many errors have been pointed out, but
the program was not corrected. Without a proof of correctness, a
program does not prove anything.
All the reported "errors" are only your failure to understand the code.
On 3/9/2025 4:36 AM, Mikko wrote:
On 2025-03-08 14:09:58 +0000, olcott said:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
On 3/7/2025 2:58 AM, Fred. Zwarts wrote:
Op 07.mrt.2025 om 03:31 schreef olcott:The code proves otherwise
On 3/6/2025 6:37 PM, Richard Damon wrote:
On 3/6/25 3:18 PM, olcott wrote:
On 3/6/2025 3:20 AM, joes wrote:Which really means you need to abandon your fraudulent methods
Am Wed, 05 Mar 2025 22:03:39 -0600 schrieb olcott:
On 3/5/2025 9:57 PM, dbush wrote:
On 3/5/2025 10:53 PM, olcott wrote:
On 3/5/2025 9:31 PM, dbush wrote:
On 3/5/2025 10:17 PM, olcott wrote:DD correctly emulated by HHH cannot possibly reach its own >>>>>>>>>>>>> "ret"
On 3/5/2025 7:10 PM, dbush wrote:You want people to accept that HHH(DD) does in fact report >>>>>>>>>>>>>> that
In other words I WILL NOT TOLERATE ANY BULLSHIT DEFLECTION. >>>>>>>>>>>>>>> You have proven that you know these things pretty well SO >>>>>>>>>>>>>>> QUIT THE
In other words, you know that what you're working on has >>>>>>>>>>>>>>>> nothing to
do with the halting problem, but you don't care. >>>>>>>>>>>>>>>
SHIT!
changing the code of HHH to an unconditional simulator and >>>>>>>>>>>>>> running
HHH(DD) will not halt.
instruction and terminate normally.
In other words, replacing the code of HHH with an unconditional >>>>>>>>>>>> simulator and subsequently running HHH(DD) does not halt, >>>>>>>>>>>> which you
previously agreed is correct:
On 2/22/2025 1:02 PM, olcott wrote:
> On 2/22/2025 11:10 AM, dbush wrote:
>> On 2/22/2025 11:43 AM, olcott wrote:
>>> The first point is DD correctly simulated by HHH >>>>>>>>>>>> cannot possibly
>>> terminate normally by reaching its own "return" >>>>>>>>>>>> instruction.
>>
>> In other words, if the code of HHH is replaced with an >>>>>>>>>>>> >> unconditional simulator then it can be shown that DD is >>>>>>>>>>>> >> non-halting and therefore HHH(DD)==0 is correct. >>>>>>>>>>>> >>
> Wow finally someone that totally gets it.
If you disagree, explain why this is different.
In particular, give an example where X correctly emulated by >>>>>>>>>>>> Y is
different from replacing the code of Y with an unconditional >>>>>>>>>>>> simulator
and subsequently running Y(X).
I may not have enough time left to change the subject and >>>>>>>>>>> endlessly go
through anything but the exact point.
You used to have enough time.
That is before the CAR T cell manufacturing process failed twice. >>>>>>>>
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
No such HHH exists.
The programmer of HHH has the following options when HHH reaches
the call to HHH:
1) It just follows the call and starts simulating the code of HHH. >>>>>> This might eventually lead to infinite recursion. So, no correct
simulation.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
A program does not prove. In particular, it does not prove that no
different program exists.
The source code 100% perfectly proves exactly what it
actually does. Whenever anyone disagrees with what it
actually does (as most people here have tried to get
away with) they are necessarily incorrect.
No, it does not. It does not even specify any claim. It only specifies
a behavior, and much of it only inplicitly. A proof ends with the
sentence that is proven but the source code does not. Unless you only
want to clalim tnat }.
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
When we assume that HHH emulates N steps of DD then
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
I am not going to address any other point until this
point is fully understood because the other points
cannot be understood until this one is understood.
On 3/9/2025 8:57 PM, Richard Damon wrote:
On 3/9/25 6:32 PM, olcott wrote:
On 3/9/2025 4:43 PM, Richard Damon wrote:
On 3/9/25 3:36 PM, olcott wrote:
On 3/9/2025 2:24 PM, Richard Damon wrote:
On 3/9/25 9:25 AM, olcott wrote:
On 3/9/2025 6:17 AM, Richard Damon wrote:
On 3/8/25 10:24 PM, olcott wrote:
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:30 PM, olcott wrote:
On 3/8/2025 5:01 PM, dbush wrote:And I am pointing out that it IS the same, it is just that you >>>>>>>>>> don't understand that "Show" implies FINITE.
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:The source code 100% completely specifies every single >>>>>>>>>>>>>>> detail
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said: >>>>>>>>>>>>>>>>>>
The code proves otherwiseA program does not prove. In particular, it does not >>>>>>>>>>>>>>>>>> prove that no
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>>>>
different program exists.
The source code 100% perfectly proves exactly what it >>>>>>>>>>>>>>>>> actually does.
The source code contains a finite sequence of truth >>>>>>>>>>>>>>>> preserving steps between axioms and a statement? >>>>>>>>>>>>>>>
of exactly what it does on each specific input.
Saying that it does not do this is counter-factual. >>>>>>>>>>>>>>>
In other words, the source code does not meet the
definition of a proof, so your claim is false.
Dumb Bunny:
*Proof[0] is anything that shows that X is necessarily true* >>>>>>>>>>>>> *and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH >>>>>>>>>>>>> conclusively proves every detail of the behavior of HHH on >>>>>>>>>>>>> this input. Disagreeing this is either foolish or dishonest. >>>>>>>>>>>>>
A proof is a finite sequence of truth preserving steps >>>>>>>>>>>> between the axioms of a system and a true statement that >>>>>>>>>>>> show the statement is true.
Proof[math] tries unsuccessfully to inherit from proof[0]. >>>>>>>>>>> I am stipulating that I have always been referring to proof[0]. >>>>>>>>>>
In that single aspect you are correct.
Show that X is definitely true and thus impossibly false
by any means what-so-ever is not proof[math].
or proof[0], since you can not SHOW something "by any means" if >>>>>>>> those means are not showable due to not being finite.
You are just proving your stupidity by repeating your
disproved claim.
If you cannot understand the Halt7.c conclusively proves[0] >>>>>>>>>>> the actual behavior of HHH(DD) this is merely your lack of >>>>>>>>>>> understanding and nothing more.
Sure I can understand what it does, as Halt7.c shows that the >>>>>>>>>> behavior of the input is to HALT since that is what DD will do >>>>>>>>>> when main calls it.
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
But The HHH You are talking about doesn't do a correct
simulation, so this statment is not applicable.
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
WHich is *NOT* a program, as it has an external reference.
*When we assume that HHH emulates N steps of DD then*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Wrong, because emulaiting for "N Steps" is NOT correctly emulation. >>>>>>
Correctly emulating N steps is emulating N steps correctly.
Which is only partially emulating it correctly, and only partially
correct is incorrect.
Everyone here that has sufficient technical competence can
see that for any N steps of DD correctly emulated by HHH
that DD cannot possibly reach its own final state and
terminate normally.
So? As has been pointed out, since HHH can't do enough steps to get
to the actual answer, it never CORRECTLY emulated the input enough
to get the answer if it aborts.
If HHH can see the same pattern that every competent
programmer sees then HHH does not need to emulate DD
more than twice to know that HHH cannot possibly reach
its own final state and terminate normally.
The pattern that HHH sees is IDENTICAL to the pattern that HHH1 saw,
up to the point it aborts.
In other words you do not believe that HHH can see what
every competent programmer sees.
On 3/10/2025 4:14 AM, Fred. Zwarts wrote:
Op 09.mrt.2025 om 14:11 schreef olcott:
On 3/9/2025 4:05 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 18:47 schreef olcott:
On 3/8/2025 9:41 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:09 schreef olcott:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Why repeating things we agree with? We agree that HHH correctly
reports that it cannot possibly complete the simulation to its end.
You have despicably changed my words.
It never has been any failure of HHH.
It has always been that DD calls HHH(DD) in recursive
emulation thus specifying that it cannot possible reach
its own final state and terminate normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach
its own "return" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
If HHH can see the same pattern that every competent
programmer sees then HHH does not need to emulate DD
more than twice to know that HHH cannot possibly reach
its own final state and terminate normally.
Perhaps you are not a competent programmer.
On 3/10/2025 4:14 AM, Fred. Zwarts wrote:
Op 09.mrt.2025 om 14:11 schreef olcott:
On 3/9/2025 4:05 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 18:47 schreef olcott:
On 3/8/2025 9:41 AM, Fred. Zwarts wrote:
Op 08.mrt.2025 om 15:09 schreef olcott:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Why repeating things we agree with? We agree that HHH correctly
reports that it cannot possibly complete the simulation to its end.
You have despicably changed my words.
It never has been any failure of HHH.
It has always been that DD calls HHH(DD) in recursive
emulation thus specifying that it cannot possible reach
its own final state and terminate normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach
its own "return" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
If HHH can see the same pattern that every competent
programmer sees then HHH does not need to emulate DD
more than twice to know that HHH cannot possibly reach
its own final state and terminate normally.
Perhaps you are not a competent programmer.
On 3/10/2025 5:45 PM, Richard Damon wrote:
On 3/10/25 10:10 AM, olcott wrote:
On 3/10/2025 6:04 AM, Richard Damon wrote:
On 3/9/25 11:10 PM, olcott wrote:
On 3/9/2025 8:57 PM, Richard Damon wrote:
On 3/9/25 6:32 PM, olcott wrote:
On 3/9/2025 4:43 PM, Richard Damon wrote:
On 3/9/25 3:36 PM, olcott wrote:
On 3/9/2025 2:24 PM, Richard Damon wrote:
On 3/9/25 9:25 AM, olcott wrote:
On 3/9/2025 6:17 AM, Richard Damon wrote:
On 3/8/25 10:24 PM, olcott wrote:
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:30 PM, olcott wrote:
On 3/8/2025 5:01 PM, dbush wrote:
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:Dumb Bunny:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:The source code 100% completely specifies every >>>>>>>>>>>>>>>>>>> single detail
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
The code proves otherwise
https://github.com/plolcott/x86utm/blob/master/ >>>>>>>>>>>>>>>>>>>>>>> Halt7.c
A program does not prove. In particular, it does >>>>>>>>>>>>>>>>>>>>>> not prove that no
different program exists.
The source code 100% perfectly proves exactly what it >>>>>>>>>>>>>>>>>>>>> actually does.
The source code contains a finite sequence of truth >>>>>>>>>>>>>>>>>>>> preserving steps between axioms and a statement? >>>>>>>>>>>>>>>>>>>
of exactly what it does on each specific input. >>>>>>>>>>>>>>>>>>> Saying that it does not do this is counter-factual. >>>>>>>>>>>>>>>>>>>
In other words, the source code does not meet the >>>>>>>>>>>>>>>>>> definition of a proof, so your claim is false. >>>>>>>>>>>>>>>>>
*Proof[0] is anything that shows that X is necessarily >>>>>>>>>>>>>>>>> true*
*and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH >>>>>>>>>>>>>>>>> conclusively proves every detail of the behavior of HHH on >>>>>>>>>>>>>>>>> this input. Disagreeing this is either foolish or >>>>>>>>>>>>>>>>> dishonest.
A proof is a finite sequence of truth preserving steps >>>>>>>>>>>>>>>> between the axioms of a system and a true statement that >>>>>>>>>>>>>>>> show the statement is true.
Proof[math] tries unsuccessfully to inherit from proof[0]. >>>>>>>>>>>>>>> I am stipulating that I have always been referring to >>>>>>>>>>>>>>> proof[0].
And I am pointing out that it IS the same, it is just that >>>>>>>>>>>>>> you don't understand that "Show" implies FINITE.
In that single aspect you are correct.
Show that X is definitely true and thus impossibly false >>>>>>>>>>>>> by any means what-so-ever is not proof[math].
or proof[0], since you can not SHOW something "by any means" >>>>>>>>>>>> if those means are not showable due to not being finite. >>>>>>>>>>>>
You are just proving your stupidity by repeating your >>>>>>>>>>>>>> disproved claim.
If you cannot understand the Halt7.c conclusively proves[0] >>>>>>>>>>>>>>> the actual behavior of HHH(DD) this is merely your lack of >>>>>>>>>>>>>>> understanding and nothing more.
Sure I can understand what it does, as Halt7.c shows that >>>>>>>>>>>>>> the behavior of the input is to HALT since that is what DD >>>>>>>>>>>>>> will do when main calls it.
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG* >>>>>>>>>>>>> DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
But The HHH You are talking about doesn't do a correct >>>>>>>>>>>> simulation, so this statment is not applicable.
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping >>>>>>>>>>> [00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
WHich is *NOT* a program, as it has an external reference. >>>>>>>>>>
*When we assume that HHH emulates N steps of DD then*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Wrong, because emulaiting for "N Steps" is NOT correctly
emulation.
Correctly emulating N steps is emulating N steps correctly.
Which is only partially emulating it correctly, and only
partially correct is incorrect.
Everyone here that has sufficient technical competence can
see that for any N steps of DD correctly emulated by HHH
that DD cannot possibly reach its own final state and
terminate normally.
So? As has been pointed out, since HHH can't do enough steps to >>>>>>>> get to the actual answer, it never CORRECTLY emulated the input >>>>>>>> enough to get the answer if it aborts.
If HHH can see the same pattern that every competent
programmer sees then HHH does not need to emulate DD
more than twice to know that HHH cannot possibly reach
its own final state and terminate normally.
The pattern that HHH sees is IDENTICAL to the pattern that HHH1
saw, up to the point it aborts.
In other words you do not believe that HHH can see what
every competent programmer sees.
The problem is that what "Every Competent Programmer" will see what
I described, that since HHH aborts and returns 0, that DD will reach
the return.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
When their only knowledge of HHH is that HHH emulates
N steps of DD then every competent programmer has
consistently agreed that DD emulated by HHH cannot
possibly reach its own "return" instruction and
terminate normally.
But if HHH only emulates N steps of DD, then any competent programmer
knows that it WILL return to DD.
Factually incorrect proving that the issue has always been
that you are not a sufficiently competent programmer.
It is only the directly executed HHH that drives the
emulation of everything else. As soon as this HHH stops
emulating DD every other emulation immediately stops.
On 3/10/2025 6:04 AM, Richard Damon wrote:...
On 3/9/25 11:10 PM, olcott wrote:
On 3/9/2025 8:57 PM, Richard Damon wrote:
On 3/9/25 6:32 PM, olcott wrote:
On 3/9/2025 4:43 PM, Richard Damon wrote:
On 3/9/25 3:36 PM, olcott wrote:
On 3/9/2025 2:24 PM, Richard Damon wrote:
On 3/9/25 9:25 AM, olcott wrote:
On 3/9/2025 6:17 AM, Richard Damon wrote:
On 3/8/25 10:24 PM, olcott wrote:
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:30 PM, olcott wrote:
On 3/8/2025 5:01 PM, dbush wrote:And I am pointing out that it IS the same, it is just that you don't
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
The code proves otherwiseA program does not prove. In particular, it does not prove that no
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>>>>>>>
different program exists.
The source code 100% perfectly proves exactly what it >>>>>>>>>>>>>>>>>>> actually does.
The source code contains a finite sequence of truth preserving steps
between axioms and a statement?
The source code 100% completely specifies every single detail >>>>>>>>>>>>>>>>> of exactly what it does on each specific input. >>>>>>>>>>>>>>>>> Saying that it does not do this is counter-factual. >>>>>>>>>>>>>>>>>
In other words, the source code does not meet the definition of a
proof, so your claim is false.
Dumb Bunny:
*Proof[0] is anything that shows that X is necessarily true* >>>>>>>>>>>>>>> *and thus impossibly false*
The source-code in Halt7.c combined with the input to HHH >>>>>>>>>>>>>>> conclusively proves every detail of the behavior of HHH on >>>>>>>>>>>>>>> this input. Disagreeing this is either foolish or dishonest. >>>>>>>>>>>>>>>
A proof is a finite sequence of truth preserving steps between the
axioms of a system and a true statement that show the statement is true.
Proof[math] tries unsuccessfully to inherit from proof[0]. >>>>>>>>>>>>> I am stipulating that I have always been referring to proof[0]. >>>>>>>>>>>>
understand that "Show" implies FINITE.
In that single aspect you are correct.
Show that X is definitely true and thus impossibly false >>>>>>>>>>> by any means what-so-ever is not proof[math].
or proof[0], since you can not SHOW something "by any means" if those
means are not showable due to not being finite.
You are just proving your stupidity by repeating your disproved claim.
If you cannot understand the Halt7.c conclusively proves[0] >>>>>>>>>>>>> the actual behavior of HHH(DD) this is merely your lack of >>>>>>>>>>>>> understanding and nothing more.
Sure I can understand what it does, as Halt7.c shows that the behavior
of the input is to HALT since that is what DD will do when main calls
it.
*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
But The HHH You are talking about doesn't do a correct simulation, so
this statment is not applicable.
_DD()
[00002133] 55 push ebp ; housekeeping >>>>>>>>> [00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]
WHich is *NOT* a program, as it has an external reference.
*When we assume that HHH emulates N steps of DD then*
DD correctly emulated by HHH cannot possibly reach
its own "ret" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Wrong, because emulaiting for "N Steps" is NOT correctly emulation. >>>>>>>>
Correctly emulating N steps is emulating N steps correctly.
Which is only partially emulating it correctly, and only partially >>>>>> correct is incorrect.
Everyone here that has sufficient technical competence can
see that for any N steps of DD correctly emulated by HHH
that DD cannot possibly reach its own final state and
terminate normally.
So? As has been pointed out, since HHH can't do enough steps to get to >>>>>> the actual answer, it never CORRECTLY emulated the input enough to get >>>>>> the answer if it aborts.
If HHH can see the same pattern that every competent
programmer sees then HHH does not need to emulate DD
more than twice to know that HHH cannot possibly reach
its own final state and terminate normally.
The pattern that HHH sees is IDENTICAL to the pattern that HHH1 saw, up >>>> to the point it aborts.
In other words you do not believe that HHH can see what
every competent programmer sees.
The problem is that what "Every Competent Programmer" will see what I
described, that since HHH aborts and returns 0, that DD will reach the
return.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
When their only knowledge of HHH is that HHH emulates
N steps of DD then every competent programmer has
On 3/10/2025 6:04 AM, Richard Damon wrote:
On 3/9/25 11:10 PM, olcott wrote:
On 3/9/2025 8:57 PM, Richard Damon wrote:
On 3/9/25 6:32 PM, olcott wrote:
On 3/9/2025 4:43 PM, Richard Damon wrote:
On 3/9/25 3:36 PM, olcott wrote:
On 3/9/2025 2:24 PM, Richard Damon wrote:
On 3/9/25 9:25 AM, olcott wrote:
On 3/9/2025 6:17 AM, Richard Damon wrote:
On 3/8/25 10:24 PM, olcott wrote:
On 3/8/2025 9:03 PM, Richard Damon wrote:
On 3/8/25 6:30 PM, olcott wrote:
On 3/8/2025 5:01 PM, dbush wrote:
On 3/8/2025 5:47 PM, olcott wrote:
On 3/8/2025 4:26 PM, dbush wrote:
On 3/8/2025 11:41 AM, olcott wrote:
On 3/8/2025 9:01 AM, dbush wrote:
On 3/8/2025 9:09 AM, olcott wrote:
On 3/8/2025 3:06 AM, Mikko wrote:
On 2025-03-07 15:11:53 +0000, olcott said:
WHich is *NOT* a program, as it has an external reference._DD()But The HHH You are talking about doesn't do a correctSure I can understand what it does, as Halt7.c shows that the >>>>>>>>>>>> behavior of the input is to HALT since that is what DD will >>>>>>>>>>>> do when main calls it.*WHEN YOU UNDERSTAND THIS THEN YOU KNOW YOU WERE WRONG* DD >>>>>>>>>>> correctly emulated by HHH cannot possibly reach its own "ret" >>>>>>>>>>> instruction and terminate normally because DD calls HHH(DD) in >>>>>>>>>>> recursive emulation.
simulation, so this statment is not applicable.
Which is only partially emulating it correctly, and only partially >>>>>> correct is incorrect.Wrong, because emulaiting for "N Steps" is NOT correctlyCorrectly emulating N steps is emulating N steps correctly.
emulation.
If HHH can see the same pattern that every competent programmer sees >>>>> then HHH does not need to emulate DD more than twice to know thatEveryone here that has sufficient technical competence can see
that for any N steps of DD correctly emulated by HHH that DD
cannot possibly reach its own final state and terminate normally. >>>>>> So? As has been pointed out, since HHH can't do enough steps to get >>>>>> to the actual answer, it never CORRECTLY emulated the input enough >>>>>> to get the answer if it aborts.
HHH cannot possibly reach its own final state and terminate
normally.
We also know that HHH definitely returns, *even when simulating itself*.When their only knowledge of HHH is that HHH emulates N steps of DD then every competent programmer has consistently agreed that DD emulated byThe problem is that what "Every Competent Programmer" will see what IThe pattern that HHH sees is IDENTICAL to the pattern that HHH1 saw,In other words you do not believe that HHH can see what every
up to the point it aborts.
competent programmer sees.
described, that since HHH aborts and returns 0, that DD will reach the
return.
HHH cannot possibly reach its own "return" instruction and terminate normally.
On 3/10/2025 3:59 AM, Mikko wrote:
On 2025-03-09 13:16:20 +0000, olcott said:>>
When we assume that HHH emulates N steps of DD then
HHH does not present that assumption, which is therefore irrelevant
to the fact that https://github.com/plolcott/x86utm/blob/master/Halt7.c
does not prove anything.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
DD correctly emulated by HHH cannot possibly reach
its own "retrun" instruction and terminate normally
because DD calls HHH(DD) in recursive emulation.
Perhaps you are not a competent programmer.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 493 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 190:49:48 |
| Calls: | 9,707 |
| Calls today: | 2 |
| Files: | 13,740 |
| Messages: | 6,179,980 |