Re: D correctly simulated by H cannot possibly reach its own line 06 and halt

Op 03.jun.2024 om 15:12 schreef olcott:

On 6/3/2024 4:11 AM, Mikko wrote:

On 2024-06-02 13:51:43 +0000, olcott said:
>

On 6/2/2024 3:00 AM, Mikko wrote:

On 2024-06-01 18:34:22 +0000, olcott said:
>

On 6/1/2024 1:28 PM, joes wrote:

Am Fri, 31 May 2024 09:25:40 -0500 schrieb olcott:

On 5/31/2024 2:50 AM, Fred. Zwarts wrote:

Op 31.mei.2024 om 00:01 schreef olcott:

On 5/30/2024 4:54 PM, joes wrote:

Am Thu, 30 May 2024 09:55:24 -0500 schrieb olcott:
>

typedef int (*ptr)();  // ptr is pointer to int function in C
00       int H(ptr p, ptr i);
01       int D(ptr p)
02       {
03         int Halt_Status = H(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         H(D,D);
12         return 0;
13       }

>

Everyone with sufficient knowledge of C can easily determine that D
correctly emulated by any *pure function* H (using an x86 emulator)
cannot possibly reach its own simulated final state at line 06 and
halt.

Yeah, of course not, if H doesn’t halt.

>

Or maybe you did not know that every computation that never reaches
its own final state *DOES NOT HALT* even if it stops running because
it is no longer simulated.

Since the claim is that H is also a computation, it holds for H, as
well. That means that H *DOES NOT HALT* even if it stops running because
it is no longer simulated.

*pure function H definitely halts you are confused*

The fuck? If H halts, then D can definitely reach past line 4.
>

>
*Trying to get away with changing the subject away from this*
*is known as the strawman deception*
>
DD correctly simulated by pure function HH cannot possibly reach
its own final state at line 06 in any finite number of steps of
correct simulation.

>
Your "DD correctly simulated by pure function HH" is an attempt
to deceive. Otherwise you would just say "DD" because that is
what the phrase means.
>

>
It turns out that "that is what the phrase means" is merely a false
assumption.

>
No, it is not. Knowledge about meanings of phrases that are not
defined in the opus where they are used is empirical knwoledge
that ultimately comes from observations. Meanings of individual
words and many phrases are documented in dictionaries. Other
phrases get their meanig from their constituents and constitution
in a way that is documented in grammar books. If you want a
meaning that cannot be found in dictionaries and grammar bookd
you need to define.
>
In this particular case the phrase is "DD correctly simulated by
pure function HH". This phrase is a composite of two subphrases:
the first one is "DD" and the sencond one is "correctly simulated
by HH". This kind of phrases are used to identify something so
that something can be said about it without saying the same about
other things. The second part is needed if the first part is a
generic term that alone may denote both things intended to be
included and things intended to be excluded from the meaning
of the phrase. So the phrase "DD correctly simulated by pure
function HH" makes a distinction between those DD that are or
have been or will be a model of correct simulation by HH and
those that are not and nave not been and will not be. But the
former kind of DD and the latter kind of DD have no intrinsic
difference that would require exclusion of the latter form
the sentence. In particular, DD's ablility to reach its own
final state at line 06 does not depend on whther HH will ever
simulate it (correctly or otherwise.
>

>
*Repeat until correct rebuttal*
>
DD correctly emulated by any HH that can possibly exist DOES NOT HALT
DD correctly emulated by any HH that can possibly exist DOES NOT HALT
DD correctly emulated by any HH that can possibly exist DOES NOT HALT

 Because *HH* emulated by any HH that can possibly exist DOES NOT HALT
 

>
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       }
>
_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]
>