On 6/7/2025 10:54 AM, wij wrote:
On Sat, 2025-06-07 at 10:35 -0500, olcott wrote:
On 6/7/2025 10:31 AM, wij wrote:
On Sat, 2025-06-07 at 09:57 -0500, olcott wrote:
On 6/7/2025 9:54 AM, wij wrote:
On Sat, 2025-06-07 at 09:32 -0500, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence of DDD
emulated by HHH from DDD emulated by HHH1.
Shows that DDD emulated by HHH and DDD emulated by HHH1 diverges >>>>>>> as soon as HHH begins emulating itself emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH [00002183]
push ebp [00002183] push ebp [00002184] mov >>>>>>> ebp,esp [00002184] mov ebp,esp [00002186] push 00002183
; DDD [00002186] push 00002183 ; DDD [0000218b] call 000015c3 ; >>>>>>> HHH [0000218b] call 000015c3 ; HHH *HHH1 emulates DDD once then >>>>>>> HHH emulates DDD once, these match*
The next instruction of DDD that HHH emulates is at the machine
address of 00002183.
The next instruction of DDD that HHH1 emulates is at the machine >>>>>>> address of 00002190.
New slave_stack at:198d21 DDD emulated by HHH *This is the
beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
The HP theorem never bothered to notice that it has contradictoryThe HP is asking for such a H that H(D)==1 iff D() halts.int main()
You are always solving POO Problem.
{
DDD(); // The HHH(DDD) that DDD calls cannot report
} // on the behavior of its caller.
That is what the HP theorem says, the halting decider is not
possible.
axioms. HHH(DDD) IS NOT ALLOWED TO REPORT ON THE BEHAVIOR OF ITS
CALLER.
And lo, no program shall be forbidden to call the mighty halt decider. Recursions 22:22Nope. It you who don't understand English.The theory of computation does not allow a halt decider to report on the behavior of its caller. Cite the chapter and verse where it does allow
this.
On 6/7/2025 11:43 AM, joes wrote:You say: HHH1 doesn't simulate itself. That is true. Also true is that
Am Sat, 07 Jun 2025 11:02:55 -0500 schrieb olcott:That is not the question being answered.
On 6/7/2025 10:54 AM, wij wrote:
On Sat, 2025-06-07 at 10:35 -0500, olcott wrote:
On 6/7/2025 10:31 AM, wij wrote:
On Sat, 2025-06-07 at 09:57 -0500, olcott wrote:
On 6/7/2025 9:54 AM, wij wrote:
On Sat, 2025-06-07 at 09:32 -0500, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence of DDD >>>>>>>>> emulated by HHH from DDD emulated by HHH1.
Shows that DDD emulated by HHH and DDD emulated by HHH1 diverges >>>>>>>>> as soon as HHH begins emulating itself emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH [00002183]
push ebp [00002183] push ebp [00002184] mov
ebp,esp [00002184] mov ebp,esp [00002186] push >>>>>>>>> 00002183 ; DDD [00002186] push 00002183 ; DDD [0000218b] call >>>>>>>>> 000015c3 ; HHH [0000218b] call 000015c3 ; HHH *HHH1 emulates >>>>>>>>> DDD once then HHH emulates DDD once, these match*
What do you mean by "then" and "once"? That implies completion and
succession, however we are only ever simulating a single call, and only
HHH1 simulates any returns of DDD/HHH.
HHH1 simulates DDD completely, HHH recurses and aborts *inside*. HHH
does not simulate DDD once, it only enters the call, but never exits.
The next instruction of DDD that HHH emulates is at the machine >>>>>>>>> address of 00002183.
The next instruction of DDD that HHH1 emulates is at the machine >>>>>>>>> address of 00002190.
At those addresses we have the first instruction of DDD and the one
after the call, respectively.
[main -> HHH1(DDD) -> HHH(DDD) -> HHH(DDD)]
New slave_stack at:198d21 DDD emulated by HHH *This is the >>>>>>>>> beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
HHH1 does simulate HHH simulating DDD.
On 6/7/2025 1:51 PM, dbush wrote:
On 6/7/2025 2:49 PM, olcott wrote:
On 6/7/2025 1:43 PM, dbush wrote:
On 6/7/2025 2:36 PM, olcott wrote:
On 6/7/2025 1:26 PM, dbush wrote:
On 6/7/2025 1:10 PM, olcott wrote:
On 6/7/2025 11:37 AM, dbush wrote:
On 6/7/2025 12:29 PM, olcott wrote:
On 6/7/2025 11:20 AM, dbush wrote:
On 6/7/2025 12:17 PM, olcott wrote:
On 6/7/2025 11:14 AM, dbush wrote:
On 6/7/2025 11:33 AM, olcott wrote:
On 6/7/2025 10:17 AM, dbush wrote:
On 6/7/2025 11:12 AM, olcott wrote:
On 6/7/2025 10:08 AM, dbush wrote:
On 6/7/2025 11:06 AM, olcott wrote:
On 6/7/2025 10:01 AM, dbush wrote:
On 6/7/2025 10:58 AM, olcott wrote:
On 6/7/2025 9:56 AM, dbush wrote:
On 6/7/2025 10:54 AM, olcott wrote:
On 6/7/2025 9:51 AM, dbush wrote:
On 6/7/2025 10:32 AM, olcott wrote:
The execution trace of HHH1(DDD) shows the >>>>>>>>>>>>>>>>>>>>>>> divergence of DDD emulated by HHH from DDD >>>>>>>>>>>>>>>>>>>>>>> emulated by HHH1.
Shows that DDD emulated by HHH and DDD emulated by >>>>>>>>>>>>>>>>>>>>>>> HHH1 diverges as soon as HHH begins emulating >>>>>>>>>>>>>>>>>>>>>>> itself emulating DDD.
*That is not an instruction of DDD*The next instruction of DDD that HHH emulates is >>>>>>>>>>>>>>>>>>>>>>> at the machine address of 00002183. >>>>>>>>>>>>>>>>>>>>>>> The next instruction of DDD that HHH1 emulates is >>>>>>>>>>>>>>>>>>>>>>> at the machine address of 00002190. >>>>>>>>>>>>>>>>>>>>>>False.
The next instruction of DDD that both HHH and HHH1 >>>>>>>>>>>>>>>>>>>>>> emulates is at the machine address of 000015c3, >>>>>>>>>>>>>>>>>>>>>
In other words, you're not operating on algorithms.
I didn't say that you didn't specify an algorithm. I said your HHHTermination analyzers are encoded algorithms that work with finite
doesn't work with algorithms,
strings that specify a precise sequence of configurations.
On 6/7/2025 2:04 PM, joes wrote:
Am Sat, 07 Jun 2025 13:59:54 -0500 schrieb olcott:
On 6/7/2025 1:51 PM, dbush wrote:
On 6/7/2025 2:49 PM, olcott wrote:
On 6/7/2025 1:43 PM, dbush wrote:
On 6/7/2025 2:36 PM, olcott wrote:
On 6/7/2025 1:26 PM, dbush wrote:
On 6/7/2025 1:10 PM, olcott wrote:
On 6/7/2025 11:37 AM, dbush wrote:
On 6/7/2025 12:29 PM, olcott wrote:
On 6/7/2025 11:20 AM, dbush wrote:
On 6/7/2025 12:17 PM, olcott wrote:
On 6/7/2025 11:14 AM, dbush wrote:
On 6/7/2025 11:33 AM, olcott wrote:
On 6/7/2025 10:17 AM, dbush wrote:
On 6/7/2025 11:12 AM, olcott wrote:
On 6/7/2025 10:08 AM, dbush wrote:
On 6/7/2025 11:06 AM, olcott wrote:
On 6/7/2025 10:01 AM, dbush wrote:
On 6/7/2025 10:58 AM, olcott wrote:
On 6/7/2025 9:56 AM, dbush wrote:
On 6/7/2025 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 6/7/2025 9:51 AM, dbush wrote:
The directly executed DDD() and the directly executed HHH(DDD) NEVERIn other words, you're not operating on algorithms.False.
The next instruction of DDD that both HHH and >>>>>>>>>>>>>>>>>>>>>>>> HHH1 emulates is at the machine address of >>>>>>>>>>>>>>>>>>>>>>>> 000015c3,
*That is not an instruction of DDD* >>>>>>>>>>>>>>>>>>>>>>
I didn't say that you didn't specify an algorithm. I said your HHHTermination analyzers are encoded algorithms that work with finite
doesn't work with algorithms,
strings that specify a precise sequence of configurations.
Yes, they should. Thus HHH is not a termination analyser if it doesn't
consider itself being part of the input. This is how computation works.
STOP RUNNING UNLESS HHH(DDD) ABORTS ITS EMULATION OF DDD.
On 6/7/2025 1:59 PM, joes wrote:No, the instructions are the same.
Am Sat, 07 Jun 2025 12:20:42 -0500 schrieb olcott:
On 6/7/2025 11:43 AM, joes wrote:You say: HHH1 doesn't simulate itself. That is true. Also true is that
Am Sat, 07 Jun 2025 11:02:55 -0500 schrieb olcott:That is not the question being answered.
On 6/7/2025 10:54 AM, wij wrote:
On Sat, 2025-06-07 at 10:35 -0500, olcott wrote:
On 6/7/2025 10:31 AM, wij wrote:
On Sat, 2025-06-07 at 09:57 -0500, olcott wrote:
On 6/7/2025 9:54 AM, wij wrote:
On Sat, 2025-06-07 at 09:32 -0500, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence of DDD >>>>>>>>>>> emulated by HHH from DDD emulated by HHH1.
Shows that DDD emulated by HHH and DDD emulated by HHH1
diverges as soon as HHH begins emulating itself emulating DDD. >>>>>>>>>>>
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH >>>>>>>>>>> [00002183]
push ebp [00002183] push ebp [00002184] mov
ebp,esp [00002184] mov ebp,esp [00002186] push
00002183 ; DDD [00002186] push 00002183 ; DDD [0000218b] >>>>>>>>>>> call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH *HHH1 >>>>>>>>>>> emulates DDD once then HHH emulates DDD once, these match*
What do you mean by "then" and "once"? That implies completion and
succession, however we are only ever simulating a single call, and
only HHH1 simulates any returns of DDD/HHH.
HHH1 simulates DDD completely, HHH recurses and aborts *inside*. HHH
does not simulate DDD once, it only enters the call, but never exits.
The next instruction of DDD that HHH emulates is at the
machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at the >>>>>>>>>>> machine address of 00002190.
At those addresses we have the first instruction of DDD and the one
after the call, respectively.
[main -> HHH1(DDD) -> HHH(DDD) -> HHH(DDD)]
New slave_stack at:198d21 DDD emulated by HHH *This is the >>>>>>>>>>> beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
HHH1 does simulate HHH simulating DDD.
HHH1 simulates the same thing that HHH does,
The emulation of DDD by HHH(DDD) contained within the execution trace of HHH1(DDD) diverges from the execution trace of DDD by HHH1 as soon as
HHH emulates itself emulating DDD.
HHH(DDD) ALWAYS emulates itself emulating DDD. HHH1(DDD) NEVER emulates itself emulating DDD.Dude, I already agreed with that. It doesn't matter.
On 6/7/2025 11:37 AM, dbush wrote:
On 6/7/2025 12:29 PM, olcott wrote:
On 6/7/2025 11:20 AM, dbush wrote:
On 6/7/2025 12:17 PM, olcott wrote:
On 6/7/2025 11:14 AM, dbush wrote:
On 6/7/2025 11:33 AM, olcott wrote:
On 6/7/2025 10:17 AM, dbush wrote:
On 6/7/2025 11:12 AM, olcott wrote:
On 6/7/2025 10:08 AM, dbush wrote:
On 6/7/2025 11:06 AM, olcott wrote:
On 6/7/2025 10:01 AM, dbush wrote:
On 6/7/2025 10:58 AM, olcott wrote:
On 6/7/2025 9:56 AM, dbush wrote:
On 6/7/2025 10:54 AM, olcott wrote:In other words you are not actually paying any attention. >>>>>>>>>>>>>
On 6/7/2025 9:51 AM, dbush wrote:
On 6/7/2025 10:32 AM, olcott wrote:*That is not an instruction of DDD*
The execution trace of HHH1(DDD) shows the divergence >>>>>>>>>>>>>>>>> of DDD emulated by HHH from DDD emulated by HHH1. >>>>>>>>>>>>>>>>>
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by >>>>>>>>>>>>>>>>> HHH1 diverges as soon as HHH begins emulating itself >>>>>>>>>>>>>>>>> emulating DDD.
*From the execution trace of HHH1(DDD) shown below* >>>>>>>>>>>>>>>>> DDD emulated by HHH1 DDD emulated by HHH
[00002183] push ebp [00002183] push ebp
[00002184] mov ebp,esp [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD [00002186] push >>>>>>>>>>>>>>>>> 00002183 ; DDD
[0000218b] call 000015c3 ; HHH [0000218b] call >>>>>>>>>>>>>>>>> 000015c3 ; HHH
*HHH1 emulates DDD once then HHH emulates DDD once, >>>>>>>>>>>>>>>>> these match*
The next instruction of DDD that HHH emulates is at >>>>>>>>>>>>>>>>> the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at >>>>>>>>>>>>>>>>> the machine address of 00002190.
False.
The next instruction of DDD that both HHH and HHH1 >>>>>>>>>>>>>>>> emulates is at the machine address of 000015c3, >>>>>>>>>>>>>>>
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
In other words, you're not operating on algorithms. >>>>>>>>>>>>>
I'm very much paying to attention to the fact that you >>>>>>>>>>>> stated that the code of the function H is not part of the >>>>>>>>>>>> input and that you're therefore not working on the halting >>>>>>>>>>>> problem.
You say that I said things that I never said.
You said that the instruction at address 000015c3 is not part >>>>>>>>>> of the input, which means the input to HHH is not an
algorithm, and therefore has nothing to do with the halting >>>>>>>>>> problem.
You really should be honest about not working on the halting >>>>>>>>>> problem.
I never said that.
So you're saying that the input to HHH is a description/
specification of algorithm DDD consisting of the fixed code of >>>>>>>> the function DDD, the fixed code of the function HHH, and the
fixed code of everything that HHH calls down to the OS level,
and that HHH must therefore report on the behavior of the
algorithm described/ specified by its input?
The directly executed DDD() would never stop running
unless HHH(DDD) aborts the simulation of its input.
The directly executed HHH(DDD) would never stop running
unless HHH(DDD) aborts the simulation of its input.
Thus conclusively proving that the input to HHH(DDD)
Is not an algorithm, as you have admitted above, and therefore has >>>>>> nothing to do with the halting problem.
People might actually take you seriously if you stopped lying
about that.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D >>>>> specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
Irrelevent, as you're not working on the halting problem by your own
admission:
I have correctly refuted the conventional proofs of
the Halting Problem
No you haven't, as you're not actually working on the halting problem
as you've admitted:
This *is* the architecture of the algorithm.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
On 6/7/2025 11:20 AM, dbush wrote:
On 6/7/2025 12:17 PM, olcott wrote:
On 6/7/2025 11:14 AM, dbush wrote:
On 6/7/2025 11:33 AM, olcott wrote:
On 6/7/2025 10:17 AM, dbush wrote:
On 6/7/2025 11:12 AM, olcott wrote:
On 6/7/2025 10:08 AM, dbush wrote:
On 6/7/2025 11:06 AM, olcott wrote:
On 6/7/2025 10:01 AM, dbush wrote:
On 6/7/2025 10:58 AM, olcott wrote:
On 6/7/2025 9:56 AM, dbush wrote:
On 6/7/2025 10:54 AM, olcott wrote:
On 6/7/2025 9:51 AM, dbush wrote:
On 6/7/2025 10:32 AM, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence >>>>>>>>>>>>>>> of DDD emulated by HHH from DDD emulated by HHH1. >>>>>>>>>>>>>>>
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by >>>>>>>>>>>>>>> HHH1 diverges as soon as HHH begins emulating itself >>>>>>>>>>>>>>> emulating DDD.
*From the execution trace of HHH1(DDD) shown below* >>>>>>>>>>>>>>> DDD emulated by HHH1 DDD emulated by HHH
[00002183] push ebp [00002183] push ebp
[00002184] mov ebp,esp [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD [00002186] push >>>>>>>>>>>>>>> 00002183 ; DDD
[0000218b] call 000015c3 ; HHH [0000218b] call >>>>>>>>>>>>>>> 000015c3 ; HHH
*HHH1 emulates DDD once then HHH emulates DDD once, these >>>>>>>>>>>>>>> match*
The next instruction of DDD that HHH emulates is at >>>>>>>>>>>>>>> the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at >>>>>>>>>>>>>>> the machine address of 00002190.
False.
The next instruction of DDD that both HHH and HHH1 >>>>>>>>>>>>>> emulates is at the machine address of 000015c3,
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
*That is not an instruction of DDD*
In other words, you're not operating on algorithms.
In other words you are not actually paying any attention. >>>>>>>>>>>
I'm very much paying to attention to the fact that you stated >>>>>>>>>> that the code of the function H is not part of the input and >>>>>>>>>> that you're therefore not working on the halting problem.
You say that I said things that I never said.
You said that the instruction at address 000015c3 is not part of >>>>>>>> the input, which means the input to HHH is not an algorithm, and >>>>>>>> therefore has nothing to do with the halting problem.
You really should be honest about not working on the halting
problem.
I never said that.
So you're saying that the input to HHH is a description/
specification of algorithm DDD consisting of the fixed code of the >>>>>> function DDD, the fixed code of the function HHH, and the fixed
code of everything that HHH calls down to the OS level, and that
HHH must therefore report on the behavior of the algorithm
described/ specified by its input?
The directly executed DDD() would never stop running
unless HHH(DDD) aborts the simulation of its input.
The directly executed HHH(DDD) would never stop running
unless HHH(DDD) aborts the simulation of its input.
Thus conclusively proving that the input to HHH(DDD)
Is not an algorithm, as you have admitted above, and therefore has
nothing to do with the halting problem.
People might actually take you seriously if you stopped lying about
that.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Irrelevent, as you're not working on the halting problem by your own
admission:
I have correctly refuted the conventional proofs of
the Halting Problem, in the same way that ZFC refuted
Russell's Paradox.
On 6/7/2025 9:54 AM, wij wrote:
On Sat, 2025-06-07 at 09:32 -0500, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH
[00002183] push ebp [00002183] push ebp
[00002184] mov ebp,esp [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH
*HHH1 emulates DDD once then HHH emulates DDD once, these match*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========== =============
<main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main() >>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
</main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9 >>>
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301 >>>
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
<DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0 xor eax,eax ; main()
[000021b5][00103831][00000018] 5d pop ebp ; main() >>> [000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
The HP is asking for such a H that H(D)==1 iff D() halts.
You are always solving POO Problem.
int main()
{
DDD(); // The HHH(DDD) that DDD calls cannot report
} // on the behavior of its caller.
On 6/7/2025 10:31 AM, wij wrote:
On Sat, 2025-06-07 at 09:57 -0500, olcott wrote:
On 6/7/2025 9:54 AM, wij wrote:
On Sat, 2025-06-07 at 09:32 -0500, olcott wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH
[00002183] push ebp [00002183] push ebp
[00002184] mov ebp,esp [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH
*HHH1 emulates DDD once then HHH emulates DDD once, these match*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly >>>>> address address data code language >>>>> ======== ======== ======== ========== =============
<main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main() >>>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
</main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9 >>>>>
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301 >>>>>
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of
HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of >>>>> HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
<DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of
HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of >>>>> HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1 >>>>> [00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0 xor eax,eax ; main() >>>>> [000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
The HP is asking for such a H that H(D)==1 iff D() halts.
You are always solving POO Problem.
int main()
{
DDD(); // The HHH(DDD) that DDD calls cannot report
} // on the behavior of its caller.
That is what the HP theorem says, the halting decider is not possible.
The HP theorem never bothered to notice that it has
contradictory axioms. HHH(DDD) IS NOT ALLOWED TO
REPORT ON THE BEHAVIOR OF ITS CALLER.
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
On 6/12/25 12:44 AM, olcott wrote:
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <polcott333@gmail.com> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH >>>>>> [00002183] push ebp [00002183] push ebp >>>>>> [00002184] mov ebp,esp [00002184] mov ebp,esp >>>>>> [00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD >>>>>> [0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH >>>>>> *HHH1 emulates DDD once then HHH emulates DDD once, these match*
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly >>>>>> address address data code language >>>>>> ======== ======== ======== ========== =============
<main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main() >>>>>> [000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 >>>>>> </main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9 >>>>>>
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>> </DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301 >>>>>>
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>> <DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD >>>>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>> </DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>> HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1 >>>>>> [00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main() >>>>>> [000021b3][0010382d][00000000] 33c0 xor eax,eax ; main() >>>>>> [000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions
and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims
are just lies based on the category error of you not making HHH
actually a fixed programs, and thus DDD isn't a program, and thus not
something that CAN be correctly simulated, just shows that you don't
care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by admitting
that DDD isn't amoundg the category of things that can be simulated.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that show
that you have just been lying all these years about your system being
the equivalent of the halting problem proof, just shows how little you
care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
WHich gives a compiler error of undefined symbol HHH.
On 6/13/2025 6:41 AM, Mikko wrote:
On 2025-06-12 14:21:39 +0000, Richard Damon said:
On 6/12/25 12:44 AM, olcott wrote:
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <polcott333@gmail.com> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH >>>>>>>> [00002183] push ebp [00002183] push ebp >>>>>>>> [00002184] mov ebp,esp [00002184] mov ebp,esp >>>>>>>> [00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD >>>>>>>> [0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH >>>>>>>> *HHH1 emulates DDD once then HHH emulates DDD once, these match* >>>>>>>>
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly >>>>>>>> address address data code language >>>>>>>> ======== ======== ======== ========== =============
<main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 >>>>>>>> </main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>> </DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>> <DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that*
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>> </DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>> HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main() >>>>>>>> [000021b3][0010382d][00000000] 33c0 xor eax,eax ; main() >>>>>>>> [000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions >>>>>>> and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims >>>>> are just lies based on the category error of you not making HHH
actually a fixed programs, and thus DDD isn't a program, and thus not >>>>> something that CAN be correctly simulated, just shows that you don't >>>>> care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by admitting >>>>> that DDD isn't amoundg the category of things that can be simulated. >>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that show >>>>> that you have just been lying all these years about your system being >>>>> the equivalent of the halting problem proof, just shows how little you >>>>> care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
WHich gives a compiler error of undefined symbol HHH.
In old C standards it was permitted to call an undefined function.
It was assumed to refer to an external function. Consequently old
compilers accept it.
I have corrected Richard on this point too many times
he is either a liar or has brain damage preventing him
from remembering any details from one post to the next.
On 6/15/2025 5:05 AM, Mikko wrote:
On 2025-06-13 15:58:46 +0000, olcott said:
On 6/13/2025 6:41 AM, Mikko wrote:
On 2025-06-12 14:21:39 +0000, Richard Damon said:
On 6/12/25 12:44 AM, olcott wrote:
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <polcott333@gmail.com> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH >>>>>>>>>> [00002183] push ebp [00002183] push ebp >>>>>>>>>> [00002184] mov ebp,esp [00002184] mov ebp,esp >>>>>>>>>> [00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD >>>>>>>>>> [0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH >>>>>>>>>> *HHH1 emulates DDD once then HHH emulates DDD once, these match* >>>>>>>>>>
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly >>>>>>>>>> address address data code language
======== ======== ======== ========== ============= >>>>>>>>>> <main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push >>>>>>>>>> DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call >>>>>>>>>> HHH1
</main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored >>>>>>>>>> at:1138d9
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD
of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD
of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push >>>>>>>>>> DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call >>>>>>>>>> HHH
</DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored >>>>>>>>>> at:15e301
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD
of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD
of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push >>>>>>>>>> DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call >>>>>>>>>> HHH
<DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that* >>>>>>>>>>
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD
of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD
of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push >>>>>>>>>> DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call >>>>>>>>>> HHH
</DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation >>>>>>>>>> Stopped
HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of >>>>>>>>>> HHH1
[00002193][001138cd][000015a8] 5d pop ebp ; DDD of
HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of
HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main() >>>>>>>>>> [000021b3][0010382d][00000000] 33c0 xor eax,eax ; main() >>>>>>>>>> [000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions >>>>>>>>> and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your
claims are just lies based on the category error of you not
making HHH actually a fixed programs, and thus DDD isn't a
program, and thus not something that CAN be correctly simulated, >>>>>>> just shows that you don't care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by
admitting that DDD isn't amoundg the category of things that can >>>>>>> be simulated.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts
that show that you have just been lying all these years about
your system being the equivalent of the halting problem proof,
just shows how little you care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
WHich gives a compiler error of undefined symbol HHH.
In old C standards it was permitted to call an undefined function.
It was assumed to refer to an external function. Consequently old
compilers accept it.
I have corrected Richard on this point too many times
he is either a liar or has brain damage preventing him
from remembering any details from one post to the next.
Syntax error. There should be either a full stop between the two main
clauses or words that connect them into a coherent sentence.
Anyway, Richard is right on this point as far as he is referring
to the current standards.
I have had to tell Richard that there is a single
global memory space for the object code of Halt7.c
dozens of times and he immediately forgets this
by the next post.
On 6/15/2025 5:05 AM, Mikko wrote:
On 2025-06-13 15:58:46 +0000, olcott said:
On 6/13/2025 6:41 AM, Mikko wrote:
On 2025-06-12 14:21:39 +0000, Richard Damon said:
On 6/12/25 12:44 AM, olcott wrote:
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <polcott333@gmail.com> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH >>>>>>>>>> [00002183] push ebp [00002183] push ebp >>>>>>>>>> [00002184] mov ebp,esp [00002184] mov ebp,esp >>>>>>>>>> [00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD >>>>>>>>>> [0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH >>>>>>>>>> *HHH1 emulates DDD once then HHH emulates DDD once, these match* >>>>>>>>>>
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD
[0000218b] e833f4ffff call 000015c3 ; call HHH
[00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD
[000021ab] e843f3ffff call 000014f3 ; call HHH1
[000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly >>>>>>>>>> address address data code language
======== ======== ======== ========== ============= >>>>>>>>>> <main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1 >>>>>>>>>> </main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>> </DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>> <DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior*
*HHH is emulating itself emulating DDD, HHH1 never does that* >>>>>>>>>>
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>> </DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>>>> HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main() >>>>>>>>>> [000021b3][0010382d][00000000] 33c0 xor eax,eax ; main() >>>>>>>>>> [000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions >>>>>>>>> and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation
into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims >>>>>>> are just lies based on the category error of you not making HHH
actually a fixed programs, and thus DDD isn't a program, and thus not >>>>>>> something that CAN be correctly simulated, just shows that you don't >>>>>>> care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly
rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by admitting >>>>>>> that DDD isn't amoundg the category of things that can be simulated. >>>>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that show >>>>>>> that you have just been lying all these years about your system being >>>>>>> the equivalent of the halting problem proof, just shows how little you >>>>>>> care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
WHich gives a compiler error of undefined symbol HHH.
In old C standards it was permitted to call an undefined function.
It was assumed to refer to an external function. Consequently old
compilers accept it.
I have corrected Richard on this point too many times
he is either a liar or has brain damage preventing him
from remembering any details from one post to the next.
Syntax error. There should be either a full stop between the two main
clauses or words that connect them into a coherent sentence.
Anyway, Richard is right on this point as far as he is referring
to the current standards.
I have had to tell Richard that there is a single
global memory space for the object code of Halt7.c
dozens of times and he immediately forgets this
by the next post.
On 6/16/2025 5:58 AM, Mikko wrote:
On 2025-06-15 15:50:18 +0000, olcott said:
On 6/15/2025 5:05 AM, Mikko wrote:
On 2025-06-13 15:58:46 +0000, olcott said:
On 6/13/2025 6:41 AM, Mikko wrote:
On 2025-06-12 14:21:39 +0000, Richard Damon said:
On 6/12/25 12:44 AM, olcott wrote:
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <polcott333@gmail.com> wrote:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by
HHH1 diverges as soon as HHH begins emulating itself
emulating DDD.
*From the execution trace of HHH1(DDD) shown below*
DDD emulated by HHH1 DDD emulated by HHH >>>>>>>>>>>> [00002183] push ebp [00002183] push ebp
[00002184] mov ebp,esp [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH
*HHH1 emulates DDD once then HHH emulates DDD once, these match* >>>>>>>>>>>>
The next instruction of DDD that HHH emulates is at
the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at
the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>> [0000218b] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>>>> [00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>> [000021ab] e843f3ffff call 000014f3 ; call HHH1 >>>>>>>>>>>> [000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========== ============= >>>>>>>>>>>> <main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>> [000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
</main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>> [0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>>>> </DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>> [0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>>>> <DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior* >>>>>>>>>>>> *HHH is emulating itself emulating DDD, HHH1 never does that* >>>>>>>>>>>>
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>> [0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>>>> </DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped >>>>>>>>>>>> HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main() >>>>>>>>>>>> [000021b3][0010382d][00000000] 33c0 xor eax,eax ; main()
[000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions >>>>>>>>>>> and learn about recursivity and taill call optimization.
Tail optimization would at best convert recursive emulation >>>>>>>>>> into an infinite loop.
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims >>>>>>>>> are just lies based on the category error of you not making HHH >>>>>>>>> actually a fixed programs, and thus DDD isn't a program, and thus not >>>>>>>>> something that CAN be correctly simulated, just shows that you don't >>>>>>>>> care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its
own "return" statement final halt state, thus is correctly >>>>>>>>>> rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by admitting
that DDD isn't amoundg the category of things that can be simulated. >>>>>>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's
counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that show
that you have just been lying all these years about your system being >>>>>>>>> the equivalent of the halting problem proof, just shows how little you
care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
WHich gives a compiler error of undefined symbol HHH.
In old C standards it was permitted to call an undefined function. >>>>>> It was assumed to refer to an external function. Consequently old
compilers accept it.
I have corrected Richard on this point too many times
he is either a liar or has brain damage preventing him
from remembering any details from one post to the next.
Syntax error. There should be either a full stop between the two main
clauses or words that connect them into a coherent sentence.
Anyway, Richard is right on this point as far as he is referring
to the current standards.
I have had to tell Richard that there is a single
global memory space for the object code of Halt7.c
dozens of times and he immediately forgets this
by the next post.
Maybe his memory isn't much better than yours but how could you know?
That he doesn't echo your lies does not mean that he has forgotten
them.
That you call what I am saying lies when you could
not even point out one mistake is the kind of reckless
disregard for the truth that loses defamation cases.
On 6/17/2025 3:21 AM, Mikko wrote:
On 2025-06-16 21:13:36 +0000, olcott said:
On 6/16/2025 5:58 AM, Mikko wrote:
On 2025-06-15 15:50:18 +0000, olcott said:
On 6/15/2025 5:05 AM, Mikko wrote:
On 2025-06-13 15:58:46 +0000, olcott said:
On 6/13/2025 6:41 AM, Mikko wrote:
On 2025-06-12 14:21:39 +0000, Richard Damon said:
On 6/12/25 12:44 AM, olcott wrote:
On 6/11/2025 8:29 PM, Richard Damon wrote:
On 6/11/25 8:03 PM, olcott wrote:
On 6/11/2025 4:06 PM, anthk wrote:
On 2025-06-07, olcott <polcott333@gmail.com> wrote: >>>>>>>>>>>>>> The execution trace of HHH1(DDD) shows the divergence >>>>>>>>>>>>>> of DDD emulated by HHH from DDD emulated by HHH1.Tail optimization would at best convert recursive emulation >>>>>>>>>>>> into an infinite loop.
int main()
{
HHH1(DDD);
}
Shows that DDD emulated by HHH and DDD emulated by >>>>>>>>>>>>>> HHH1 diverges as soon as HHH begins emulating itself >>>>>>>>>>>>>> emulating DDD.
*From the execution trace of HHH1(DDD) shown below* >>>>>>>>>>>>>> DDD emulated by HHH1 DDD emulated by HHH
[00002183] push ebp [00002183] push ebp
[00002184] mov ebp,esp [00002184] mov ebp,esp
[00002186] push 00002183 ; DDD [00002186] push 00002183 ; DDD
[0000218b] call 000015c3 ; HHH [0000218b] call 000015c3 ; HHH
*HHH1 emulates DDD once then HHH emulates DDD once, these match* >>>>>>>>>>>>>>
The next instruction of DDD that HHH emulates is at >>>>>>>>>>>>>> the machine address of 00002183.
The next instruction of DDD that HHH1 emulates is at >>>>>>>>>>>>>> the machine address of 00002190.
00002183 != 00002190
_DDD()
[00002183] 55 push ebp
[00002184] 8bec mov ebp,esp
[00002186] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>>>> [0000218b] e833f4ffff call 000015c3 ; call HHH >>>>>>>>>>>>>> [00002190] 83c404 add esp,+04
[00002193] 5d pop ebp
[00002194] c3 ret
Size in bytes:(0018) [00002194]
_main()
[000021a3] 55 push ebp
[000021a4] 8bec mov ebp,esp
[000021a6] 6883210000 push 00002183 ; push DDD >>>>>>>>>>>>>> [000021ab] e843f3ffff call 000014f3 ; call HHH1 >>>>>>>>>>>>>> [000021b0] 83c404 add esp,+04
[000021b3] 33c0 xor eax,eax
[000021b5] 5d pop ebp
[000021b6] c3 ret
Size in bytes:(0020) [000021b6]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========== ============= >>>>>>>>>>>>>> <main is executed>
[000021a3][0010382d][00000000] 55 push ebp ; main()
[000021a4][0010382d][00000000] 8bec mov ebp,esp ; main()
[000021a6][00103829][00002183] 6883210000 push 00002183 ; push DDD
[000021ab][00103825][000021b0] e843f3ffff call 000014f3 ; call HHH1
</main is executed>
New slave_stack at:1038d1
Begin Local Halt Decider Simulation Execution Trace Stored at:1138d9
<DDD emulated by HHH1>
[00002183][001138c9][001138cd] 55 push ebp ; DDD of HHH1
[00002184][001138c9][001138cd] 8bec mov ebp,esp ; DDD of HHH1
[00002186][001138c5][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001138c1][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH1>
New slave_stack at:14e2f9
Begin Local Halt Decider Simulation Execution Trace Stored at:15e301
<DDD emulated by HHH>
[00002183][0015e2f1][0015e2f5] 55 push ebp ; DDD of HHH[0]
[00002184][0015e2f1][0015e2f5] 8bec mov ebp,esp ; DDD of HHH[0]
[00002186][0015e2ed][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][0015e2e9][00002190] e833f4ffff call 000015c3 ; call HHH
<DDD emulated by HHH>
New slave_stack at:198d21 DDD emulated by HHH
*This is the beginning of the divergence of the behavior* >>>>>>>>>>>>>> *HHH is emulating itself emulating DDD, HHH1 never does that* >>>>>>>>>>>>>>
<DDD emulated by HHH emulating itself>
[00002183][001a8d19][001a8d1d] 55 push ebp ; DDD of HHH[1]
[00002184][001a8d19][001a8d1d] 8bec mov ebp,esp ; DDD of HHH[1]
[00002186][001a8d15][00002183] 6883210000 push 00002183 ; push DDD
[0000218b][001a8d11][00002190] e833f4ffff call 000015c3 ; call HHH
</DDD emulated by HHH emulating itself>
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
HHH returns to caller
<DDD emulated by HHH1>
[00002190][001138c9][001138cd] 83c404 add esp,+04 ; DDD of HHH1
[00002193][001138cd][000015a8] 5d pop ebp ; DDD of HHH1
[00002194][001138d1][0003a980] c3 ret ; DDD of HHH1
</DDD emulated by HHH1>
<main is executed>
[000021b0][0010382d][00000000] 83c404 add esp,+04 ; main()
[000021b3][0010382d][00000000] 33c0 xor eax,eax ; main()
[000021b5][00103831][00000018] 5d pop ebp ; main()
[000021b6][00103835][00000000] c3 ret ; main()
</main is executed>
Number of Instructions Executed(352831) == 5266 Pages >>>>>>>>>>>>>>
Lean Lisp first, ideally with Scheme. Go get Concrete Abstractions
and learn about recursivity and taill call optimization. >>>>>>>>>>>>
Only for the DDD that calls the HHH that never aborts.
Sorry, but you admission to the facts that show that all your claims
are just lies based on the category error of you not making HHH >>>>>>>>>>> actually a fixed programs, and thus DDD isn't a program, and thus not
something that CAN be correctly simulated, just shows that you don't
care about what the truth actualy is.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly emulated by HHH cannot possibly reach its >>>>>>>>>>>> own "return" statement final halt state, thus is correctly >>>>>>>>>>>> rejected by HHH as non-halting.
Something that can not happen by your stipulations,
Sorry, you have ADMITTED that this statement can't be true by admitting
that DDD isn't amoundg the category of things that can be simulated.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The point of all of this is that the halting problem's >>>>>>>>>>>> counter-example input is also correctly rejected as
non-halting thus refuting the conventional HP proof.
No it isn't, and the fact that you have admitted to the facts that show
that you have just been lying all these years about your system being
the equivalent of the halting problem proof, just shows how little you
care about truth.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
WHich gives a compiler error of undefined symbol HHH.
In old C standards it was permitted to call an undefined function. >>>>>>>> It was assumed to refer to an external function. Consequently old >>>>>>>> compilers accept it.
I have corrected Richard on this point too many times
he is either a liar or has brain damage preventing him
from remembering any details from one post to the next.
Syntax error. There should be either a full stop between the two main >>>>>> clauses or words that connect them into a coherent sentence.
Anyway, Richard is right on this point as far as he is referring
to the current standards.
I have had to tell Richard that there is a single
global memory space for the object code of Halt7.c
dozens of times and he immediately forgets this
by the next post.
Maybe his memory isn't much better than yours but how could you know?
That he doesn't echo your lies does not mean that he has forgotten
them.
That you call what I am saying lies when you could
not even point out one mistake is the kind of reckless
disregard for the truth that loses defamation cases.
As I have already pointed out your mistakes and compared them to the
truth clearly shows that your "could not ever point out one mistake"
is a lie. But that was irrelevant to my previous comment as it was
a response to your reckless disregard for the truth about Richards
ability to remember.
You have never pointed out any mistake that I made.
The most that you have done is point out your own
counter-factual assumptions.
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
On 6/18/2025 4:33 AM, Mikko wrote:
On 2025-06-07 14:32:36 +0000, olcott said:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
The divergence means that at least one of them simulates
incorrectly. Next should be determined which one.
*One might incorrectly guess that*
When one tries to find even a single 100% specific
instruction that is simulated incorrectly, one fails.
When one does not understand these things well
enough to begin looking for a single instruction
that is simulated incorrectly, then one is dishonest
when they claim that the simulation is incorrect.
On 6/18/2025 4:33 AM, Mikko wrote:
On 2025-06-07 14:32:36 +0000, olcott said:
The execution trace of HHH1(DDD) shows the divergence
of DDD emulated by HHH from DDD emulated by HHH1.
The divergence means that at least one of them simulates
incorrectly. Next should be determined which one.
*One might incorrectly guess that*
When one tries to find even a single 100% specific
instruction that is simulated incorrectly, one fails.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 162:22:39 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,501 |