Re: A simulating halt decider applied to the The Peter Linz Turing Machine description ⟨Ĥ⟩

On 5/27/2024 11:33 AM, Richard Damon wrote:

On 5/27/24 12:22 PM, olcott wrote:

On 5/27/2024 10:58 AM, Richard Damon wrote:

On 5/27/24 11:46 AM, olcott wrote:

On 5/27/2024 10:25 AM, Richard Damon wrote:

On 5/27/24 11:06 AM, olcott wrote:

>
>
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       }
>
The above template refers to an infinite set of H/D pairs where D is
correctly simulated by either pure simulator H or pure function H. This
was done because many reviewers used the shell game ploy to endlessly
switch which H/D pair was being referred to.
>
*Correct Simulation Defined*
    This is provided because many reviewers had a different notion of
    correct simulation that diverges from this notion.
>
    A simulator is an x86 emulator that correctly emulates 1 to N of the
    x86 instructions of D in the order specified by the x86 instructions
    of D. This may include M recursive emulations of H emulating itself
    emulating D.

>
And how do you apply that to a TEMPLATE that doesn't define what a call H means (as it could be any of the infinite set of Hs that you can instantiate the template on)?
>

>
*Somehow we got off track of the subject of this thread*

 I note that YOU keep on switching between your C program and Turing Machines.
 Note, per the implications that you implicitly agreed to (by not even trying to refute) the two systems are NOT equivalents of each other.
 

(1) I think you are wrong. I have not seen any of your
reasoning that was not anchored in false assumptions.
Your make fake rebuttal is to change the subject.
(2) It does not matter my proof is anchored in the Linz
proof and the H/D pairs are only used to have a 100% concrete
basis to perfectly anchor things such as the correct meaning
of D correctly simulated by H so that people cannot get away
with claiming that an incorrect simulation is correct.
int main() { D(D); } IS NOT THE BEHAVIOR OF D CORRECTLY SIMULATED BY H.
One cannot simply ignore the pathological relationship between H and D.

>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
  Ĥ copies its own Turing machine description: ⟨Ĥ⟩
  then invokes embedded_H that simulates ⟨Ĥ⟩ with ⟨Ĥ⟩ as input.
>
For the purposes of the above analysis we hypothesize that
embedded_H is either a UTM or a UTM that has been adapted
to stop simulating after a finite number of steps of simulation.

 And what you do mean by that?
 Do you hypothesize that the original H was just a pure UTM,

The original proof does not consider the notion of a simulating
halt decider so I have to begin the proof at an earlier stage
than any definition of H.

in which case we have previously shown that H (H^) (H^) will never answer, and thus isn't a correct decider.

I include UTM embedded_H and adapted UTM embedded_H so that every
simulation of 1 to ∞ steps can be reviewed. At this point embedded_H
is not a decider, it either either a UTM or a UTM that has been
adapted to stop simulating after a finite number of steps.
As you already acknowledged neither UTM embedded_H nor ⟨Ĥ⟩ ⟨Ĥ⟩
correctly simulated by UTM embedded_H would ever halt.
The key point that you keep trying to avoid by perpetual
attempts to change the subject is that when we know that
when ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H for an
infinite number of steps never halts that less than an
infinite number of steps will not halt either.
In other words NO MATTER WHAT ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated
by embedded_H DOES NOT HALT.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer