Re: Two dozen people were simply wrong --- Try to prove otherwise --- pinned down

Op 01.jun.2024 om 18:24 schreef olcott:

On 6/1/2024 11:19 AM, Fred. Zwarts wrote:

Op 01.jun.2024 om 18:13 schreef olcott:

On 6/1/2024 10:56 AM, Richard Damon wrote:

On 6/1/24 11:30 AM, olcott wrote:

>
*I will not discuss any other points with you until after you either*
(a) Acknowledge that DD correctly simulated by HH and ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
     simulated by embedded_H remain stuck in recursive simulation for
     1 to ∞ of correct simulation or
>
(b) Correctly prove otherwise.

>
And until you answer the question of what that actually means, I will reply WHO CARES.
>

>
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       }
>
Every DD correctly simulated by any HH of the infinite set of HH/DD
pairs that match the above template never reaches past its own simulated
line 03 in 1 to ∞ steps of correct simulation of DD by HH.
>
In this case HH is either a pure simulator that never halts or
HH is a pure function that stops simulating after some finite number
of simulated lines. The line count is stored in a local variable.
The pure function HH always returns the meaningless value of 56
after it stops simulating.
>

>
The simulated D never reaches past line 03, because the simulated HH never halts in 1 to ∞ steps of correct simulation of HH by HH.
I have told you that so many times.
HH is required to halt, thus HH does not match the requirement.

  HH correctly reports that because DD calls HH(DD,DD) in
recursive simulation that DD never halts.
 HHH(HH,DD,DD) would report that HH halts.
 

Maybe. And H1 (DD,DD) would report that DD halts.
In the recursive simulation by HH, neither the simulation of DD, nor the simulation of HH halts. If one of them would halt, the other one would halt as well.
So HH 'correctly' reports that both DD and HH do not halt, because they both keep starting an instance of each other.