When we see that all "rebuttals" are either changing the subject with
the strawman deception or ad hominem personal attacks then we see that
even dishonest reviewers are implicitly affirming that the point has
been proved.

int D(int (*x)())
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

*D simulated by H cannot correctly reach its ret instruction and halt*

_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08] // move 1st argument to eax
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08] // move 1st argument to ecx
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H same as H(D,D)
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret

It is a verified fact that H correctly predicts that D correctly
simulated by H cannot possibly reach its final state and halt in any
finite number of steps.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

It is a verified fact that neither the directly executed D(D) nor D
correctly simulated by H would ever stop running unless unless H aborts
its simulation of D. This conclusively proves that H is correct to
reject its input as non-halting.

It is a verified fact that when H(D,D) correctly determines that its
input never halts that H is correct to reject this input as non-halting.

*Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (317-320)

*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2/23/23 10:40 PM, olcott wrote:
> When we see that all "rebuttals" are either changing the subject with
> the strawman deception or ad hominem personal attacks then we see that
> even dishonest reviewers are implicitly affirming that the point has
> been proved.

WHAT changing of subject.

You are CLAIMING to be working on the Halting Problem so talking about
the Halting Problem is on topic.

You also don't understand what an ad hominem attack is, so you are just
proving your ignorance. (Note, that is NOT ad hominem, as it isn't
saying you arguement is wrong because of a characteristic of you, but is
pointing out that it has been shown via actual logic that you are wrong,
and that FACT demonstrartes a property of you.

DEFINITIONS -> you are wrong -> thus demonstrating -> you are ignorant.

>
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *D simulated by H cannot correctly reach its ret instruction and halt*

Which isn't the criteria of a Halt Decider, but is only apparently the
criteria of your POOP.

Remember In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

Thus that actual and only criteria is one which you say can't apply
(showing your ignorance) that of the actual behavior of the machine
descirbed.

Even YOU have admitted that D(D) will Halt because H(D,D) returns 0.

By the definition. this means the only correct answer is Halting and
thus H is wrong.

H might be a correct POOP decider.

>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [00001d23] 83c408     add esp,+08
>  [00001d26] 8945fc     mov [ebp-04],eax
>  [00001d29] 837dfc00   cmp dword [ebp-04],+00
>  [00001d2d] 7402       jz 00001d31
>  [00001d2f] ebfe       jmp 00001d2f
>  [00001d31] 8b45fc     mov eax,[ebp-04]
>  [00001d34] 8be5       mov esp,ebp
>  [00001d36] 5d         pop ebp
>  [00001d37] c3         ret
>
> It is a verified fact that H correctly predicts that D correctly
> simulated by H cannot possibly reach its final state and halt in any
> finite number of steps.
>

Yes, you can prove that H can not simulate D to its final state.

You can even prove that no machine similar to H can do that for the D
based on that machine

That is STILL not the definiton of Halting, because D(D) still Halts
when H(D,D) returns 0, so by the definition of Halting D(D) Halts, and
by the definition of a Halt Decider, H is not a correct halt decier.

> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)

Right **THE TURING MACHINE**, it is not looking at a partial
simulatioon of the machine, but the ACTUAL MACHINE, that is D(D).

D(D) Halts, so this definition says it is a computation that halts.

>
> It is a verified fact that neither the directly executed D(D) nor D
> correctly simulated by H would ever stop running unless unless H aborts
> its simulation of D. This conclusively proves that H is correct to
> reject its input as non-halting.

But since H(D,D) DOES abort it simulation, since if it doesn't it
doesn't asnwer, that s a vacous statement, logic based on a condition
that never occurs doesn't prove anything. The fact that you resort to
using that shows your ignorance of the baiscs of logic.

>
> It is a verified fact that when H(D,D) correctly determines that its
> input never halts that H is correct to reject this input as non-halting.

Nope, It may determine that H's simulation never reaches the final
state, but that isn;'t the definition of halting.

Again, more proof of your ignorance, or maybe you blantant disreguard
for facts.

>
> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

just more of your garbage. Refuted many times, so your repeating it
shows that you are just a blatant liar.

On 2/23/2023 9:40 PM, olcott wrote:
> When we see that all "rebuttals" are either changing the subject with
> the strawman deception or ad hominem personal attacks then we see that
> even dishonest reviewers are implicitly affirming that the point has
> been proved.
>
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *D simulated by H cannot correctly reach its ret instruction and halt*
>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [00001d23] 83c408     add esp,+08
>  [00001d26] 8945fc     mov [ebp-04],eax
>  [00001d29] 837dfc00   cmp dword [ebp-04],+00
>  [00001d2d] 7402       jz 00001d31
>  [00001d2f] ebfe       jmp 00001d2f
>  [00001d31] 8b45fc     mov eax,[ebp-04]
>  [00001d34] 8be5       mov esp,ebp
>  [00001d36] 5d         pop ebp
>  [00001d37] c3         ret
>
> It is a verified fact that H correctly predicts that D correctly
> simulated by H cannot possibly reach its final state and halt in any
> finite number of steps.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> It is a verified fact that neither the directly executed D(D) nor D
> correctly simulated by H would ever stop running unless unless H aborts
> its simulation of D. This conclusively proves that H is correct to
> reject its input as non-halting.
>
> It is a verified fact that when H(D,D) correctly determines that its
> input never halts that H is correct to reject this input as non-halting.
>
> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

https://www.liarparadox.org/Linz_Proof.pdf
Simplified notational conventions for Linz Ĥ at the top of page 3

The paper indicates that Ĥ is created entirely from prepending and
appending states to the original Linz H. I refer to this middle H as
embedded_H.

q0 is named Ĥ.q0
The variable Wm is referred to by its value ⟨Ĥ⟩
The second start state Ĥq0 is referred to as embedded_H
Tape states y1 and y2 are removed for clarity
Figure 12.2 indicates that the qy state is never removed

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When embedded_H bases its halt status decision on the behavior of ⟨Ĥ⟩ ⟨Ĥ⟩
correctly simulated by embedded_H

then it is a verified fact that ⟨Ĥ⟩ correctly simulated by embedded_H
cannot possibly reach its own simulated final state of ⟨Ĥ.qn⟩ in any
finite number of simulated steps thus never halts.

*computation that halts* … the Turing machine will halt whenever it
enters a final state. (Linz:1990:234)

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2/23/23 11:38 PM, olcott wrote:
> On 2/23/2023 9:40 PM, olcott wrote:
>> When we see that all "rebuttals" are either changing the subject with
>> the strawman deception or ad hominem personal attacks then we see that
>> even dishonest reviewers are implicitly affirming that the point has
>> been proved.
>>
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [00001d23] 83c408     add esp,+08
>>   [00001d26] 8945fc     mov [ebp-04],eax
>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>   [00001d2d] 7402       jz 00001d31
>>   [00001d2f] ebfe       jmp 00001d2f
>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>   [00001d34] 8be5       mov esp,ebp
>>   [00001d36] 5d         pop ebp
>>   [00001d37] c3         ret
>>
>> It is a verified fact that H correctly predicts that D correctly
>> simulated by H cannot possibly reach its final state and halt in any
>> finite number of steps.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> It is a verified fact that neither the directly executed D(D) nor D
>> correctly simulated by H would ever stop running unless unless H aborts
>> its simulation of D. This conclusively proves that H is correct to
>> reject its input as non-halting.
>>
>> It is a verified fact that when H(D,D) correctly determines that its
>> input never halts that H is correct to reject this input as non-halting.
>>
>> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
>
> https://www.liarparadox.org/Linz_Proof.pdf
> Simplified notational conventions for Linz Ĥ at the top of page 3
>
> The paper indicates that Ĥ is created entirely from prepending and
> appending states to the original Linz H. I refer to this middle H as
> embedded_H.
>

Which means your embedded_H is identical to H, and thus does exactly the
same thing as H does for every input.

> q0 is named Ĥ.q0
> The variable Wm is referred to by its value ⟨Ĥ⟩
> The second start state Ĥq0 is referred to as embedded_H
> Tape states y1 and y2 are removed for clarity
> Figure 12.2 indicates that the qy state is never removed

Right, qy is reached if H decided Halting, at which point Ĥ to be
contray just loop. Your H NEVER decides this input is halting, so that
path becomes unreached code.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞

Which only happens if H/embedded_H decided halting.

> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Which happens when H/embeedded_H decides non-halting, at which point Ĥ
will halt making H/embedded_H just wrong.

>
> When embedded_H bases its halt status decision on the behavior of ⟨Ĥ⟩ ⟨Ĥ⟩
> correctly simulated by embedded_H

Not quite, it bases its halt status decision on the behavior of its
input, that is ⟨Ĥ⟩ ⟨Ĥ⟩, partially simulated by H/embedded_H.

Note, since your embedded_H aborts its simulation, the fact that the
simulation never reaches a final state becomes a meaningless fact.

>
> then it is a verified fact that ⟨Ĥ⟩ correctly simulated by embedded_H
> cannot possibly reach its own simulated final state of ⟨Ĥ.qn⟩ in any
> finite number of simulated steps thus never halts.

No, because since you has stated that H will abort it simulation of its
simulaiton of that same input, it is a FACT that embedded_H will do the
same thing and go to Ĥ.qn and then the Ĥ will halt.

embedded_H DOESN'T simulate for "any finite number of steps" but will
ALWAYS abort its input at precisely the same point every time, because
H/embedded_H is a specific program.

The error is assuming that embedded_H NEEDS to reach a final state of
its simulaton for the Ĥ to halt, which is false because we need to look
at the behavior of the Ĥ that is USING embedded_H, not the machine that
it is simulating.

>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
>
>

Right, you need to look at the ACTUAL MACHINE Ĥ, not the aborted
simulation done by H/embedded_H.

Aborted simulatons, by themselvrs, prove nothing.

Ĥ ⟨Ĥ⟩ will halt, thus the correct answer is Halting.

You are showing you don't understand that programs are what they are and
you can't talk about them acting differently in a way that affects other
copies of them at the input.

Change H to a H* that simulates enough farther and give it this same ⟨Ĥ⟩
⟨Ĥ⟩ input, and it will simulate it to its final state. This PROVES that
the correct simulation of the input will halt, and thus the correct
answer is Halting.

On 2/23/2023 9:40 PM, olcott wrote:
> When we see that all "rebuttals" are either changing the subject with
> the strawman deception or ad hominem personal attacks then we see that
> even dishonest reviewers are implicitly affirming that the point has
> been proved.
>
>
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> *D simulated by H cannot correctly reach its ret instruction and halt*
>
> _D()
>  [00001d12] 55         push ebp
>  [00001d13] 8bec       mov ebp,esp
>  [00001d15] 51         push ecx
>  [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>  [00001d19] 50         push eax         // push D
>  [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>  [00001d1d] 51         push ecx         // push D
>  [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>  [00001d23] 83c408     add esp,+08
>  [00001d26] 8945fc     mov [ebp-04],eax
>  [00001d29] 837dfc00   cmp dword [ebp-04],+00
>  [00001d2d] 7402       jz 00001d31
>  [00001d2f] ebfe       jmp 00001d2f
>  [00001d31] 8b45fc     mov eax,[ebp-04]
>  [00001d34] 8be5       mov esp,ebp
>  [00001d36] 5d         pop ebp
>  [00001d37] c3         ret
>
> It is a verified fact that H correctly predicts that D correctly
> simulated by H cannot possibly reach its final state and halt in any
> finite number of steps.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> It is a verified fact that neither the directly executed D(D) nor D
> correctly simulated by H would ever stop running unless unless H aborts
> its simulation of D. This conclusively proves that H is correct to
> reject its input as non-halting.
>
> It is a verified fact that when H(D,D) correctly determines that its
> input never halts that H is correct to reject this input as non-halting.
>
> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

People that only respond to this work with ad hominem the strawman
deception validate this work on the basis that they have run out of
valid rebuttals.

Honest reviews could point out some mistake. They don't point about any
mistakes because everything that I have said is a verified fact and they
know it.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2/23/2023 10:38 PM, olcott wrote:
> On 2/23/2023 9:40 PM, olcott wrote:
>> When we see that all "rebuttals" are either changing the subject with
>> the strawman deception or ad hominem personal attacks then we see that
>> even dishonest reviewers are implicitly affirming that the point has
>> been proved.
>>
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [00001d23] 83c408     add esp,+08
>>   [00001d26] 8945fc     mov [ebp-04],eax
>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>   [00001d2d] 7402       jz 00001d31
>>   [00001d2f] ebfe       jmp 00001d2f
>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>   [00001d34] 8be5       mov esp,ebp
>>   [00001d36] 5d         pop ebp
>>   [00001d37] c3         ret
>>
>> It is a verified fact that H correctly predicts that D correctly
>> simulated by H cannot possibly reach its final state and halt in any
>> finite number of steps.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> It is a verified fact that neither the directly executed D(D) nor D
>> correctly simulated by H would ever stop running unless unless H aborts
>> its simulation of D. This conclusively proves that H is correct to
>> reject its input as non-halting.
>>
>> It is a verified fact that when H(D,D) correctly determines that its
>> input never halts that H is correct to reject this input as non-halting.
>>
>> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
>
> https://www.liarparadox.org/Linz_Proof.pdf
> Simplified notational conventions for Linz Ĥ at the top of page 3
>
> The paper indicates that Ĥ is created entirely from prepending and
> appending states to the original Linz H. I refer to this middle H as
> embedded_H.
>
> q0 is named Ĥ.q0
> The variable Wm is referred to by its value ⟨Ĥ⟩
> The second start state Ĥq0 is referred to as embedded_H
> Tape states y1 and y2 are removed for clarity
> Figure 12.2 indicates that the qy state is never removed
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When embedded_H bases its halt status decision on the behavior of ⟨Ĥ⟩ ⟨Ĥ⟩
> correctly simulated by embedded_H
>
> then it is a verified fact that ⟨Ĥ⟩ correctly simulated by embedded_H
> cannot possibly reach its own simulated final state of ⟨Ĥ.qn⟩ in any
> finite number of simulated steps thus never halts.
>
> *computation that halts* … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)

Dishonest reviewers make sure to distract attention away from the
verified fact that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot
possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
of correctly simulated steps.

This conclusively proves that the ⟨Ĥ⟩ ⟨Ĥ⟩ input to embedded_H never halts
thus conclusively proving that embedded_H is correct to abort this
simulation and transition to it own final state of Ĥ.qn.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 2/24/23 11:34 AM, olcott wrote:
> On 2/23/2023 9:40 PM, olcott wrote:
>> When we see that all "rebuttals" are either changing the subject with
>> the strawman deception or ad hominem personal attacks then we see that
>> even dishonest reviewers are implicitly affirming that the point has
>> been proved.
>>
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>
>> _D()
>>   [00001d12] 55         push ebp
>>   [00001d13] 8bec       mov ebp,esp
>>   [00001d15] 51         push ecx
>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>   [00001d19] 50         push eax         // push D
>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>   [00001d1d] 51         push ecx         // push D
>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>   [00001d23] 83c408     add esp,+08
>>   [00001d26] 8945fc     mov [ebp-04],eax
>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>   [00001d2d] 7402       jz 00001d31
>>   [00001d2f] ebfe       jmp 00001d2f
>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>   [00001d34] 8be5       mov esp,ebp
>>   [00001d36] 5d         pop ebp
>>   [00001d37] c3         ret
>>
>> It is a verified fact that H correctly predicts that D correctly
>> simulated by H cannot possibly reach its final state and halt in any
>> finite number of steps.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> It is a verified fact that neither the directly executed D(D) nor D
>> correctly simulated by H would ever stop running unless unless H aborts
>> its simulation of D. This conclusively proves that H is correct to
>> reject its input as non-halting.
>>
>> It is a verified fact that when H(D,D) correctly determines that its
>> input never halts that H is correct to reject this input as non-halting.
>>
>> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
> People that only respond to this work with ad hominem the strawman
> deception validate this work on the basis that they have run out of
> valid rebuttals.

So, you don't know the meaning of ad mominem.

>
> Honest reviews could point out some mistake. They don't point about any
> mistakes because everything that I have said is a verified fact and they
> know it.
>
>

Your mistakes HAVE been pointed out.

Your inability to understand them prove your incompentence.

The fact that you claim an clearly false statement, that a Halting
Decider can some how claim an input is non-halting when you admit that
the machine the input is acking about Halts, proves you are just a liar.

And it proves all the negative statement about you are likely true.

You have just wasted the last decades of your life, if not all of it,
based on your inability to think clearly.

You seem to have lived a life filled with self-deception.

On 2/24/23 11:42 AM, olcott wrote:
> On 2/23/2023 10:38 PM, olcott wrote:
>> On 2/23/2023 9:40 PM, olcott wrote:
>>> When we see that all "rebuttals" are either changing the subject with
>>> the strawman deception or ad hominem personal attacks then we see that
>>> even dishonest reviewers are implicitly affirming that the point has
>>> been proved.
>>>
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> *D simulated by H cannot correctly reach its ret instruction and halt*
>>>
>>> _D()
>>>   [00001d12] 55         push ebp
>>>   [00001d13] 8bec       mov ebp,esp
>>>   [00001d15] 51         push ecx
>>>   [00001d16] 8b4508     mov eax,[ebp+08] // move 1st argument to eax
>>>   [00001d19] 50         push eax         // push D
>>>   [00001d1a] 8b4d08     mov ecx,[ebp+08] // move 1st argument to ecx
>>>   [00001d1d] 51         push ecx         // push D
>>>   [00001d1e] e83ff8ffff call 00001562    // call H same as H(D,D)
>>>   [00001d23] 83c408     add esp,+08
>>>   [00001d26] 8945fc     mov [ebp-04],eax
>>>   [00001d29] 837dfc00   cmp dword [ebp-04],+00
>>>   [00001d2d] 7402       jz 00001d31
>>>   [00001d2f] ebfe       jmp 00001d2f
>>>   [00001d31] 8b45fc     mov eax,[ebp-04]
>>>   [00001d34] 8be5       mov esp,ebp
>>>   [00001d36] 5d         pop ebp
>>>   [00001d37] c3         ret
>>>
>>> It is a verified fact that H correctly predicts that D correctly
>>> simulated by H cannot possibly reach its final state and halt in any
>>> finite number of steps.
>>>
>>> *computation that halts* … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> It is a verified fact that neither the directly executed D(D) nor D
>>> correctly simulated by H would ever stop running unless unless H aborts
>>> its simulation of D. This conclusively proves that H is correct to
>>> reject its input as non-halting.
>>>
>>> It is a verified fact that when H(D,D) correctly determines that its
>>> input never halts that H is correct to reject this input as non-halting.
>>>
>>> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
>>> Lexington/Toronto: D. C. Heath and Company. (317-320)
>>>
>>>
>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>
>>
>>
>> https://www.liarparadox.org/Linz_Proof.pdf
>> Simplified notational conventions for Linz Ĥ at the top of page 3
>>
>> The paper indicates that Ĥ is created entirely from prepending and
>> appending states to the original Linz H. I refer to this middle H as
>> embedded_H.
>>
>> q0 is named Ĥ.q0
>> The variable Wm is referred to by its value ⟨Ĥ⟩
>> The second start state Ĥq0 is referred to as embedded_H
>> Tape states y1 and y2 are removed for clarity
>> Figure 12.2 indicates that the qy state is never removed
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When embedded_H bases its halt status decision on the behavior of ⟨Ĥ⟩ ⟨Ĥ⟩
>> correctly simulated by embedded_H
>>
>> then it is a verified fact that ⟨Ĥ⟩ correctly simulated by embedded_H
>> cannot possibly reach its own simulated final state of ⟨Ĥ.qn⟩ in any
>> finite number of simulated steps thus never halts.
>>
>> *computation that halts* … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
>
> Dishonest reviewers make sure to distract attention away from the
> verified fact that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot
> possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
> of correctly simulated steps.
>
> This conclusively proves that the ⟨Ĥ⟩ ⟨Ĥ⟩ input to embedded_H never halts
> thus conclusively proving that embedded_H is correct to abort this
> simulation and transition to it own final state of Ĥ.qn.
>

None of which matters since halting isn't about the simulation done by
the decider byt the actual behavior of the machine the input describes.

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run forever.

Since D(D) Halts when H(D,D) returns non-halting, that answer can never
be correct for a Halt Decider, BY DEFINITION.

You are just proving that you are not working on the Halting Problem,
but on your Strawman POOP.

Hey. You look like a tech fan.
Have You looked the tool for getting faster webpages:
superfastdatabase.000webhostapp.com/a.html
?

Thank You for attention.

Kristjan Robam

On Saturday, February 25, 2023 at 3:11:38 AM UTC+2, Richard Damon wrote:
> On 2/24/23 11:42 AM, olcott wrote:
> > On 2/23/2023 10:38 PM, olcott wrote:
> >> On 2/23/2023 9:40 PM, olcott wrote:
> >>> When we see that all "rebuttals" are either changing the subject with
> >>> the strawman deception or ad hominem personal attacks then we see that
> >>> even dishonest reviewers are implicitly affirming that the point has
> >>> been proved.
> >>>
> >>>
> >>> int D(int (*x)())
> >>> {
> >>> int Halt_Status = H(x, x);
> >>> if (Halt_Status)
> >>> HERE: goto HERE;
> >>> return Halt_Status;
> >>> }
> >>>
> >>> *D simulated by H cannot correctly reach its ret instruction and halt*
> >>>
> >>> _D()
> >>> [00001d12] 55 push ebp
> >>> [00001d13] 8bec mov ebp,esp
> >>> [00001d15] 51 push ecx
> >>> [00001d16] 8b4508 mov eax,[ebp+08] // move 1st argument to eax
> >>> [00001d19] 50 push eax // push D
> >>> [00001d1a] 8b4d08 mov ecx,[ebp+08] // move 1st argument to ecx
> >>> [00001d1d] 51 push ecx // push D
> >>> [00001d1e] e83ff8ffff call 00001562 // call H same as H(D,D)
> >>> [00001d23] 83c408 add esp,+08
> >>> [00001d26] 8945fc mov [ebp-04],eax
> >>> [00001d29] 837dfc00 cmp dword [ebp-04],+00
> >>> [00001d2d] 7402 jz 00001d31
> >>> [00001d2f] ebfe jmp 00001d2f
> >>> [00001d31] 8b45fc mov eax,[ebp-04]
> >>> [00001d34] 8be5 mov esp,ebp
> >>> [00001d36] 5d pop ebp
> >>> [00001d37] c3 ret
> >>>
> >>> It is a verified fact that H correctly predicts that D correctly
> >>> simulated by H cannot possibly reach its final state and halt in any
> >>> finite number of steps.
> >>>
> >>> *computation that halts* … the Turing machine will halt whenever it
> >>> enters a final state. (Linz:1990:234)
> >>>
> >>> It is a verified fact that neither the directly executed D(D) nor D
> >>> correctly simulated by H would ever stop running unless unless H aborts
> >>> its simulation of D. This conclusively proves that H is correct to
> >>> reject its input as non-halting.
> >>>
> >>> It is a verified fact that when H(D,D) correctly determines that its
> >>> input never halts that H is correct to reject this input as non-halting.
> >>>
> >>> *Linz, Peter 1990*. An Introduction to Formal Languages and Automata.
> >>> Lexington/Toronto: D. C. Heath and Company. (317-320)
> >>>
> >>>
> >>> *Simulating Halt Deciders Defeat the Halting Theorem*
> >>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
> >>>
> >>
> >>
> >> https://www.liarparadox.org/Linz_Proof.pdf
> >> Simplified notational conventions for Linz Ĥ at the top of page 3
> >>
> >> The paper indicates that Ĥ is created entirely from prepending and
> >> appending states to the original Linz H. I refer to this middle H as
> >> embedded_H.
> >>
> >> q0 is named Ĥ.q0
> >> The variable Wm is referred to by its value ⟨Ĥ⟩
> >> The second start state Ĥq0 is referred to as embedded_H
> >> Tape states y1 and y2 are removed for clarity
> >> Figure 12.2 indicates that the qy state is never removed
> >>
> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>
> >> When embedded_H bases its halt status decision on the behavior of ⟨Ĥ⟩ ⟨Ĥ⟩
> >> correctly simulated by embedded_H
> >>
> >> then it is a verified fact that ⟨Ĥ⟩ correctly simulated by embedded_H
> >> cannot possibly reach its own simulated final state of ⟨Ĥ..qn⟩ in any
> >> finite number of simulated steps thus never halts.
> >>
> >> *computation that halts* … the Turing machine will halt whenever it
> >> enters a final state. (Linz:1990:234)
> >
> >
> > Dishonest reviewers make sure to distract attention away from the
> > verified fact that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot
> > possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
> > of correctly simulated steps.
> >
> > This conclusively proves that the ⟨Ĥ⟩ ⟨Ĥ⟩ input to embedded_H never halts
> > thus conclusively proving that embedded_H is correct to abort this
> > simulation and transition to it own final state of Ĥ.qn.
> >
> None of which matters since halting isn't about the simulation done by
> the decider byt the actual behavior of the machine the input describes.
> In computability theory, the halting problem is the problem of
> determining, from a description of an arbitrary computer program and an
> input, whether the program will finish running, or continue to run forever.
> Since D(D) Halts when H(D,D) returns non-halting, that answer can never
> be correct for a Halt Decider, BY DEFINITION.
>
> You are just proving that you are not working on the Halting Problem,
> but on your Strawman POOP.

On 24/02/2023 3:59 am, Richard Damon wrote:
> On 2/23/23 10:40 PM, olcott wrote:
>> When we see that all "rebuttals" are either changing the subject with
>> the strawman deception or ad hominem personal attacks then we see that
>> even dishonest reviewers are implicitly affirming that the point has
>> been proved.
>
> WHAT changing of subject.
>
> You are CLAIMING to be working on the Halting Problem so talking about
> the Halting Problem is on topic.
>
> You also don't understand what an ad hominem attack is, so you are just
> proving your ignorance. (Note, that is NOT ad hominem, as it isn't
> saying you arguement is wrong because of a characteristic of you, but is
> pointing out that it has been shown via actual logic that you are wrong,
> and that FACT demonstrartes a property of you.
>
> DEFINITIONS -> you are wrong -> thus demonstrating -> you are ignorant.

Except we need to replace "thus demonstrating" with "because" if we are
really honest about it.

/Flibble