Re: DD correctly simulated by HH cannot possible halt --- Try to prove otherwise --- x86 DD

On 6/2/24 2:29 PM, olcott wrote:

On 6/2/2024 1:13 PM, Richard Damon wrote:

On 6/2/24 1:59 PM, olcott wrote:

On 6/2/2024 12:22 PM, Richard Damon wrote:

On 6/2/24 10:19 AM, olcott wrote:

>
Semantic tautologies are self-evident truth that prove themselves.
It is a fact that every five pound rock weights more than any
three pound rock. No need to weigh any rocks.

>
Right, so you don't need to weigh a five pound rock to know it is five bpounds.
>

>
typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         HH(DD,DD);
12         return 0;
13       }
>
Likewise we correctly deduce that for every HH/DD pair of the
infinite set of all HH/DD pairs that match the above template
every DD correctly simulated by HH never reaches past its own
simulated line 03, thus never halts.

>

>
When for every freaking HH/DD pair that matches the above template
DD correctly simulated by HH cannot possibly ever reaches past its
own simulated line 03 then
>
we know with complete logical certainty that not a damn one of
these DD instance halts. halts, NOT A DAMN ONE OF THEM EVER HALTS.

>
Nope, and you are just proving you are totally out of touch with reality.
>
EVERY DD built on an HH that returns 0 for HH(DD,DD) will Halt.
>

 I am going to give up on you because you continue to try
to get away with the straw-mam deception CHANGE-THE-SUBJECT
fake rebuttal.

Nope. I am not "Changing the subject" but showing that your subject is incorrect or irrelevent.

 This is the only post that I will reply to and unless you
either accept that DD correctly simulated by HH will never
halt for the infinite set of HH/DD pairs specified below
or correctly refute the paragraph relating to the x86 code
of DD shown below *I will simply not respond to your posts*

Which I won't do until you say why it matters.

 (a) Accept the DD/HH that DD never halts
(b) Correctly refute the x86 DD
*EVERYTHING ELSE WILL GET NO RESPONSE FROM ME*

And thus a whole list of posts refuting everything that you say that you will just be forced to leave out there or convict yourself of LYING.

 typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         HH(DD,DD);
12         return 0;
13       }
  DD correctly emulated by HH with an x86 emulator cannot possibly
reach past its own machine instruction [00001c2e] in any finite
(or infinite) number of steps of correct emulation.

But any such finite simulation doesn't prove that the machie being simulated is non-halting.
All you are proving is that the DDs that are provable to be non-halting are built to refute HHs that never answer about them.

 _DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax        ; push DD 1c22
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx        ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342   ; call HH
[00001c33] 83c408     add esp,+08
[00001c36] 8945fc     mov [ebp-04],eax
[00001c39] 837dfc00   cmp dword [ebp-04],+00
[00001c3d] 7402       jz 00001c41
[00001c3f] ebfe       jmp 00001c3f
[00001c41] 8b45fc     mov eax,[ebp-04]
[00001c44] 8be5       mov esp,ebp
[00001c46] 5d         pop ebp
[00001c47] c3         ret
Size in bytes:(0038) [00001c47]