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

Op 02.jun.2024 om 20:46 schreef olcott:

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*

HH must halt. Therefore, a correct simulation of HH must halt, too. If it doesn't, either the simulation is incorrect, or HH does not halt.