Re: Deciders are ONLY accountable for their actual inputs ---

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

On 6/2/2024 1:39 PM, Fred. Zwarts wrote:

Op 02.jun.2024 om 15:56 schreef olcott:

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

On 2024-06-01 15:09:02 +0000, olcott said:
>

On 6/1/2024 3:23 AM, Mikko wrote:

On 2024-05-29 18:31:52 +0000, olcott said:
>

*two dozen people were simply wrong*

>
Why are people who are wrong so important that they deserve
a subject line? I would think that people who are right are
more interesting.
>

>
This is the key mistake of the definition of the halting problem itself.
Linz makes this same mistake. I already covered this extensively in
another reply.

>
The word "this" above does not denote anything so the first sentence
does not mean anything. The word "same" in the second sentence refers
to "this" in the first sentnece and therefore does not denote, either,
so the second sentence does not say anything either. So the third
sentence says that you covevered nothing.
>

That these two dozen different people are wrong about this shows that
the only basis for any rebuttal of my proof for the last three years IS
WRONG.

>
That you claim that these two dozen people are wrong does not show
anything. It probably wouldn't even if you could show that they
really were wrong.
>

>
The only one that I am aware that is not wrong about the behavior
that a simulating halt decider must report on is myself.
>
Only software engineers will understand that DD correctly simulated
by HH had different behavior than DD(DD). Comp Sci people allow Comp Sci
dogma to overrule verified facts.
>
When I pinned Richard down on this he simply said that he does not care
that DD correctly simulated by HH has different behavior than DD(DD).
>
It turns out that DD correctly simulated by HH <is> the behavior that
the input to HH(DD,DD) specifies. Deciders are ONLY accountable for
their actual inputs. Deciders compute the mapping FROM THEIR INPUTS...
>
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.

>
Only because the call to HH at [00001c2e] does not return, because HH does not reach its own return in any finite (or infinite) number of steps of correct emulation.
>

 When HH correctly simulates DD and DD calls the simulated HH(DD,DD)
to simulate itself again
 *this simulated HH is not required to halt*
*this simulated HH is not required to halt*
*this simulated HH is not required to halt*
*this simulated HH is not required to halt*
 

It is required to act just like the real HH.

The executed HH must halt.

So, the simulated HH *IS* required to halt.
Otherwise you have LIED that it is (a copy of) the exact same pure function.

 

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

>