On 11/11/2022 6:29 PM, Richard Damon wrote:
> On 11/11/22 7:05 PM, olcott wrote:
>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>> On 11/11/22 6:39 PM, olcott wrote:
>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>> would have
>>>>>>>>>>>>>> thought given your intelligence you would also understand
>>>>>>>>>>>>>> that.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked
>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>
>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>> archives, I want enough evidence to be around to point out
>>>>>>>>>>>>> his errors.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>
>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>> doesn't actually know what he is talking about, and reveals
>>>>>>>>>>>>> his ignorance. If he tries to put his explanation into
>>>>>>>>>>>>> explicit words, his errors become very apparent, I think
>>>>>>>>>>>>> even to him, so he just refuses.
>>>>>>>>>>>>
>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, because *I* use the actual definition of a Halting Decider.
>>>>>>>>>>>
>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>> machine (UTM) knows that the behavior of D correctly simulated
>>>>>>>>>> by H provides H with a correct basis for its halt status
>>>>>>>>>> decision.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> void E(void (*x)())
>>>>>>>> {
>>>>>>>>    H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>> execution of E is correct to report non-halting. No shell game
>>>>>>>> can correctly deny this.
>>>>>>>>
>>>>>>>
>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>> running this conclusively proves that H is correct to abort its
>>>>>> simulation and report non-halting.
>>>>>>
>>>>>
>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>
>>>>
>>>> H only need to correctly predict that its input would never reach
>>>> its own final state and terminate normally in 1 to ∞ of correct
>>>> simulation.
>>>
>>> Right, and it does when CORRECTLY (and completely) simulated or
>>> directly executed.
>>>
>>> H just aborts its simulation too soon.
>>
>> *This is the part where you are either incompetent or a liar*
>>
>> Any expert in C knows that the correctly simulated E never reaches its
>> own final state even if an infinite number of steps are correctly
>> simulated. Thus H is correct to predict that its input never halts.
>
> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>
> It just can't be done by H.
>
> Note, the problem doesn't say "by H", that is your strawman, the problem
> just references the behavior of the program, which can be seen by direct
> execution or correct simulation.
>
> A correct simulation or direct execution will see the H simulating for a
> while, then aborting its simulation and returning 0 and E halting. (or
> you H never gave what you claim to be the correct answer).
If H waits for an inner H to abort its simulation then
this H waits for an inner H to abort its simulation then
this H waits for an inner H to abort its simulation then ...
no H ever aborts its simulation.

You aren't stupid or incompetent for not seeing this, you seem to be
dishonest not remembering all the times that I have already told you this.

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

On 11/11/2022 12:56 PM, Jeff Barnett wrote:
> On 11/11/2022 11:43 AM, Richard Damon wrote:
>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>
>>> It is my understanding that Olcott has blocked you and I would have
>>> thought given your intelligence you would also understand that.
>>>
>>> /Flibble
>>>
>>
>> I don't think he has actually blocked me, just mostly ignores me.
>>
>> I say this because at times he seems to respond to what I say, even if
>> not in a direct reply,
>>
>> Also, when someone like you replies, even if he has blocked me, he
>> will still see me.
>>
>> More importantly, If anyone naive wanders into the archives, I want
>> enough evidence to be around to point out his errors.
>
> How is that working? Do you really think that repeating yourself
> literally 1000's of times makes good reading? Almost anyone who can look
> deeply enough into the logic will notice you engaging in a supposed
> dialogue with a stone wall (actually a stone brain). After your first
> half dozen messages a few years ago, you have added nothing to the
> conversation. Time to move on.
>
>> Note also, my longer replies shows what I know and provide reasoning
>> behind the claims, showing the Truth.
>
> It's a trivial truth and few will be fooled. Further, the real truth
> tellers and teachers do not hang out in these groups or archives. Too
> many truth tellers too few acolytes shrewd enough to know who has the
> inside track on god's word. Did you know that PO, in his less lucid
> moments, thinks he's a truth teller too? Truth tellers only pass the
> word when they preach to the choir.
>
>> His short claims, and guff replies just show that he doesn't actually
>> know what he is talking about, and reveals his ignorance. If he tries
>> to put his explanation into explicit words, his errors become very
>> apparent, I think even to him, so he just refuses.
>
> So what? Rather than save the world from a babbling idiot, why not
> rescue homeless puppies at risk? You would be doing a better thing and
> would be more admired. A mathematical social worker is not needed.
>
> I think, instead, you don't know what to do with your time and have
> select this task to fill the gaps. Anyone studying the archives will
> notice that PO is the clear victor in all these threads. His head is too
> thick to be bothered by facts or sort-of facts; he's too ignorant and
> proud to be bothered by anyone else's facts or religion; and some of
> your presentations (articles) are not worded in the best way or are
> slightly misleading to someone who doesn't already know most of what you
> meant to say. (That's a problem with most of us writing articles without
> a few hours reflection before posting.) You will not win this way.
>
> Since I think you seek recognition for your efforts as a white knight
> and it's not working, I suggest you go black hat! Beat PO at his own
> game: Initiate threads five to twenty times a week; Have response chains
> where you respond significant numbers of times to your own articles; Be
> outrageous!
>
> This will only work if you devote enough time to take all of the PO
> USENET distinctions away from him. You must, every month, win the honors
> for (1) most threads started, (2) most number of responses to threads
> you have started, (3) most posts by an individual, (4) threads with
> largest number of indentations, (5) the highest number of almost
> repetitious posts - slight variations required, (6) highest percentage
> of silly capitalization, and (7) most times breaking USENET rules on
> text postings.
>
> When you follow the above seven point program (and you are well on your
> way in many of the points) you will eclipse PO and he will go POOF into
> a heap of dust. You will have won! At last. and history and the titles
> will be yours. You will be known to future USENET generations, for as
> long as the archives are maintained, as a winner.
>
> However, and this is an important however, you will have approximately
> the same impact on the truth as you do now. Why not have fun instead?

PS How are we supposed to distinguish between one of you who claims "I
am god" and another ".. If anyone naive wanders into the archives, I
want enough evidence to be around to point out his errors."? Gee, god
vs. defender of naive virtue?

Give it up. Follow Ben's plan.
--
Jeff Barnett

On 11/11/22 7:46 PM, olcott wrote:
> On 11/11/2022 6:24 PM, Richard Damon wrote:
>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> I don't think he has actually blocked me, just mostly ignores
>>>>>>>>>>>> me.
>>>>>>>>>>>>
>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>
>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked
>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>
>>>>>>>>>>>> More importantly, If anyone naive wanders into the archives,
>>>>>>>>>>>> I want enough evidence to be around to point out his errors.
>>>>>>>>>>>>
>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>
>>>>>>>>>>>> His short claims, and guff replies just show that he doesn't
>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>> ignorance. If he tries to put his explanation into explicit
>>>>>>>>>>>> words, his errors become very apparent, I think even to him,
>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>
>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, because *I* use the actual definition of a Halting Decider.
>>>>>>>>> Anyone that accepts the definition of a universal Turing machine
>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>
>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>
>>>>>>> void E(void (*x)())
>>>>>>> {
>>>>>>>      H(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>> execution of E is correct to report non-halting. No shell game can
>>>>>>> correctly deny this.
>>>>>>
>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>> CORRECT simulation, as will the diret exectuion, will halt. Note,
>>>>>> such an H doesn't do a correct simulation, so any arguement based
>>>>>> on it doing so it just WRONG.
>>>>>
>>>>> The need to abort the simulation is due to the self reference
>>>>> category error present in the proof; what Olcott is getting wrong
>>>>> is the mapping of the need to abort the simulation to a halt
>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>> INPUT.
>>>>>
>>>>> /Flibble
>>>>
>>>> Nope, no self reference.
>>>>
>>>> E just has a copy of the H that claim to be deciding it, not a
>>>> "reference" to it. Turing Machines do not have the power to directly
>>>> express a reference.
>>>
>>> Nope, if it isn't a self reference then it is infinite copies all the
>>> way down so is the same category error manifesting in a different
>>> way.
>>>
>>> /Flibble
>>>
>>
>> Only if the "decider" makes that happen, in which case it isn't
>> actually a decider.
>>
>
> It is easy to see that the correctly simulated input to embedded_H
> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When we remove extraneous complexity then
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> It is easy to see that the correctly simulated input to embedded_H
> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.

Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that it
its input doesn't stop? So a correct simulation of that input will do
that too.

Note, there is no "embedded_H" in your statement. In your arguement,
embedded_H is just a copy of H, and thus behaves EXACTLY like H. Since
H ⟨Ĥ⟩ ⟨Ĥ⟩ goes to H.qn, the embeded copy of it will.

Why doesn't that happen when Ĥ reaches that exact same code?

Mote, it doesn't matter that embedded_H won't actually correctly
simulate its input, and in fact, it CAN'T since H doesn't, and
embedded_H is just a copy of H. (or you are just a liar).

Remember
H ⟨Ĥ⟩ ⟨Ĥ⟩ is required to go to H.qy if Ĥ ⟨Ĥ⟩ will Halt and
H ⟨Ĥ⟩ ⟨Ĥ⟩ is required to go to H.qn if Ĥ ⟨Ĥ⟩ will never Halt

(Or don't you understand the part of the description you like to omit?)

Please note that none of this refers to ANY simulation to determine the
correct answer. Yes, you can replace the behavior of the machine with
the behavior of a UTM processing the input, but H isn't a UTM either,
since it abort. Also, such a UTM simulaiton isn't a piece of the
execution of H, but a specification for H, and in fact, H CAN'T just use
a UTM, as then it can't ever give a non-halting answer in finite time.

Maybe the problem is that you don't understand what you are saying.

It seems that you build the Halt Decider you describe, you need someone
to give you a Halt Decider to determine when the UTM will run forever,
and if you try to use your machine for that, it needs another halt
decider to tell it when to stop and so on. In other words, your design
fails to be finite.

On 11/11/2022 1:56 PM, Jeff Barnett wrote:
> On 11/11/2022 11:43 AM, Richard Damon wrote:
>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>
>>> It is my understanding that Olcott has blocked you and I would have
>>> thought given your intelligence you would also understand that.
>>>
>>> /Flibble
>>>
>>
>> I don't think he has actually blocked me, just mostly ignores me.
>>
>> I say this because at times he seems to respond to what I say, even if
>> not in a direct reply,
>>
>> Also, when someone like you replies, even if he has blocked me, he
>> will still see me.
>>
>> More importantly, If anyone naive wanders into the archives, I want
>> enough evidence to be around to point out his errors.
>
> How is that working? Do you really think that repeating yourself
> literally 1000's of times makes good reading? Almost anyone who can look
> deeply enough into the logic will notice you engaging in a supposed
> dialogue with a stone wall (actually a stone brain). After your first
> half dozen messages a few years ago, you have added nothing to the
> conversation. Time to move on.
>
>> Note also, my longer replies shows what I know and provide reasoning
>> behind the claims, showing the Truth.
>
> It's a trivial truth and few will be fooled. Further, the real truth
> tellers and teachers do not hang out in these groups or archives. Too
> many truth tellers too few acolytes shrewd enough to know who has the
> inside track on god's word. Did you know that PO, in his less lucid
> moments, thinks he's a truth teller too? Truth tellers only pass the
> word when they preach to the choir.
>
>> His short claims, and guff replies just show that he doesn't actually
>> know what he is talking about, and reveals his ignorance. If he tries
>> to put his explanation into explicit words, his errors become very
>> apparent, I think even to him, so he just refuses.
>
> So what? Rather than save the world from a babbling idiot, why not
> rescue homeless puppies at risk? You would be doing a better thing and
> would be more admired. A mathematical social worker is not needed.
>
> I think, instead, you don't know what to do with your time and have
> select this task to fill the gaps. Anyone studying the archives will
> notice that PO is the clear victor in all these threads. His head is too
> thick to be bothered by facts or sort-of facts; he's too ignorant and
> proud to be bothered by anyone else's facts or religion; and some of
> your presentations (articles) are not worded in the best way or are
> slightly misleading to someone who doesn't already know most of what you
> meant to say. (That's a problem with most of us writing articles without
> a few hours reflection before posting.) You will not win this way.
>
> Since I think you seek recognition for your efforts as a white knight
> and it's not working, I suggest you go black hat! Beat PO at his own
> game: Initiate threads five to twenty times a week; Have response chains
> where you respond significant numbers of times to your own articles; Be
> outrageous!
>
> This will only work if you devote enough time to take all of the PO
> USENET distinctions away from him. You must, every month, win the honors
> for (1) most threads started, (2) most number of responses to threads
> you have started, (3) most posts by an individual, (4) threads with
> largest number of indentations, (5) the highest number of almost
> repetitious posts - slight variations required, (6) highest percentage
> of silly capitalization, and (7) most times breaking USENET rules on
> text postings.
>
> When you follow the above seven point program (and you are well on your
> way in many of the points) you will eclipse PO and he will go POOF into
> a heap of dust. You will have won! At last. and history and the titles
> will be yours. You will be known to future USENET generations, for as
> long as the archives are maintained, as a winner.
>
> However, and this is an important however, you will have approximately
> the same impact on the truth as you do now. Why not have fun instead?

I made the basis of my proof much easier to understand so that anyone
that is an expert in the C programming language would be able to
understand a simulating halt decider.

void E(void (*x)())
{ H(x, x);
}

When H(D,D) returns 0 it correctly predicts that D correctly simulated
by H would never reach its own final state and terminate normally after
1 to ∞ of correct simulation.

I predict that no one will be able to find any actual error with that.

--
Copyright 2022 Pete Olcott

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

On 11/11/22 7:51 PM, olcott wrote:
> On 11/11/2022 6:29 PM, Richard Damon wrote:
>> On 11/11/22 7:05 PM, olcott wrote:
>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>> would have
>>>>>>>>>>>>>>> thought given your intelligence you would also understand
>>>>>>>>>>>>>>> that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>> archives, I want enough evidence to be around to point out
>>>>>>>>>>>>>> his errors.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his explanation
>>>>>>>>>>>>>> into explicit words, his errors become very apparent, I
>>>>>>>>>>>>>> think even to him, so he just refuses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, because *I* use the actual definition of a Halting Decider.
>>>>>>>>>>>>
>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>> simulated by H provides H with a correct basis for its halt
>>>>>>>>>>> status decision.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> void E(void (*x)())
>>>>>>>>> {
>>>>>>>>>    H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>> execution of E is correct to report non-halting. No shell game
>>>>>>>>> can correctly deny this.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>>> running this conclusively proves that H is correct to abort its
>>>>>>> simulation and report non-halting.
>>>>>>>
>>>>>>
>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>
>>>>>
>>>>> H only need to correctly predict that its input would never reach
>>>>> its own final state and terminate normally in 1 to ∞ of correct
>>>>> simulation.
>>>>
>>>> Right, and it does when CORRECTLY (and completely) simulated or
>>>> directly executed.
>>>>
>>>> H just aborts its simulation too soon.
>>>
>>> *This is the part where you are either incompetent or a liar*
>>>
>>> Any expert in C knows that the correctly simulated E never reaches
>>> its own final state even if an infinite number of steps are correctly
>>> simulated. Thus H is correct to predict that its input never halts.
>>
>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>
>> It just can't be done by H.
>>
>> Note, the problem doesn't say "by H", that is your strawman, the
>> problem just references the behavior of the program, which can be seen
>> by direct execution or correct simulation.
>>
>> A correct simulation or direct execution will see the H simulating for
>> a while, then aborting its simulation and returning 0 and E halting.
>> (or you H never gave what you claim to be the correct answer).
> If H waits for an inner H to abort its simulation then
> this H waits for an inner H to abort its simulation then
> this H waits for an inner H to abort its simulation then ...
> no H ever aborts its simulation.
>
> You aren't stupid or incompetent for not seeing this, you seem to be
> dishonest not remembering all the times that I have already told you this.
>

Right, if your H is designed THAT way, it never aborts and thus fails to
answer.

That doesn't make it right to abort without actually having proved you
know the answer.

You are just shwoing that you are a Hypocrite, as you say it is
illogical to use non-truth perseving operations, but you then use that
sort of logic to try to make your claims.

Remember, H needs to answer about the E made form IT, not some other
version of it that behaves "slightly" differently based on a general
category of pperation but a different exact process.

You need to FIRST define what EXACTLY your H is going to do. Remeber,
"Get the Right Answer" is NOT an algorithm, you need to define the
actual "mechanical" steps it will perform to get the answer.

Then you define your H^/P/D/E from that H, and compare the answer of
H(E,E) to the behavior of E(E) to see it it was right.

Based on what you have defined, either H(E,E) is going to never return
an answer, and thus this H just fails, or H(E,E) will return 0, and then
the running or correct simulation of E(E) will call that H(E,E), get
back the return of 0 and halt.

The fact that the simulation that H did was stopped gefore there doesn't
mean anything, as the correct simulation by an independent simulator shows.

You insistance otherwise just shows that you are too stupid to
understand how the logic works.

On 11/11/2022 8:15 PM, Richard Damon wrote:
> On 11/11/22 7:46 PM, olcott wrote:
>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly ignores
>>>>>>>>>>>>> me.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked
>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>
>>>>>>>>>>>>> More importantly, If anyone naive wanders into the archives,
>>>>>>>>>>>>> I want enough evidence to be around to point out his errors.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>
>>>>>>>>>>>>> His short claims, and guff replies just show that he doesn't
>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>> ignorance. If he tries to put his explanation into explicit
>>>>>>>>>>>>> words, his errors become very apparent, I think even to him,
>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>
>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, because *I* use the actual definition of a Halting Decider.
>>>>>>>>>> Anyone that accepts the definition of a universal Turing machine
>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>>
>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>
>>>>>>>> void E(void (*x)())
>>>>>>>> {
>>>>>>>>      H(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>> execution of E is correct to report non-halting. No shell game can
>>>>>>>> correctly deny this.
>>>>>>>
>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>> CORRECT simulation, as will the diret exectuion, will halt. Note,
>>>>>>> such an H doesn't do a correct simulation, so any arguement based
>>>>>>> on it doing so it just WRONG.
>>>>>>
>>>>>> The need to abort the simulation is due to the self reference
>>>>>> category error present in the proof; what Olcott is getting wrong
>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>>> INPUT.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> Nope, no self reference.
>>>>>
>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>> "reference" to it. Turing Machines do not have the power to directly
>>>>> express a reference.
>>>>
>>>> Nope, if it isn't a self reference then it is infinite copies all the
>>>> way down so is the same category error manifesting in a different
>>>> way.
>>>>
>>>> /Flibble
>>>>
>>>
>>> Only if the "decider" makes that happen, in which case it isn't
>>> actually a decider.
>>>
>>
>> It is easy to see that the correctly simulated input to embedded_H
>> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When we remove extraneous complexity then
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> It is easy to see that the correctly simulated input to embedded_H
>> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.
>
> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that it
> its input doesn't stop? So a correct simulation of that input will do
> that too.

⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩

--
Copyright 2022 Pete Olcott

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

On 11/11/2022 8:25 PM, Richard Damon wrote:
> On 11/11/22 7:51 PM, olcott wrote:
>> On 11/11/2022 6:29 PM, Richard Damon wrote:
>>> On 11/11/22 7:05 PM, olcott wrote:
>>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>>> would have
>>>>>>>>>>>>>>>> thought given your intelligence you would also
>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his explanation
>>>>>>>>>>>>>>> into explicit words, his errors become very apparent, I
>>>>>>>>>>>>>>> think even to him, so he just refuses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers
>>>>>>>>>>>>>> are not in my target audience.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>> simulated by H provides H with a correct basis for its halt
>>>>>>>>>>>> status decision.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void E(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>    H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>> execution of E is correct to report non-halting. No shell game
>>>>>>>>>> can correctly deny this.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>>>> running this conclusively proves that H is correct to abort its
>>>>>>>> simulation and report non-halting.
>>>>>>>>
>>>>>>>
>>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>>
>>>>>>
>>>>>> H only need to correctly predict that its input would never reach
>>>>>> its own final state and terminate normally in 1 to ∞ of correct
>>>>>> simulation.
>>>>>
>>>>> Right, and it does when CORRECTLY (and completely) simulated or
>>>>> directly executed.
>>>>>
>>>>> H just aborts its simulation too soon.
>>>>
>>>> *This is the part where you are either incompetent or a liar*
>>>>
>>>> Any expert in C knows that the correctly simulated E never reaches
>>>> its own final state even if an infinite number of steps are
>>>> correctly simulated. Thus H is correct to predict that its input
>>>> never halts.
>>>
>>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>>
>>> It just can't be done by H.
>>>
>>> Note, the problem doesn't say "by H", that is your strawman, the
>>> problem just references the behavior of the program, which can be
>>> seen by direct execution or correct simulation.
>>>
>>> A correct simulation or direct execution will see the H simulating
>>> for a while, then aborting its simulation and returning 0 and E
>>> halting. (or you H never gave what you claim to be the correct answer).
>> If H waits for an inner H to abort its simulation then
>> this H waits for an inner H to abort its simulation then
>> this H waits for an inner H to abort its simulation then ...
>> no H ever aborts its simulation.
>>
>> You aren't stupid or incompetent for not seeing this, you seem to be
>> dishonest not remembering all the times that I have already told you
>> this.
>>
>
> Right, if your H is designed THAT way, it never aborts and thus fails to
> answer.
>

I made the basis of my proof much easier to understand so that anyone
that is an expert in the C programming language would be able to
understand a simulating halt decider.

void E(void (*x)())
{ H(x, x);
}

When H(D,D) returns 0 it correctly predicts that D correctly simulated
by H would never reach its own final state and terminate normally after
1 to ∞ of correct simulation.

--
Copyright 2022 Pete Olcott

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

On 11/11/22 9:35 PM, olcott wrote:
> On 11/11/2022 8:15 PM, Richard Damon wrote:
>> On 11/11/22 7:46 PM, olcott wrote:
>>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>
>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly ignores
>>>>>>>>>>>>>> me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked
>>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the archives,
>>>>>>>>>>>>>> I want enough evidence to be around to point out his errors.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> His short claims, and guff replies just show that he doesn't
>>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>>> ignorance. If he tries to put his explanation into explicit
>>>>>>>>>>>>>> words, his errors become very apparent, I think even to him,
>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, because *I* use the actual definition of a Halting Decider.
>>>>>>>>>>> Anyone that accepts the definition of a universal Turing machine
>>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>>>
>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>
>>>>>>>>> void E(void (*x)())
>>>>>>>>> {
>>>>>>>>>      H(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>> execution of E is correct to report non-halting. No shell game can
>>>>>>>>> correctly deny this.
>>>>>>>>
>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt. Note,
>>>>>>>> such an H doesn't do a correct simulation, so any arguement based
>>>>>>>> on it doing so it just WRONG.
>>>>>>>
>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>> category error present in the proof; what Olcott is getting wrong
>>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>>>> INPUT.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Nope, no self reference.
>>>>>>
>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>> "reference" to it. Turing Machines do not have the power to directly
>>>>>> express a reference.
>>>>>
>>>>> Nope, if it isn't a self reference then it is infinite copies all the
>>>>> way down so is the same category error manifesting in a different
>>>>> way.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Only if the "decider" makes that happen, in which case it isn't
>>>> actually a decider.
>>>>
>>>
>>> It is easy to see that the correctly simulated input to embedded_H
>>> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When we remove extraneous complexity then
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> It is easy to see that the correctly simulated input to embedded_H
>>> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.
>>
>> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that it
>> its input doesn't stop? So a correct simulation of that input will do
>> that too.
>
> ⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>

If embedded_H does "Correctly Simulate" this input, then it is the case
that H never aborts its simulation, and thus H will never return an answer.

Since H DOES abort its simulation, since you claim it "correctly"
returns 0, embedded_H can't do a correct simulation, and thus your
statememt is meaningless.

Which way are you wrong?

You are just proving that you don't understand what you are talking
about or you are just intentionally lying about everything.

It is clear that you just don't understand how programs work.

You will be know FOREVER as someone who just tried to spread falsehoods
because they wanted to show something that wasn't actually true.

Maybe you will get some cover from Trump, as your lies aren't attempting
to do somethihng as big, but they are no better than what he has been
doiong.

On 11/11/2022 8:45 PM, Richard Damon wrote:
> On 11/11/22 9:35 PM, olcott wrote:
>> On 11/11/2022 8:15 PM, Richard Damon wrote:
>>> On 11/11/22 7:46 PM, olcott wrote:
>>>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>> ignores
>>>>>>>>>>>>>>> me.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked
>>>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the archives,
>>>>>>>>>>>>>>> I want enough evidence to be around to point out his errors.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> His short claims, and guff replies just show that he doesn't
>>>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>>>> ignorance. If he tries to put his explanation into explicit
>>>>>>>>>>>>>>> words, his errors become very apparent, I think even to him,
>>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>> Decider.
>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>> machine
>>>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>>>>
>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>
>>>>>>>>>> void E(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>      H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>> execution of E is correct to report non-halting. No shell game
>>>>>>>>>> can
>>>>>>>>>> correctly deny this.
>>>>>>>>>
>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt. Note,
>>>>>>>>> such an H doesn't do a correct simulation, so any arguement based
>>>>>>>>> on it doing so it just WRONG.
>>>>>>>>
>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>> category error present in the proof; what Olcott is getting wrong
>>>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>>>>> INPUT.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> Nope, no self reference.
>>>>>>>
>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>> "reference" to it. Turing Machines do not have the power to directly
>>>>>>> express a reference.
>>>>>>
>>>>>> Nope, if it isn't a self reference then it is infinite copies all the
>>>>>> way down so is the same category error manifesting in a different
>>>>>> way.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>> actually a decider.
>>>>>
>>>>
>>>> It is easy to see that the correctly simulated input to embedded_H
>>>> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When we remove extraneous complexity then
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> It is easy to see that the correctly simulated input to embedded_H
>>>> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.
>>>
>>> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that
>>> it its input doesn't stop? So a correct simulation of that input will
>>> do that too.
>>
>> ⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>
>
> If embedded_H does "Correctly Simulate" this input, then it is the case
> that H never aborts its simulation, and thus H will never return an answer.

Yes and when embedded_H can predict this in a finite number of steps
then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.

--
Copyright 2022 Pete Olcott

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

On 11/11/22 9:36 PM, olcott wrote:
> On 11/11/2022 8:25 PM, Richard Damon wrote:
>> On 11/11/22 7:51 PM, olcott wrote:
>>> On 11/11/2022 6:29 PM, Richard Damon wrote:
>>>> On 11/11/22 7:05 PM, olcott wrote:
>>>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and
>>>>>>>>>>>>>>>>> I would have
>>>>>>>>>>>>>>>>> thought given your intelligence you would also
>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I say this because at times he seems to respond to what
>>>>>>>>>>>>>>>> I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>> explanation into explicit words, his errors become very
>>>>>>>>>>>>>>>> apparent, I think even to him, so he just refuses.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers
>>>>>>>>>>>>>>> are not in my target audience.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>> simulated by H provides H with a correct basis for its halt
>>>>>>>>>>>>> status decision.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>    H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>>>>> running this conclusively proves that H is correct to abort its
>>>>>>>>> simulation and report non-halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>>>
>>>>>>>
>>>>>>> H only need to correctly predict that its input would never reach
>>>>>>> its own final state and terminate normally in 1 to ∞ of correct
>>>>>>> simulation.
>>>>>>
>>>>>> Right, and it does when CORRECTLY (and completely) simulated or
>>>>>> directly executed.
>>>>>>
>>>>>> H just aborts its simulation too soon.
>>>>>
>>>>> *This is the part where you are either incompetent or a liar*
>>>>>
>>>>> Any expert in C knows that the correctly simulated E never reaches
>>>>> its own final state even if an infinite number of steps are
>>>>> correctly simulated. Thus H is correct to predict that its input
>>>>> never halts.
>>>>
>>>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>>>
>>>> It just can't be done by H.
>>>>
>>>> Note, the problem doesn't say "by H", that is your strawman, the
>>>> problem just references the behavior of the program, which can be
>>>> seen by direct execution or correct simulation.
>>>>
>>>> A correct simulation or direct execution will see the H simulating
>>>> for a while, then aborting its simulation and returning 0 and E
>>>> halting. (or you H never gave what you claim to be the correct answer).
>>> If H waits for an inner H to abort its simulation then
>>> this H waits for an inner H to abort its simulation then
>>> this H waits for an inner H to abort its simulation then ...
>>> no H ever aborts its simulation.
>>>
>>> You aren't stupid or incompetent for not seeing this, you seem to be
>>> dishonest not remembering all the times that I have already told you
>>> this.
>>>
>>
>> Right, if your H is designed THAT way, it never aborts and thus fails
>> to answer.
>>
>
> I made the basis of my proof much easier to understand so that anyone
> that is an expert in the C programming language would be able to
> understand a simulating halt decider.
>
> void E(void (*x)())
> {
>   H(x, x);
> }
>
> When H(D,D) returns 0 it correctly predicts that D correctly simulated
> by H would never reach its own final state and terminate normally after
> 1 to ∞ of correct simulation.
>
>

On 11/11/22 9:48 PM, olcott wrote:
> On 11/11/2022 8:45 PM, Richard Damon wrote:
>> On 11/11/22 9:35 PM, olcott wrote:
>>> On 11/11/2022 8:15 PM, Richard Damon wrote:
>>>> On 11/11/22 7:46 PM, olcott wrote:
>>>>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>
>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>> ignores
>>>>>>>>>>>>>>>> me.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked
>>>>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>> archives,
>>>>>>>>>>>>>>>> I want enough evidence to be around to point out his
>>>>>>>>>>>>>>>> errors.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>>>>> ignorance. If he tries to put his explanation into explicit
>>>>>>>>>>>>>>>> words, his errors become very apparent, I think even to
>>>>>>>>>>>>>>>> him,
>>>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>> machine
>>>>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>>>>>
>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>
>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>      H(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>> game can
>>>>>>>>>>> correctly deny this.
>>>>>>>>>>
>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt. Note,
>>>>>>>>>> such an H doesn't do a correct simulation, so any arguement based
>>>>>>>>>> on it doing so it just WRONG.
>>>>>>>>>
>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>> category error present in the proof; what Olcott is getting wrong
>>>>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>>>>>> INPUT.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Nope, no self reference.
>>>>>>>>
>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>> directly
>>>>>>>> express a reference.
>>>>>>>
>>>>>>> Nope, if it isn't a self reference then it is infinite copies all
>>>>>>> the
>>>>>>> way down so is the same category error manifesting in a different
>>>>>>> way.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>> actually a decider.
>>>>>>
>>>>>
>>>>> It is easy to see that the correctly simulated input to embedded_H
>>>>> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> When we remove extraneous complexity then
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> It is easy to see that the correctly simulated input to embedded_H
>>>>> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.
>>>>
>>>> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that
>>>> it its input doesn't stop? So a correct simulation of that input
>>>> will do that too.
>>>
>>> ⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>
>>
>> If embedded_H does "Correctly Simulate" this input, then it is the
>> case that H never aborts its simulation, and thus H will never return
>> an answer.
>
> Yes and when embedded_H can predict this in a finite number of steps
> then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>

On 11/11/2022 8:51 PM, Richard Damon wrote:
> On 11/11/22 9:36 PM, olcott wrote:
>> On 11/11/2022 8:25 PM, Richard Damon wrote:
>>> On 11/11/22 7:51 PM, olcott wrote:
>>>> On 11/11/2022 6:29 PM, Richard Damon wrote:
>>>>> On 11/11/22 7:05 PM, olcott wrote:
>>>>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and
>>>>>>>>>>>>>>>>>> I would have
>>>>>>>>>>>>>>>>>> thought given your intelligence you would also
>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to what
>>>>>>>>>>>>>>>>> I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become very
>>>>>>>>>>>>>>>>> apparent, I think even to him, so he just refuses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers
>>>>>>>>>>>>>>>> are not in my target audience.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>>>>>> running this conclusively proves that H is correct to abort
>>>>>>>>>> its simulation and report non-halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> H only need to correctly predict that its input would never
>>>>>>>> reach its own final state and terminate normally in 1 to ∞ of
>>>>>>>> correct simulation.
>>>>>>>
>>>>>>> Right, and it does when CORRECTLY (and completely) simulated or
>>>>>>> directly executed.
>>>>>>>
>>>>>>> H just aborts its simulation too soon.
>>>>>>
>>>>>> *This is the part where you are either incompetent or a liar*
>>>>>>
>>>>>> Any expert in C knows that the correctly simulated E never reaches
>>>>>> its own final state even if an infinite number of steps are
>>>>>> correctly simulated. Thus H is correct to predict that its input
>>>>>> never halts.
>>>>>
>>>>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>>>>
>>>>> It just can't be done by H.
>>>>>
>>>>> Note, the problem doesn't say "by H", that is your strawman, the
>>>>> problem just references the behavior of the program, which can be
>>>>> seen by direct execution or correct simulation.
>>>>>
>>>>> A correct simulation or direct execution will see the H simulating
>>>>> for a while, then aborting its simulation and returning 0 and E
>>>>> halting. (or you H never gave what you claim to be the correct
>>>>> answer).
>>>> If H waits for an inner H to abort its simulation then
>>>> this H waits for an inner H to abort its simulation then
>>>> this H waits for an inner H to abort its simulation then ...
>>>> no H ever aborts its simulation.
>>>>
>>>> You aren't stupid or incompetent for not seeing this, you seem to be
>>>> dishonest not remembering all the times that I have already told you
>>>> this.
>>>>
>>>
>>> Right, if your H is designed THAT way, it never aborts and thus fails
>>> to answer.
>>>
>>
>> I made the basis of my proof much easier to understand so that anyone
>> that is an expert in the C programming language would be able to
>> understand a simulating halt decider.
>>
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>> When H(D,D) returns 0 it correctly predicts that D correctly simulated
>> by H would never reach its own final state and terminate normally
>> after 1 to ∞ of correct simulation.
>>
>>
>
> Except that it didn't correctly predict that, as it can't correctly
> predict that as the actual correct simulation of the input by a real
> correct simulator, which will agree with the direct exectuion of the
> input, shows that it does reach the final state, after the point that H
> gives up.
You and I can both see that
the correct and complete simulation of D by H never reaches its final
state in 1 to ∞ steps of correct simulation

On 11/11/2022 7:43 PM, Jeff Barnett wrote:
> On 11/11/2022 12:56 PM, Jeff Barnett wrote:
>> On 11/11/2022 11:43 AM, Richard Damon wrote:
>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>
>>>> It is my understanding that Olcott has blocked you and I would have
>>>> thought given your intelligence you would also understand that.
>>>>
>>>> /Flibble
>>>>
>>>
>>> I don't think he has actually blocked me, just mostly ignores me.
>>>
>>> I say this because at times he seems to respond to what I say, even
>>> if not in a direct reply,
>>>
>>> Also, when someone like you replies, even if he has blocked me, he
>>> will still see me.
>>>
>>> More importantly, If anyone naive wanders into the archives, I want
>>> enough evidence to be around to point out his errors.
>>
>> How is that working? Do you really think that repeating yourself
>> literally 1000's of times makes good reading? Almost anyone who can
>> look deeply enough into the logic will notice you engaging in a
>> supposed dialogue with a stone wall (actually a stone brain). After
>> your first half dozen messages a few years ago, you have added nothing
>> to the conversation. Time to move on.
>>
>>> Note also, my longer replies shows what I know and provide reasoning
>>> behind the claims, showing the Truth.
>>
>> It's a trivial truth and few will be fooled. Further, the real truth
>> tellers and teachers do not hang out in these groups or archives. Too
>> many truth tellers too few acolytes shrewd enough to know who has the
>> inside track on god's word. Did you know that PO, in his less lucid
>> moments, thinks he's a truth teller too? Truth tellers only pass the
>> word when they preach to the choir.
>>
>>> His short claims, and guff replies just show that he doesn't actually
>>> know what he is talking about, and reveals his ignorance. If he tries
>>> to put his explanation into explicit words, his errors become very
>>> apparent, I think even to him, so he just refuses.
>>
>> So what? Rather than save the world from a babbling idiot, why not
>> rescue homeless puppies at risk? You would be doing a better thing and
>> would be more admired. A mathematical social worker is not needed.
>>
>> I think, instead, you don't know what to do with your time and have
>> select this task to fill the gaps. Anyone studying the archives will
>> notice that PO is the clear victor in all these threads. His head is
>> too thick to be bothered by facts or sort-of facts; he's too ignorant
>> and proud to be bothered by anyone else's facts or religion; and some
>> of your presentations (articles) are not worded in the best way or are
>> slightly misleading to someone who doesn't already know most of what
>> you meant to say. (That's a problem with most of us writing articles
>> without a few hours reflection before posting.) You will not win this
>> way.
>>
>> Since I think you seek recognition for your efforts as a white knight
>> and it's not working, I suggest you go black hat! Beat PO at his own
>> game: Initiate threads five to twenty times a week; Have response
>> chains where you respond significant numbers of times to your own
>> articles; Be outrageous!
>>
>> This will only work if you devote enough time to take all of the PO
>> USENET distinctions away from him. You must, every month, win the
>> honors for (1) most threads started, (2) most number of responses to
>> threads you have started, (3) most posts by an individual, (4) threads
>> with largest number of indentations, (5) the highest number of almost
>> repetitious posts - slight variations required, (6) highest percentage
>> of silly capitalization, and (7) most times breaking USENET rules on
>> text postings.
>>
>> When you follow the above seven point program (and you are well on
>> your way in many of the points) you will eclipse PO and he will go
>> POOF into a heap of dust. You will have won! At last. and history and
>> the titles will be yours. You will be known to future USENET
>> generations, for as long as the archives are maintained, as a winner.
>>
>> However, and this is an important however, you will have approximately
>> the same impact on the truth as you do now. Why not have fun instead?
>
> Give it up. Follow Ben's plan.

Ben's plan is entirely based on the fact Professor Sipser decimated
Ben's only rebuttal of my work. Ben wants to actively suppress review of
my work because he can now see the clear path to my success.

--
Copyright 2022 Pete Olcott

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

On 11/11/22 9:57 PM, olcott wrote:
> On 11/11/2022 8:51 PM, Richard Damon wrote:
>> On 11/11/22 9:36 PM, olcott wrote:
>>> On 11/11/2022 8:25 PM, Richard Damon wrote:
>>>> On 11/11/22 7:51 PM, olcott wrote:
>>>>> On 11/11/2022 6:29 PM, Richard Damon wrote:
>>>>>> On 11/11/22 7:05 PM, olcott wrote:
>>>>>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>> and I would have
>>>>>>>>>>>>>>>>>>> thought given your intelligence you would also
>>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just refuses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers
>>>>>>>>>>>>>>>>> are not in my target audience.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
>>>>>>>>>>>>> infinite execution of E is correct to report non-halting.
>>>>>>>>>>>>> No shell game can correctly deny this.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>>>>>>> running this conclusively proves that H is correct to abort
>>>>>>>>>>> its simulation and report non-halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H only need to correctly predict that its input would never
>>>>>>>>> reach its own final state and terminate normally in 1 to ∞ of
>>>>>>>>> correct simulation.
>>>>>>>>
>>>>>>>> Right, and it does when CORRECTLY (and completely) simulated or
>>>>>>>> directly executed.
>>>>>>>>
>>>>>>>> H just aborts its simulation too soon.
>>>>>>>
>>>>>>> *This is the part where you are either incompetent or a liar*
>>>>>>>
>>>>>>> Any expert in C knows that the correctly simulated E never
>>>>>>> reaches its own final state even if an infinite number of steps
>>>>>>> are correctly simulated. Thus H is correct to predict that its
>>>>>>> input never halts.
>>>>>>
>>>>>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>>>>>
>>>>>> It just can't be done by H.
>>>>>>
>>>>>> Note, the problem doesn't say "by H", that is your strawman, the
>>>>>> problem just references the behavior of the program, which can be
>>>>>> seen by direct execution or correct simulation.
>>>>>>
>>>>>> A correct simulation or direct execution will see the H simulating
>>>>>> for a while, then aborting its simulation and returning 0 and E
>>>>>> halting. (or you H never gave what you claim to be the correct
>>>>>> answer).
>>>>> If H waits for an inner H to abort its simulation then
>>>>> this H waits for an inner H to abort its simulation then
>>>>> this H waits for an inner H to abort its simulation then ...
>>>>> no H ever aborts its simulation.
>>>>>
>>>>> You aren't stupid or incompetent for not seeing this, you seem to
>>>>> be dishonest not remembering all the times that I have already told
>>>>> you this.
>>>>>
>>>>
>>>> Right, if your H is designed THAT way, it never aborts and thus
>>>> fails to answer.
>>>>
>>>
>>> I made the basis of my proof much easier to understand so that anyone
>>> that is an expert in the C programming language would be able to
>>> understand a simulating halt decider.
>>>
>>> void E(void (*x)())
>>> {
>>>    H(x, x);
>>> }
>>>
>>> When H(D,D) returns 0 it correctly predicts that D correctly
>>> simulated by H would never reach its own final state and terminate
>>> normally after 1 to ∞ of correct simulation.
>>>
>>>
>>
>> Except that it didn't correctly predict that, as it can't correctly
>> predict that as the actual correct simulation of the input by a real
>> correct simulator, which will agree with the direct exectuion of the
>> input, shows that it does reach the final state, after the point that
>> H gives up.
> You and I can both see that
> the correct and complete simulation of D by H never reaches its final
> state in 1 to ∞ steps of correct simulation

On 11/11/2022 9:25 PM, Richard Damon wrote:
> On 11/11/22 9:57 PM, olcott wrote:
>> On 11/11/2022 8:51 PM, Richard Damon wrote:
>>> On 11/11/22 9:36 PM, olcott wrote:
>>>> On 11/11/2022 8:25 PM, Richard Damon wrote:
>>>>> On 11/11/22 7:51 PM, olcott wrote:
>>>>>> On 11/11/2022 6:29 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 7:05 PM, olcott wrote:
>>>>>>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>>>>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>>> and I would have
>>>>>>>>>>>>>>>>>>>> thought given your intelligence you would also
>>>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to
>>>>>>>>>>>>>>>>>>> point out his errors.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just refuses.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
>>>>>>>>>>>>>> infinite execution of E is correct to report non-halting.
>>>>>>>>>>>>>> No shell game can correctly deny this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>>> halt.
>>>>>>>>>>>> If no H ever aborts its simulation of E then no E ever stops
>>>>>>>>>>>> running this conclusively proves that H is correct to abort
>>>>>>>>>>>> its simulation and report non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> H only need to correctly predict that its input would never
>>>>>>>>>> reach its own final state and terminate normally in 1 to ∞ of
>>>>>>>>>> correct simulation.
>>>>>>>>>
>>>>>>>>> Right, and it does when CORRECTLY (and completely) simulated or
>>>>>>>>> directly executed.
>>>>>>>>>
>>>>>>>>> H just aborts its simulation too soon.
>>>>>>>>
>>>>>>>> *This is the part where you are either incompetent or a liar*
>>>>>>>>
>>>>>>>> Any expert in C knows that the correctly simulated E never
>>>>>>>> reaches its own final state even if an infinite number of steps
>>>>>>>> are correctly simulated. Thus H is correct to predict that its
>>>>>>>> input never halts.
>>>>>>>
>>>>>>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>>>>>>
>>>>>>> It just can't be done by H.
>>>>>>>
>>>>>>> Note, the problem doesn't say "by H", that is your strawman, the
>>>>>>> problem just references the behavior of the program, which can be
>>>>>>> seen by direct execution or correct simulation.
>>>>>>>
>>>>>>> A correct simulation or direct execution will see the H
>>>>>>> simulating for a while, then aborting its simulation and
>>>>>>> returning 0 and E halting. (or you H never gave what you claim to
>>>>>>> be the correct answer).
>>>>>> If H waits for an inner H to abort its simulation then
>>>>>> this H waits for an inner H to abort its simulation then
>>>>>> this H waits for an inner H to abort its simulation then ...
>>>>>> no H ever aborts its simulation.
>>>>>>
>>>>>> You aren't stupid or incompetent for not seeing this, you seem to
>>>>>> be dishonest not remembering all the times that I have already
>>>>>> told you this.
>>>>>>
>>>>>
>>>>> Right, if your H is designed THAT way, it never aborts and thus
>>>>> fails to answer.
>>>>>
>>>>
>>>> I made the basis of my proof much easier to understand so that
>>>> anyone that is an expert in the C programming language would be able
>>>> to understand a simulating halt decider.
>>>>
>>>> void E(void (*x)())
>>>> {
>>>>    H(x, x);
>>>> }
>>>>
>>>> When H(D,D) returns 0 it correctly predicts that D correctly
>>>> simulated by H would never reach its own final state and terminate
>>>> normally after 1 to ∞ of correct simulation.
>>>>
>>>>
>>>
>>> Except that it didn't correctly predict that, as it can't correctly
>>> predict that as the actual correct simulation of the input by a real
>>> correct simulator, which will agree with the direct exectuion of the
>>> input, shows that it does reach the final state, after the point that
>>> H gives up.
>> You and I can both see that
>> the correct and complete simulation of D by H never reaches its final
>> state in 1 to ∞ steps of correct simulation
>
> The H in question never does and can't do a correct and complete
> simulation of this input,

On 11/11/2022 8:56 PM, Richard Damon wrote:
> On 11/11/22 9:48 PM, olcott wrote:
>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>> On 11/11/22 9:35 PM, olcott wrote:
>>>> On 11/11/2022 8:15 PM, Richard Damon wrote:
>>>>> On 11/11/22 7:46 PM, olcott wrote:
>>>>>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>
>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>> ignores
>>>>>>>>>>>>>>>>> me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>> blocked
>>>>>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>> archives,
>>>>>>>>>>>>>>>>> I want enough evidence to be around to point out his
>>>>>>>>>>>>>>>>> errors.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>>>>>> ignorance. If he tries to put his explanation into
>>>>>>>>>>>>>>>>> explicit
>>>>>>>>>>>>>>>>> words, his errors become very apparent, I think even to
>>>>>>>>>>>>>>>>> him,
>>>>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>      H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>> game can
>>>>>>>>>>>> correctly deny this.
>>>>>>>>>>>
>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>>>>> Note,
>>>>>>>>>>> such an H doesn't do a correct simulation, so any arguement
>>>>>>>>>>> based
>>>>>>>>>>> on it doing so it just WRONG.
>>>>>>>>>>
>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>> category error present in the proof; what Olcott is getting wrong
>>>>>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>>>>>>> INPUT.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Nope, no self reference.
>>>>>>>>>
>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>> directly
>>>>>>>>> express a reference.
>>>>>>>>
>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>> all the
>>>>>>>> way down so is the same category error manifesting in a different
>>>>>>>> way.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>> actually a decider.
>>>>>>>
>>>>>>
>>>>>> It is easy to see that the correctly simulated input to embedded_H
>>>>>> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When we remove extraneous complexity then
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is easy to see that the correctly simulated input to embedded_H
>>>>>> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.
>>>>>
>>>>> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that
>>>>> it its input doesn't stop? So a correct simulation of that input
>>>>> will do that too.
>>>>
>>>> ⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>
>>>
>>> If embedded_H does "Correctly Simulate" this input, then it is the
>>> case that H never aborts its simulation, and thus H will never return
>>> an answer.
>>
>> Yes and when embedded_H can predict this in a finite number of steps
>> then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>
> Except that it can't do that since it is shown that H^ <H^> Will halt in
> this case, so it is impossible to correctly predict that a correct
> simulation of the input <H^> <H^> will not halt.
A simulating halt decider must correctly predict (in a finite number of
steps whether or not its simulated input would ever stop running if it
never aborted its simulation of its input.

On 11/11/2022 8:56 PM, Richard Damon wrote:
> On 11/11/22 9:48 PM, olcott wrote:
>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>> On 11/11/22 9:35 PM, olcott wrote:
>>>> On 11/11/2022 8:15 PM, Richard Damon wrote:
>>>>> On 11/11/22 7:46 PM, olcott wrote:
>>>>>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>
>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>>>>> would have thought given your intelligence you would also
>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>> ignores
>>>>>>>>>>>>>>>>> me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>> blocked
>>>>>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>> archives,
>>>>>>>>>>>>>>>>> I want enough evidence to be around to point out his
>>>>>>>>>>>>>>>>> errors.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>>>>>> ignorance. If he tries to put his explanation into
>>>>>>>>>>>>>>>>> explicit
>>>>>>>>>>>>>>>>> words, his errors become very apparent, I think even to
>>>>>>>>>>>>>>>>> him,
>>>>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers are
>>>>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>>>>>> provides H with a correct basis for its halt status decision.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>      H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>> game can
>>>>>>>>>>>> correctly deny this.
>>>>>>>>>>>
>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>>>>> Note,
>>>>>>>>>>> such an H doesn't do a correct simulation, so any arguement
>>>>>>>>>>> based
>>>>>>>>>>> on it doing so it just WRONG.
>>>>>>>>>>
>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>> category error present in the proof; what Olcott is getting wrong
>>>>>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>>>>>> decision of non-halting; it needs to instead be mapped to INVALID
>>>>>>>>>> INPUT.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Nope, no self reference.
>>>>>>>>>
>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>> directly
>>>>>>>>> express a reference.
>>>>>>>>
>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>> all the
>>>>>>>> way down so is the same category error manifesting in a different
>>>>>>>> way.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>> actually a decider.
>>>>>>>
>>>>>>
>>>>>> It is easy to see that the correctly simulated input to embedded_H
>>>>>> cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When we remove extraneous complexity then
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> It is easy to see that the correctly simulated input to embedded_H
>>>>>> cannot possibly reach a final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ and halt.
>>>>>
>>>>> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say that
>>>>> it its input doesn't stop? So a correct simulation of that input
>>>>> will do that too.
>>>>
>>>> ⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>
>>>
>>> If embedded_H does "Correctly Simulate" this input, then it is the
>>> case that H never aborts its simulation, and thus H will never return
>>> an answer.
>>
>> Yes and when embedded_H can predict this in a finite number of steps
>> then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>
> Except that it can't do that since it is shown that H^ <H^> Will halt in
> this case, so it is impossible to correctly predict that a correct
> simulation of the input <H^> <H^> will not halt.
>

On 11/11/2022 8:31 PM, Sergi o wrote:
> On 11/11/2022 8:21 PM, olcott wrote:
>> On 11/11/2022 1:56 PM, Jeff Barnett wrote:
>>> On 11/11/2022 11:43 AM, Richard Damon wrote:
>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>
>>>>> It is my understanding that Olcott has blocked you and I would have
>>>>> thought given your intelligence you would also understand that.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> I don't think he has actually blocked me, just mostly ignores me.
>>>>
>>>> I say this because at times he seems to respond to what I say, even
>>>> if not in a direct reply,
>>>>
>>>> Also, when someone like you replies, even if he has blocked me, he
>>>> will still see me.
>>>>
>>>> More importantly, If anyone naive wanders into the archives, I want
>>>> enough evidence to be around to point out his errors.
>>>
>>> How is that working? Do you really think that repeating yourself
>>> literally 1000's of times makes good reading? Almost anyone who can
>>> look deeply enough into the logic will notice you engaging in a
>>> supposed dialogue with a stone wall (actually a stone brain). After
>>> your first half dozen messages a few years ago, you have added
>>> nothing to the conversation. Time to move on.
>>>
>>>> Note also, my longer replies shows what I know and provide reasoning
>>>> behind the claims, showing the Truth.
>>>
>>> It's a trivial truth and few will be fooled. Further, the real truth
>>> tellers and teachers do not hang out in these groups or archives. Too
>>> many truth tellers too few acolytes shrewd enough to know who has the
>>> inside track on god's word. Did you know that PO, in his less lucid
>>> moments, thinks he's a truth teller too? Truth tellers only pass the
>>> word when they preach to the choir.
>>>
>>>> His short claims, and guff replies just show that he doesn't
>>>> actually know what he is talking about, and reveals his ignorance.
>>>> If he tries to put his explanation into explicit words, his errors
>>>> become very apparent, I think even to him, so he just refuses.
>>>
>>> So what? Rather than save the world from a babbling idiot, why not
>>> rescue homeless puppies at risk? You would be doing a better thing
>>> and would be more admired. A mathematical social worker is not needed.
>>>
>>> I think, instead, you don't know what to do with your time and have
>>> select this task to fill the gaps. Anyone studying the archives will
>>> notice that PO is the clear victor in all these threads. His head is
>>> too thick to be bothered by facts or sort-of facts; he's too ignorant
>>> and proud to be bothered by anyone else's facts or religion; and some
>>> of your presentations (articles) are not worded in the best way or
>>> are slightly misleading to someone who doesn't already know most of
>>> what you meant to say. (That's a problem with most of us writing
>>> articles without a few hours reflection before posting.) You will not
>>> win this way.
>>>
>>> Since I think you seek recognition for your efforts as a white knight
>>> and it's not working, I suggest you go black hat! Beat PO at his own
>>> game: Initiate threads five to twenty times a week; Have response
>>> chains where you respond significant numbers of times to your own
>>> articles; Be outrageous!
>>>
>>> This will only work if you devote enough time to take all of the PO
>>> USENET distinctions away from him. You must, every month, win the
>>> honors for (1) most threads started, (2) most number of responses to
>>> threads you have started, (3) most posts by an individual, (4)
>>> threads with largest number of indentations, (5) the highest number
>>> of almost repetitious posts - slight variations required, (6) highest
>>> percentage of silly capitalization, and (7) most times breaking
>>> USENET rules on text postings.
>>>
>>> When you follow the above seven point program (and you are well on
>>> your way in many of the points) you will eclipse PO and he will go
>>> POOF into a heap of dust. You will have won! At last. and history and
>>> the titles will be yours. You will be known to future USENET
>>> generations, for as long as the archives are maintained, as a winner.
>>>
>>> However, and this is an important however, you will have
>>> approximately the same impact on the truth as you do now. Why not
>>> have fun instead?
>>
>> I made the basis of my proof much easier to understand so that anyone
>> that is an expert in the C programming language would be able to
>> understand a simulating halt decider.
>>
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>> When H(D,D) returns 0 it correctly predicts that D correctly simulated
>> by H would never reach its own final state and terminate normally
>> after 1 to ∞ of correct simulation.
>>
>> I predict that no one will be able to find any actual error with that.
>>
>>
>
> if it doesn't bust the compiler, run it through a code checker, lots of
> free ones out there
>
> https://www.onlinegdb.com/online_c_compiler

The last remaining issue is the acceptance of the notion of a simulating
halt decider.
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 11/11/22 11:00 PM, olcott wrote:
> On 11/11/2022 8:56 PM, Richard Damon wrote:
>> On 11/11/22 9:48 PM, olcott wrote:
>>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>>> On 11/11/22 9:35 PM, olcott wrote:
>>
>>> Yes and when embedded_H can predict this in a finite number of steps
>>> then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> Except that it can't do that since it is shown that H^ <H^> Will halt
>> in this case, so it is impossible to correctly predict that a correct
>> simulation of the input <H^> <H^> will not halt.
> A simulating halt decider must correctly predict (in a finite number of
> steps whether or not its simulated input would ever stop running if it
> never aborted its simulation of its input.
>
>

Right, it must, but it can't. Again, your Egish is lacking because you
are too stupid.

If you claim it can, what pattern did it use to detect this, that ALWAYS
shows the program is non-halting?

I will note that E(E) calling H(E,E) is NOT such a pattern, as E(E) will
halt if H(E,E) is defined to abort that simulation and return 0.

Note, the "if it never aborted" is a fantasy claim, as H DOES abort its
simulation. In this context, your phrase means to look at the alternate
reality when THIS EXECTUTION of H has been changed, but not any others.

Because of your erroneous structure of H and E (E is supposed to be an
INDEPENDENT PROGRAM, not a piece of the program H), you can't actualy
write that hypothetical case, as it requires two different version of H
to exist together.

On 11/11/22 11:17 PM, olcott wrote:
> On 11/11/2022 8:56 PM, Richard Damon wrote:
>> On 11/11/22 9:48 PM, olcott wrote:
>>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>>> On 11/11/22 9:35 PM, olcott wrote:
>>>>> On 11/11/2022 8:15 PM, Richard Damon wrote:
>>>>>> On 11/11/22 7:46 PM, olcott wrote:
>>>>>>> On 11/11/2022 6:24 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>
>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>>>>>> would have thought given your intelligence you would
>>>>>>>>>>>>>>>>>>> also
>>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>> ignores
>>>>>>>>>>>>>>>>>> me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>> blocked
>>>>>>>>>>>>>>>>>> me, he will still see me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>> archives,
>>>>>>>>>>>>>>>>>> I want enough evidence to be around to point out his
>>>>>>>>>>>>>>>>>> errors.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>> provide
>>>>>>>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>> doesn't
>>>>>>>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>>>>>>>> ignorance. If he tries to put his explanation into
>>>>>>>>>>>>>>>>>> explicit
>>>>>>>>>>>>>>>>>> words, his errors become very apparent, I think even
>>>>>>>>>>>>>>>>>> to him,
>>>>>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You always use the strawman deception as your only basis.
>>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive readers
>>>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>>>> not in my target audience.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>> (UTM) knows that the behavior of D correctly simulated by H
>>>>>>>>>>>>>>> provides H with a correct basis for its halt status
>>>>>>>>>>>>>>> decision.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>      H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>>> game can
>>>>>>>>>>>>> correctly deny this.
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because the
>>>>>>>>>>>> CORRECT simulation, as will the diret exectuion, will halt.
>>>>>>>>>>>> Note,
>>>>>>>>>>>> such an H doesn't do a correct simulation, so any arguement
>>>>>>>>>>>> based
>>>>>>>>>>>> on it doing so it just WRONG.
>>>>>>>>>>>
>>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>>> wrong
>>>>>>>>>>> is the mapping of the need to abort the simulation to a halt
>>>>>>>>>>> decision of non-halting; it needs to instead be mapped to
>>>>>>>>>>> INVALID
>>>>>>>>>>> INPUT.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>
>>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>>> directly
>>>>>>>>>> express a reference.
>>>>>>>>>
>>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>>> all the
>>>>>>>>> way down so is the same category error manifesting in a different
>>>>>>>>> way.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>>> actually a decider.
>>>>>>>>
>>>>>>>
>>>>>>> It is easy to see that the correctly simulated input to
>>>>>>> embedded_H cannot possibly reach ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> When we remove extraneous complexity then
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> It is easy to see that the correctly simulated input to
>>>>>>> embedded_H cannot possibly reach a final state of ⟨Ĥ.qy⟩ or
>>>>>>> ⟨Ĥ.qn⟩ and halt.
>>>>>>
>>>>>> Why not? Don't you claim that H ⟨Ĥ⟩ ⟨Ĥ⟩ will go to H.qn to say
>>>>>> that it its input doesn't stop? So a correct simulation of that
>>>>>> input will do that too.
>>>>>
>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H will never reach ⟨Ĥ.qy⟩ or
>>>>> ⟨Ĥ.qn⟩
>>>>>
>>>>
>>>> If embedded_H does "Correctly Simulate" this input, then it is the
>>>> case that H never aborts its simulation, and thus H will never
>>>> return an answer.
>>>
>>> Yes and when embedded_H can predict this in a finite number of steps
>>> then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>
>> Except that it can't do that since it is shown that H^ <H^> Will halt
>> in this case, so it is impossible to correctly predict that a correct
>> simulation of the input <H^> <H^> will not halt.
>>
>
> When simulating halt decider embedded_H transitions to its reject state
> ⟨Ĥ.qn⟩ it is correctly predicting that ⟨Ĥ⟩ simulated by embedded_H would
> never reach its own final state in 1 to ∞ steps of correct simulation.
>

On Fri, 11 Nov 2022 19:24:53 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/11/22 6:55 PM, Mr Flibble wrote:
> > On Fri, 11 Nov 2022 18:25:58 -0500
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 11/11/22 4:54 PM, Mr Flibble wrote:
> >>> On Fri, 11 Nov 2022 16:44:49 -0500
> >>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>
> >>>> On 11/11/22 4:15 PM, olcott wrote:
> >>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
> >>>>>> On 11/11/22 2:39 PM, olcott wrote:
> >>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
> >>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
> >>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
> >>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
> >>>>>>>>>>
> >>>>>>>>>>> It is my understanding that Olcott has blocked you and I
> >>>>>>>>>>> would have thought given your intelligence you would also
> >>>>>>>>>>> understand that.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> I don't think he has actually blocked me, just mostly
> >>>>>>>>>> ignores me.
> >>>>>>>>>>
> >>>>>>>>>> I say this because at times he seems to respond to what I
> >>>>>>>>>> say, even if not in a direct reply,
> >>>>>>>>>>
> >>>>>>>>>> Also, when someone like you replies, even if he has blocked
> >>>>>>>>>> me, he will still see me.
> >>>>>>>>>>
> >>>>>>>>>> More importantly, If anyone naive wanders into the
> >>>>>>>>>> archives, I want enough evidence to be around to point out
> >>>>>>>>>> his errors.
> >>>>>>>>>>
> >>>>>>>>>> Note also, my longer replies shows what I know and provide
> >>>>>>>>>> reasoning behind the claims, showing the Truth.
> >>>>>>>>>>
> >>>>>>>>>> His short claims, and guff replies just show that he
> >>>>>>>>>> doesn't actually know what he is talking about, and
> >>>>>>>>>> reveals his ignorance. If he tries to put his explanation
> >>>>>>>>>> into explicit words, his errors become very apparent, I
> >>>>>>>>>> think even to him, so he just refuses.
> >>>>>>>>>
> >>>>>>>>> You always use the strawman deception as your only basis.
> >>>>>>>>> Naive readers will never notice this, yet naive readers are
> >>>>>>>>> not in my target audience.
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> No, because *I* use the actual definition of a Halting
> >>>>>>>> Decider.
> >>>>>>> Anyone that accepts the definition of a universal Turing
> >>>>>>> machine (UTM) knows that the behavior of D correctly
> >>>>>>> simulated by H provides H with a correct basis for its halt
> >>>>>>> status decision.
> >>>>>>
> >>>>>> But only if H DOES correctly simulate its input.
> >>>>>>
> >>>>>
> >>>>> void E(void (*x)())
> >>>>> {
> >>>>>   H(x, x);
> >>>>> }
> >>>>>
> >>>>> Any H that does abort its simulation to prevent the infinite
> >>>>> execution of E is correct to report non-halting. No shell game
> >>>>> can correctly deny this.
> >>>>>
> >>>>
> >>>> Any H that does aborts its simulation is INCORRECT because the
> >>>> CORRECT simulation, as will the diret exectuion, will halt. Note,
> >>>> such an H doesn't do a correct simulation, so any arguement based
> >>>> on it doing so it just WRONG.
> >>>
> >>> The need to abort the simulation is due to the self reference
> >>> category error present in the proof; what Olcott is getting wrong
> >>> is the mapping of the need to abort the simulation to a halt
> >>> decision of non-halting; it needs to instead be mapped to INVALID
> >>> INPUT.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Nope, no self reference.
> >>
> >> E just has a copy of the H that claim to be deciding it, not a
> >> "reference" to it. Turing Machines do not have the power to
> >> directly express a reference.
> >
> > Nope, if it isn't a self reference then it is infinite copies all
> > the way down so is the same category error manifesting in a
> > different way.
> >
> > /Flibble
> >
>
> Only if the "decider" makes that happen, in which case it isn't
> actually a decider.
>
> If we assume a prospective decider exists, then the "Impossible"
> program is simple to make from it, and is given one copy of the
> description of itself, which is also simple to make.
>
> When run it makes a second copy of its description, and then calls
> the decider.
>
> After that, it is the deciders job to make the decision in finite
> time, by whatever method it wants. If it gets stuck in your infinite
> loop, the decider is just wrong.
>
> The proof shows that what ever answer the decider does give (if it
> gives one) will be wrong, and thus the decider doesn't meet the
> requirements.
>
> No "Self Reference" in sight there only a program being given a copy
> of something that just happens to be its own description.
>
> The only place we get any form of "Reference", is when we try to
> ANALYSE or DESIGN the H to try to meet the challenge. There the
> effect of the Self-Reference just lets us see that the task turns out
> be be impossible, so no such program exists.

You are fractally wrong on all fronts: in the traditional halting
problem proofs based on [Strachey 1965] the program is impossible not
due to self reference or infinite copies but because the input tries to
do the opposite of what the decider decides; the category error that I
have identified is different: it is an error of self reference and/or
infinite copies; it is an error related to the fact that the input
references a decider rather than being related to what the input does
with the decision result of a decider.

/Flibble

On 11/11/22 10:36 PM, olcott wrote:
> On 11/11/2022 9:25 PM, Richard Damon wrote:
>> On 11/11/22 9:57 PM, olcott wrote:
>>> On 11/11/2022 8:51 PM, Richard Damon wrote:
>>>> On 11/11/22 9:36 PM, olcott wrote:
>>>>> On 11/11/2022 8:25 PM, Richard Damon wrote:
>>>>>> On 11/11/22 7:51 PM, olcott wrote:
>>>>>>> On 11/11/2022 6:29 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 7:05 PM, olcott wrote:
>>>>>>>>> On 11/11/2022 5:48 PM, Richard Damon wrote:
>>>>>>>>>> On 11/11/22 6:39 PM, olcott wrote:
>>>>>>>>>>> On 11/11/2022 5:20 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 3:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>>>> and I would have
>>>>>>>>>>>>>>>>>>>>> thought given your intelligence you would also
>>>>>>>>>>>>>>>>>>>>> understand that.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just
>>>>>>>>>>>>>>>>>>>> mostly ignores me.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to
>>>>>>>>>>>>>>>>>>>> point out his errors.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just refuses.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>>>> basis.
>>>>>>>>>>>>>>>>>>> Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal
>>>>>>>>>>>>>>>>> Turing machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>> correctly simulated by H provides H with a correct
>>>>>>>>>>>>>>>>> basis for its halt status decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
>>>>>>>>>>>>>>> infinite execution of E is correct to report non-halting.
>>>>>>>>>>>>>>> No shell game can correctly deny this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>> If no H ever aborts its simulation of E then no E ever
>>>>>>>>>>>>> stops running this conclusively proves that H is correct to
>>>>>>>>>>>>> abort its simulation and report non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> if THE H doesn't abort, it doesn't answer.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> H only need to correctly predict that its input would never
>>>>>>>>>>> reach its own final state and terminate normally in 1 to ∞ of
>>>>>>>>>>> correct simulation.
>>>>>>>>>>
>>>>>>>>>> Right, and it does when CORRECTLY (and completely) simulated
>>>>>>>>>> or directly executed.
>>>>>>>>>>
>>>>>>>>>> H just aborts its simulation too soon.
>>>>>>>>>
>>>>>>>>> *This is the part where you are either incompetent or a liar*
>>>>>>>>>
>>>>>>>>> Any expert in C knows that the correctly simulated E never
>>>>>>>>> reaches its own final state even if an infinite number of steps
>>>>>>>>> are correctly simulated. Thus H is correct to predict that its
>>>>>>>>> input never halts.
>>>>>>>>
>>>>>>>> Nope, in fact you have PROVED the opposite. (Or do you forget that)
>>>>>>>>
>>>>>>>> It just can't be done by H.
>>>>>>>>
>>>>>>>> Note, the problem doesn't say "by H", that is your strawman, the
>>>>>>>> problem just references the behavior of the program, which can
>>>>>>>> be seen by direct execution or correct simulation.
>>>>>>>>
>>>>>>>> A correct simulation or direct execution will see the H
>>>>>>>> simulating for a while, then aborting its simulation and
>>>>>>>> returning 0 and E halting. (or you H never gave what you claim
>>>>>>>> to be the correct answer).
>>>>>>> If H waits for an inner H to abort its simulation then
>>>>>>> this H waits for an inner H to abort its simulation then
>>>>>>> this H waits for an inner H to abort its simulation then ...
>>>>>>> no H ever aborts its simulation.
>>>>>>>
>>>>>>> You aren't stupid or incompetent for not seeing this, you seem to
>>>>>>> be dishonest not remembering all the times that I have already
>>>>>>> told you this.
>>>>>>>
>>>>>>
>>>>>> Right, if your H is designed THAT way, it never aborts and thus
>>>>>> fails to answer.
>>>>>>
>>>>>
>>>>> I made the basis of my proof much easier to understand so that
>>>>> anyone that is an expert in the C programming language would be
>>>>> able to understand a simulating halt decider.
>>>>>
>>>>> void E(void (*x)())
>>>>> {
>>>>>    H(x, x);
>>>>> }
>>>>>
>>>>> When H(D,D) returns 0 it correctly predicts that D correctly
>>>>> simulated by H would never reach its own final state and terminate
>>>>> normally after 1 to ∞ of correct simulation.
>>>>>
>>>>>
>>>>
>>>> Except that it didn't correctly predict that, as it can't correctly
>>>> predict that as the actual correct simulation of the input by a real
>>>> correct simulator, which will agree with the direct exectuion of the
>>>> input, shows that it does reach the final state, after the point
>>>> that H gives up.
>>> You and I can both see that
>>> the correct and complete simulation of D by H never reaches its final
>>> state in 1 to ∞ steps of correct simulation
>>
>> The H in question never does and can't do a correct and complete
>> simulation of this input,
>
> H correctly predicts that D correctly simulated by H would never reach
> the final state of D in 1 to ∞ steps of correct simulation.
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> H correctly predicts that Infinite_Loop() correctly simulated by H would
> never reach the final state of Infinite_Loop() in 1 to ∞ steps of
> correct simulation.
>
>