void Px(ptr x)
{ int Halt_Status = Hx(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", Hx(Px, Px));
}

*Understanding the above code proves this*
There are zero elements of infinite set of Hx/Px pairs such that the
correct *partial or complete* simulation of Px by Hx reaches the final
state of Px.

*THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
(A) Every element of the infinite set of Hx/Px pairs that does a correct
and complete simulation of its input never reaches the final state of
this input.

*THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
(B) A correct and complete simulation of Px by Hx derives the actual
behavior of Px.

*THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
(C) The actual behavior of this input never reaches the final state of
this input.

When the criteria for a simulating halt decider (SHD) is to correctly
predict that its complete and correct simulation of its input would
never reach the final state of this simulated input then:

void Infinite_Loop()
{ HERE: goto HERE;
} *H0(Infinite_Loop)==0 // is correct*

void Infinite_Recursion(int N)
{ Infinite_Recursion(N);
} *H(Infinite_Recursion, 0x777)==0 // is correct*

Every Hx that returns zero correctly predicts that every Px correctly
and completely simulated by any Hx never reaches the final state of Px.
*Hx(Px,Px)==0 // is correct*

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

The particular instance of Hx named H and contained in Halt7.c does
correctly predict
that the arguments to H(P,P) cannot possibly reach their own final
state. H makes this
prediction on the basis of correctly matching a correct
infinite-behavior pattern.

*complete halt deciding system including*
*(a) x86utm operating system*
*(b) complete x86 emulator*
*(c) All of the various halt deciders and their inputs are contained in
Halt7.c*
https://liarparadox.org/2022_09_07.zip

This system currently only compiles under:
Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

*Halting problem proofs refuted on the basis of software engineering* ?
https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

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

--
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 9/16/2022 11:25 AM, Ben Bacarisse wrote:
> olcott <polcott2@gmail.com> writes:
>
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>
> And so on...
>
> Just a heads-up: this thread is not about C or C++ and if you feel the
> need to reply do so on comp.theory (Followup-To set). The OP also set
> followup-to (so kudos there), but he's just fishing for new people to
> talk to, as all but one have stopped replying on comp.theory. If you
> feel the urge, I invite to review his >18-year history of posting on
> this topic first.
>

No one has found any error in the above and have given up responding on
this basis because they were only ever interested in forming rebuttals
to my work.

I post to comp.lang.c and comp.lang.c++ because the proof that my work
is correct can now be understood on the basis of ordinary software
engineering in these two languages.

--
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 Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", Hx(Px, Px));
> }
>
This means nothing without a definition of Hx
Once again - what are you trying to prove?

On 9/16/22 12:38 PM, olcott wrote:
> On 9/16/2022 11:25 AM, Ben Bacarisse wrote:
>> olcott <polcott2@gmail.com> writes:
>>
>>> void Px(ptr x)
>>> {
>>>    int Halt_Status = Hx(x, x);
>>
>> And so on...
>>
>> Just a heads-up: this thread is not about C or C++ and if you feel the
>> need to reply do so on comp.theory (Followup-To set).  The OP also set
>> followup-to (so kudos there), but he's just fishing for new people to
>> talk to, as all but one have stopped replying on comp.theory.  If you
>> feel the urge, I invite to review his >18-year history of posting on
>> this topic first.
>>
>
> No one has found any error in the above and have given up responding on
> this basis because they were only ever interested in forming rebuttals
> to my work.
>
> I post to comp.lang.c and comp.lang.c++ because the proof that my work
> is correct can now be understood on the basis of ordinary software
> engineering in these two languages.
>

WRONG, giving only 20 minutes for a rebuttal sho0ws you are ignorant of
how this sort of thing works.

Since a rebuttal of these points had ALREADY BEEN POSTED from the LAST
time you posted this crap, shows you have the mind of a goldfish.

You are just proving you are an ignorant pathological lying idiot.

A repeat and point by point rebuttal will follow shortly.

On 9/16/22 12:17 PM, olcott wrote:
> void Px(ptr x)
> {
>   int Halt_Status = Hx(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", Hx(Px, Px));
> }
>
> *Understanding the above code proves this*
> There are zero elements of infinite set of Hx/Px pairs such that the
> correct *partial or complete* simulation of Px by Hx reaches the final
> state of Px.

Agreed, but that isn't the requirement for the definition of Halting.

Only COMPLETE simulation show halting/non-halting by themselves.

Only SOME of the inputs have been completely simulated to show non-halting.

>
> *THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
> (A) Every element of the infinite set of Hx/Px pairs that does a correct
> and complete simulation of its input never reaches the final state of
> this input.

Right, and the subset of the above that has been complete simulated are
the Px that call a Hx that never stops its simulation until it reaches
the end.

So those, and ONLY those, elements of the set of Px have been shown to
be non-halting.

>
> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
> (B) A correct and complete simulation of Px by Hx derives the actual
> behavior of Px.

Right, and the only inputs that have been subject to a UTM are those Px
that use an Hx that never stop there simulation.

>
> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
> (C) The actual behavior of this input never reaches the final state of
> this input.

Which only applies to that subset that use a Hx that never stops its
simulation, not to any Px that calls an Hx that stops its simulation and
returns 0.

>
> When the criteria for a simulating halt decider (SHD) is to correctly
> predict that its complete and correct simulation of its input would
> never reach the final state of this simulated input then:

Except that ISN'T the criteria for a simulation Halt Decider, because
such a definition is ILLOGICAL. A given program can not both stop
simulating and return an answer and also perform a complete simulation
of the same input that is non-halting.

THIS JUST PROVES YOUR IGNORANANCE.

That might be the method YOUR SHD uses to try to solve the problem, but
it fails to meet even THAT requirement,

The ACTUAL requriement is that a Halt Decider (of ANY TYPE, simulating
or not) is to correct predict that *THE* complete and correct simulation
of its input, which would be by an AcTUAL UTM, would reach a final state.

Since a Halt Decider CAN'T be an actual UTM and still answer for a
non-halting input, your definition just breaks.

>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
> *H0(Infinite_Loop)==0 // is correct*

Yes, but can only be done because H0 has some CORRECT logic to deduce
that the UTM simulation of this input would not halt.

>
> void Infinite_Recursion(int N)
> {
>   Infinite_Recursion(N);
> }
> *H(Infinite_Recursion, 0x777)==0 // is correct*

Right, but can only be

>
> Every Hx that returns zero correctly predicts that every Px correctly
> and completely simulated by any Hx never reaches the final state of Px.
> *Hx(Px,Px)==0 // is correct*

Right, ny Hx can correct decide for a Px built on an Hx that doesn't
abort its simulation, THAT is what you proved above.

Since the "Impossible Program Proof" says H needs to decide on the P
built on IT, and H needs to stop its simulation of this input to give an
answer, you "proof" above has said NOTHING about this case.

>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> The particular instance of Hx named H and contained in Halt7.c does
> correctly predict
> that the arguments to H(P,P) cannot possibly reach their own final
> state. H makes this
> prediction on the basis of correctly matching a correct
> infinite-behavior pattern.

Nope. since P is DEFINED to call that H which has been defined to abort
its simulation, NONE of you logic above has said ANYTHING about its
behavior, and thus it is just a blantant lie, and proof of logical
incompetence to make such a claim.

Note, that since is HAS been shown that for this H, which returns 0 for
H(P,P) for this P, that this P(P) will Halt, thus the answer from H MUST
be wromg, and your claims otherwise just prove you are an ignorant
pathologically lying idiot, as you are trying to make a claim in DIRECT
contradiciton to the definition of a Halt Decider.

>
> *complete halt deciding system including*
> *(a) x86utm operating system*
> *(b) complete x86 emulator*
> *(c) All of the various halt deciders and their inputs are contained in
> Halt7.c*
> https://liarparadox.org/2022_09_07.zip
>
> This system currently only compiles under:
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
> *Halting problem proofs refuted on the basis of software engineering* ?
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>
> Linz, Peter 1990. An Introduction to Formal Languages and Automata.
> Lexington/Toronto: D. C. Heath and Company. (317-320)
>

FAIL

On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", Hx(Px, Px));
>> }
>>
> This means nothing without a definition of Hx
> Once again - what are you trying to prove?

You have to carefully study every single word that I said and then you
will see that Hx/Px pairs include an infinite set of definitions of Hx.

I have proved that for some Hx/Px pairs Hx correctly decides that Px
never halts.

--
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 9/16/2022 2:33 PM, Richard Damon wrote:
>
> On 9/16/22 12:17 PM, olcott wrote:
>> void Px(ptr x)
>> {
>>    int Halt_Status = Hx(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", Hx(Px, Px));
>> }
>>
>> *Understanding the above code proves this*
>> There are zero elements of infinite set of Hx/Px pairs such that the
>> correct *partial or complete* simulation of Px by Hx reaches the final
>> state of Px.
>
> Agreed, but that isn't the requirement for the definition of Halting.
>
> Only COMPLETE simulation show halting/non-halting by themselves.
>
> Only SOME of the inputs have been completely simulated to show non-halting.

That is almost correct.

When halting is defined as reaching the final state of the simulated
input then even the partially simulated inputs do not halt.

That an input does not halt ONLY because its simulation has been aborted
provides no evidence that this input specifies non-halting behavior.

That none of the correctly and completely simulated inputs ever stop
running conclusively proves that these inputs specify non-halting behavior.

>>
>> *THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
>> (A) Every element of the infinite set of Hx/Px pairs that does a
>> correct and complete simulation of its input never reaches the final
>> state of this input.
>
> Right, and the subset of the above that has been complete simulated are
> the Px that call a Hx that never stops its simulation until it reaches
> the end.
>

*Saying that an infinite simulation reaches the end*
is where you are too far out-of-whack and I will have to quit responding
to you.

--
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 Friday, September 16, 2022 at 8:36:09 PM UTC+1, olcott wrote:
> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
> > On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
> >> void Px(ptr x)
> >> {
> >> int Halt_Status = Hx(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", Hx(Px, Px));
> >> }
> >>
> > This means nothing without a definition of Hx
> > Once again - what are you trying to prove?
> You have to carefully study every single word that I said and then you
> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>
> I have proved that for some Hx/Px pairs Hx correctly decides that Px
> never halts.

You've proved nothing of the sort and you know you haven't.

And your statement that "No one has found any error in the above" is a downright lie, comp.theory is full of posts by people pointing out your errors.

On 9/16/22 3:36 PM, olcott wrote:
> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>> void Px(ptr x)
>>> {
>>> int Halt_Status = Hx(x, x);
>>> if (Halt_Status)
>>> HERE: goto HERE;
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", Hx(Px, Px));
>>> }
>>>
>> This means nothing without a definition of Hx
>> Once again - what are you trying to prove?
>
> You have to carefully study every single word that I said and then you
> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>
> I have proved that for some Hx/Px pairs Hx correctly decides that Px
> never halts.
>

No, you have shown that SOME of the set of Px are non-halting, so an Hx
could be correct to say it is non-halting, but NONE of the Hx that give
an answer are given one of those Px to decide on, since the set of Px's
that are non-hatling are EXACTLY the set of Px that are based on an Hx
that does't answer, and the Hx are only given the Px based on them to
decider.

You have TWO DISJOINT infinite sets.

The set of Hx/Px that shows that their Px is non-halting by completely
simulating the input, but never give an answer to be correct about that.

And then the set of Hx/Px that abort their simultion, and thus not show
that their inputs are non-halting, and which, in fact we can show by
simple analysis that UTM(Px,Px) for these input WILL HALT, thus ALL
these Hx are incorrect in their determination.

All you have done is confused two infintely large sets for each other,
thus you have made an infinite number of errors, and actually not proven
your point.

FAIL.

On 9/16/2022 3:01 PM, Paul N wrote:
> On Friday, September 16, 2022 at 8:36:09 PM UTC+1, olcott wrote:
>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>> void Px(ptr x)
>>>> {
>>>> int Halt_Status = Hx(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>> }
>>>>
>>> This means nothing without a definition of Hx
>>> Once again - what are you trying to prove?
>> You have to carefully study every single word that I said and then you
>> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>>
>> I have proved that for some Hx/Px pairs Hx correctly decides that Px
>> never halts.
>
> You've proved nothing of the sort and you know you haven't.
>
> And your statement that "No one has found any error in the above" is a downright lie, comp.theory is full of posts by people pointing out your errors.

Please respond to my post from yesterday, we must proceed one point at a
time or an honest dialogue is lost.

--
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 9/16/22 4:00 PM, olcott wrote:
> On 9/16/2022 2:33 PM, Richard Damon wrote:
>>
>> On 9/16/22 12:17 PM, olcott wrote:
>>> void Px(ptr x)
>>> {
>>>    int Halt_Status = Hx(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", Hx(Px, Px));
>>> }
>>>
>>> *Understanding the above code proves this*
>>> There are zero elements of infinite set of Hx/Px pairs such that the
>>> correct *partial or complete* simulation of Px by Hx reaches the
>>> final state of Px.
>>
>> Agreed, but that isn't the requirement for the definition of Halting.
>>
>> Only COMPLETE simulation show halting/non-halting by themselves.
>>
>> Only SOME of the inputs have been completely simulated to show
>> non-halting.
>
> That is almost correct.
>
> When halting is defined as reaching the final state of the simulated
> input then even the partially simulated inputs do not halt.

So, are you admitting that you aren't using the correct definition of
Halting?

Remember, the definition you quote is based on the ACTUAL MACHINE, and
the ACTUAL MACHINE NEVER stops until it reachs a final state, thus any
definition based on simulation must be based on COMPLETE simulation or
acknoledge that non-halting is only indicated by a simulation that goes
to an unbonded number of steps.

>
> That an input does not halt ONLY because its simulation has been aborted
> provides no evidence that this input specifies non-halting behavior.
>

Right, but the simulation of the input of H DOES halt when performed by
a correct and complete simulator (which this H isn't).

It has been shown that UTM(Px,Px) will Halt for ALL Px based on an Hx
that returns 0 from Hx(Px,Px), thus those Hx are WRONG.

> That none of the correctly and completely simulated inputs ever stop
> running conclusively proves that these inputs specify non-halting behavior.

Nope, only thge NON_ABORTED simulations show their input is non-halting.

You are just showing your IGNORANCE (or duplicity) to claim that a
partial simulation shows non-halting.

>
>>>
>>> *THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
>>> (A) Every element of the infinite set of Hx/Px pairs that does a
>>> correct and complete simulation of its input never reaches the final
>>> state of this input.
>>
>> Right, and the subset of the above that has been complete simulated
>> are the Px that call a Hx that never stops its simulation until it
>> reaches the end.
>>
>
> *Saying that an infinite simulation reaches the end*
> is where you are too far out-of-whack and I will have to quit responding
> to you.
>

Just shows your ignorance of the language. I didn't say the Hxs that do
an infinite simulation teach an end, and in fact, that is what YOUR
claim needs to happen.

Any Hx that stops simulating before it reaches a final state, hasn't
done a complete simulation, and thus can't call its simulation result
the result of a UTM.

Thus, by your logic, no H can correctly return 0, as to return 0, it
needs to FIRST do a complete simulation, which will never end, and THEN
return the answer.

If is stops before then, then BY DEFINITION, it never does a complete
simulation, and thus has no definition of the behavior of its input.
This makes your definition, where H only looks at the simulation of H as
a defition of the behavior of the input to be invalid.

On 9/16/2022 3:08 PM, Richard Damon wrote:
> On 9/16/22 3:36 PM, olcott wrote:
>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>> void Px(ptr x)
>>>> {
>>>> int Halt_Status = Hx(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>> }
>>>>
>>> This means nothing without a definition of Hx
>>> Once again - what are you trying to prove?
>>
>> You have to carefully study every single word that I said and then you
>> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>>
>> I have proved that for some Hx/Px pairs Hx correctly decides that Px
>> never halts.
>>
>
> No, you have shown that SOME of the set of Px are non-halting,
I have proved that none of the partially or fully simulated Px inputs
simulated by Hx ever reach their final state.

A subset of these are the elements of Px fully simulated by Hx.

When every simulating halt decider bases its halt status decision on
whether or not it must abort the simulation of its input to prevent
infinite simulation then every Hx that returns 0 is correct.

THE ABOVE IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS SO ANY
DISAGREEMENT IS NECESSARILY INCORRECT.

When you disagree with this or change the subject to disagree with the
changed subject you are written off as a liar.

--
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 9/16/22 4:22 PM, olcott wrote:
> On 9/16/2022 3:08 PM, Richard Damon wrote:
>> On 9/16/22 3:36 PM, olcott wrote:
>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>> void Px(ptr x)
>>>>> {
>>>>> int Halt_Status = Hx(x, x);
>>>>> if (Halt_Status)
>>>>> HERE: goto HERE;
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>> }
>>>>>
>>>> This means nothing without a definition of Hx
>>>> Once again - what are you trying to prove?
>>>
>>> You have to carefully study every single word that I said and then
>>> you will see that Hx/Px pairs include an infinite set of definitions
>>> of Hx.
>>>
>>> I have proved that for some Hx/Px pairs Hx correctly decides that Px
>>> never halts.
>>>
>>
>> No, you have shown that SOME of the set of Px are non-halting,
> I have proved that none of the partially or fully simulated Px inputs
> simulated by Hx ever reach their final state.
>

Right.

> A subset of these are the elements of Px fully simulated by Hx.

Right, and that subset that is fully simulated is PRECISELY the subset
based on Hx's that don't abort.

>
> When every simulating halt decider bases its halt status decision on
> whether or not it must abort the simulation of its input to prevent
> infinite simulation then every Hx that returns 0 is correct.

But an Hx that DOES abort is not a member of the subset that you showed
create Px's that were completely simulated to show non-halting, so you
have ZERO proof that its input is non-halting

>
> THE ABOVE IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS SO ANY
> DISAGREEMENT IS NECESSARILY INCORRECT.

Nope, just shows you don't know the meaning of the words.

The Hx that you are trying to show that its input is non-halting is
DEFINED to abort its simulation, and thus the Px that its input is based
on is DEFINED to be based on an Hx that aborts. To try to replace the Hx
it calls with one that doesn't says you are not looking at the input
that this Hx was actually given.

Machines and input ARE WHAT THEY ARE, and are not replacable from a
"set" of related machines/inputs.

You can ask if this Hx(Px,Px) needs to abort by looking at the behavior
of UTM(Px,Px) where Px didn't change, as that is looking at the exact
same input.

You CAN NOT change Hx to be a DIFFERENT Hx, in a way that changes Px to
be a different Px and expect this to mean anything at all about the
original input.

The fact that you think it does just proves that you are just ignorant
of how the logic works.

>
> When you disagree with this or change the subject to disagree with the
> changed subject you are written off as a liar.
>

Nope, you are the liar because you are using false meaning of words.

The fact that you seem to BELIEVE these false meanings shows you are
also IGNORANT.

FAIL.

On 9/16/2022 4:06 PM, Richard Damon wrote:
> On 9/16/22 4:22 PM, olcott wrote:
>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>> On 9/16/22 3:36 PM, olcott wrote:
>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>> int Halt_Status = Hx(x, x);
>>>>>> if (Halt_Status)
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>> }
>>>>>>
>>>>> This means nothing without a definition of Hx
>>>>> Once again - what are you trying to prove?
>>>>
>>>> You have to carefully study every single word that I said and then
>>>> you will see that Hx/Px pairs include an infinite set of definitions
>>>> of Hx.
>>>>
>>>> I have proved that for some Hx/Px pairs Hx correctly decides that Px
>>>> never halts.
>>>>
>>>
>>> No, you have shown that SOME of the set of Px are non-halting,
>> I have proved that none of the partially or fully simulated Px inputs
>> simulated by Hx ever reach their final state.
>>
>
> Right.
>
>> A subset of these are the elements of Px fully simulated by Hx.
>
> Right, and that subset that is fully simulated is PRECISELY the subset
> based on Hx's that don't abort.
>
>>
>> When every simulating halt decider bases its halt status decision on
>> whether or not it must abort the simulation of its input to prevent
>> infinite simulation then every Hx that returns 0 is correct.
>
> But an Hx that DOES abort is not a member of the subset that you showed
> create Px's that were completely simulated to show non-halting, so you
> have ZERO proof that its input is non-halting
If that reasoning was valid then it would apply equally to this:

void Infinite_Loop()
{ HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H0((u32)Infinite_Loop));
}

Yet this correctly matched correct infinite behavior pattern proves that
you are wrong:

H0: Begin Simulation Execution Trace Stored at:211fac
[00001102][00211f9c][00211fa0] 55 push ebp
[00001103][00211f9c][00211fa0] 8bec mov ebp,esp
[00001105][00211f9c][00211fa0] ebfe jmp 00001105
[00001105][00211f9c][00211fa0] ebfe jmp 00001105
H0: Infinite Loop Detected Simulation Stopped

For simulating halt deciders halts ONLY because its simulation was
aborted is the same as input specifies non-halting behavior.

--
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 9/16/22 5:18 PM, olcott wrote:
> On 9/16/2022 4:06 PM, Richard Damon wrote:
>> On 9/16/22 4:22 PM, olcott wrote:
>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>>> void Px(ptr x)
>>>>>>> {
>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>> if (Halt_Status)
>>>>>>> HERE: goto HERE;
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>> }
>>>>>>>
>>>>>> This means nothing without a definition of Hx
>>>>>> Once again - what are you trying to prove?
>>>>>
>>>>> You have to carefully study every single word that I said and then
>>>>> you will see that Hx/Px pairs include an infinite set of
>>>>> definitions of Hx.
>>>>>
>>>>> I have proved that for some Hx/Px pairs Hx correctly decides that
>>>>> Px never halts.
>>>>>
>>>>
>>>> No, you have shown that SOME of the set of Px are non-halting,
>>> I have proved that none of the partially or fully simulated Px inputs
>>> simulated by Hx ever reach their final state.
>>>
>>
>> Right.
>>
>>> A subset of these are the elements of Px fully simulated by Hx.
>>
>> Right, and that subset that is fully simulated is PRECISELY the subset
>> based on Hx's that don't abort.
>>
>>>
>>> When every simulating halt decider bases its halt status decision on
>>> whether or not it must abort the simulation of its input to prevent
>>> infinite simulation then every Hx that returns 0 is correct.
>>
>> But an Hx that DOES abort is not a member of the subset that you
>> showed create Px's that were completely simulated to show non-halting,
>> so you have ZERO proof that its input is non-halting
> If that reasoning was valid then it would apply equally to this:

Yes, it applies there. The issue is that YOU are not noticing that you
are actually applying some logic to see that Infinite_Loop wouldn't go
on forever, so the halting is correct.

Since H0 aborts its simulation of Infinite_Loop, H0 can not point to ANY
copy of that exact H0 that simulates this input indefinitely.

You can only show either by looking at an ACTUAL UTM(Infinite_LooP)
being non-halting or by applying PROVEN logical rules from a partial
simulation of Infinte_Loop that it is non-halting.

If you want to claim otherwise, pleae provide the code for H0 that, with
the exact same code as a computation both simulates this input
completely and also aborts its simulation and returns an answer.

>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
> Yet this correctly matched correct infinite behavior pattern proves that
> you are wrong:

RIGHT, YOU ARE USING A PROVEN RULE, NOT the fact that H0 does a
simulation that complete simulates the input.

Thus, your H0 does NOT meet the requriements you have stated, as there
does not exist an H0 that does a complete simulation showing that the
input is non-halting and also provides an answer in finte time.

>
> H0: Begin Simulation   Execution Trace Stored at:211fac
> [00001102][00211f9c][00211fa0] 55         push ebp
> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
> H0: Infinite Loop Detected Simulation Stopped
>
> For simulating halt deciders halts ONLY because its simulation was
> aborted is the same as input specifies non-halting behavior.
>

The only reason ANY simulator stops simulating is because it was
programmed to at that point.

There is no "Only Because it would otherwise", it either DOES or it DOESN'T.

FAIL:.

You just don;t understand how computers and computations works.

On 9/16/2022 4:36 PM, Richard Damon wrote:
>
> On 9/16/22 5:18 PM, olcott wrote:
>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>> On 9/16/22 4:22 PM, olcott wrote:
>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>>>> void Px(ptr x)
>>>>>>>> {
>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>> if (Halt_Status)
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>> }
>>>>>>>>
>>>>>>> This means nothing without a definition of Hx
>>>>>>> Once again - what are you trying to prove?
>>>>>>
>>>>>> You have to carefully study every single word that I said and then
>>>>>> you will see that Hx/Px pairs include an infinite set of
>>>>>> definitions of Hx.
>>>>>>
>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides that
>>>>>> Px never halts.
>>>>>>
>>>>>
>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>> I have proved that none of the partially or fully simulated Px
>>>> inputs simulated by Hx ever reach their final state.
>>>>
>>>
>>> Right.
>>>
>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>
>>> Right, and that subset that is fully simulated is PRECISELY the
>>> subset based on Hx's that don't abort.
>>>
>>>>
>>>> When every simulating halt decider bases its halt status decision on
>>>> whether or not it must abort the simulation of its input to prevent
>>>> infinite simulation then every Hx that returns 0 is correct.
>>>
>>> But an Hx that DOES abort is not a member of the subset that you
>>> showed create Px's that were completely simulated to show
>>> non-halting, so you have ZERO proof that its input is non-halting
>> If that reasoning was valid then it would apply equally to this:
>
> Yes, it applies there. The issue is that YOU are not noticing that you
> are actually applying some logic to see that Infinite_Loop wouldn't go
> on forever, so the halting is correct.
>
OK so you have proven that you are unequivocally a liar when you say
that an infinite loop does not go on forever.

--
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 9/16/22 5:42 PM, olcott wrote:
> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>
>> On 9/16/22 5:18 PM, olcott wrote:
>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>>>>> void Px(ptr x)
>>>>>>>>> {
>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>> This means nothing without a definition of Hx
>>>>>>>> Once again - what are you trying to prove?
>>>>>>>
>>>>>>> You have to carefully study every single word that I said and
>>>>>>> then you will see that Hx/Px pairs include an infinite set of
>>>>>>> definitions of Hx.
>>>>>>>
>>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides that
>>>>>>> Px never halts.
>>>>>>>
>>>>>>
>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>> I have proved that none of the partially or fully simulated Px
>>>>> inputs simulated by Hx ever reach their final state.
>>>>>
>>>>
>>>> Right.
>>>>
>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>
>>>> Right, and that subset that is fully simulated is PRECISELY the
>>>> subset based on Hx's that don't abort.
>>>>
>>>>>
>>>>> When every simulating halt decider bases its halt status decision
>>>>> on whether or not it must abort the simulation of its input to
>>>>> prevent infinite simulation then every Hx that returns 0 is correct.
>>>>
>>>> But an Hx that DOES abort is not a member of the subset that you
>>>> showed create Px's that were completely simulated to show
>>>> non-halting, so you have ZERO proof that its input is non-halting
>>> If that reasoning was valid then it would apply equally to this:
>>
>> Yes, it applies there. The issue is that YOU are not noticing that you
>> are actually applying some logic to see that Infinite_Loop wouldn't go
>> on forever, so the halting is correct.
>>
> OK so you have proven that you are unequivocally a liar when you say
> that an infinite loop does not go on forever.
>
>

WHERE DID I SAY THAT?

Seems to be that YOU are the one lying,

I said that you have no copy of H0 that simulates that input forever,
not that IS the same compuation as H0, as implied by your definition,

On 9/16/2022 4:54 PM, Richard Damon wrote:
> On 9/16/22 5:42 PM, olcott wrote:
>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>
>>> On 9/16/22 5:18 PM, olcott wrote:
>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>>>>>> void Px(ptr x)
>>>>>>>>>> {
>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>> if (Halt_Status)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>
>>>>>>>> You have to carefully study every single word that I said and
>>>>>>>> then you will see that Hx/Px pairs include an infinite set of
>>>>>>>> definitions of Hx.
>>>>>>>>
>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides
>>>>>>>> that Px never halts.
>>>>>>>>
>>>>>>>
>>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>>> I have proved that none of the partially or fully simulated Px
>>>>>> inputs simulated by Hx ever reach their final state.
>>>>>>
>>>>>
>>>>> Right.
>>>>>
>>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>>
>>>>> Right, and that subset that is fully simulated is PRECISELY the
>>>>> subset based on Hx's that don't abort.
>>>>>
>>>>>>
>>>>>> When every simulating halt decider bases its halt status decision
>>>>>> on whether or not it must abort the simulation of its input to
>>>>>> prevent infinite simulation then every Hx that returns 0 is correct.
>>>>>
>>>>> But an Hx that DOES abort is not a member of the subset that you
>>>>> showed create Px's that were completely simulated to show
>>>>> non-halting, so you have ZERO proof that its input is non-halting
>>>> If that reasoning was valid then it would apply equally to this:
>>>
>>> Yes, it applies there. The issue is that YOU are not noticing that
>>> you are actually applying some logic to see that Infinite_Loop
>>> wouldn't go on forever, so the halting is correct.
>>>
>> OK so you have proven that you are unequivocally a liar when you say
>> that an infinite loop does not go on forever.
>>
>>
>
> WHERE DID I SAY THAT?
>
> Seems to be that YOU are the one lying,
>
> I said that you have no copy of H0 that simulates that input forever,
> not that IS the same compuation as H0, as implied by your definition,

So you agree that H0 correctly determines that its simulation of
Infinite_Loop would never stop running if this simulation was never
aborted?

--
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 9/16/22 6:11 PM, olcott wrote:
> On 9/16/2022 4:54 PM, Richard Damon wrote:
>> On 9/16/22 5:42 PM, olcott wrote:
>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>
>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>> return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>
>>>>>>>>> You have to carefully study every single word that I said and
>>>>>>>>> then you will see that Hx/Px pairs include an infinite set of
>>>>>>>>> definitions of Hx.
>>>>>>>>>
>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides
>>>>>>>>> that Px never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>>>> I have proved that none of the partially or fully simulated Px
>>>>>>> inputs simulated by Hx ever reach their final state.
>>>>>>>
>>>>>>
>>>>>> Right.
>>>>>>
>>>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>>>
>>>>>> Right, and that subset that is fully simulated is PRECISELY the
>>>>>> subset based on Hx's that don't abort.
>>>>>>
>>>>>>>
>>>>>>> When every simulating halt decider bases its halt status decision
>>>>>>> on whether or not it must abort the simulation of its input to
>>>>>>> prevent infinite simulation then every Hx that returns 0 is correct.
>>>>>>
>>>>>> But an Hx that DOES abort is not a member of the subset that you
>>>>>> showed create Px's that were completely simulated to show
>>>>>> non-halting, so you have ZERO proof that its input is non-halting
>>>>> If that reasoning was valid then it would apply equally to this:
>>>>
>>>> Yes, it applies there. The issue is that YOU are not noticing that
>>>> you are actually applying some logic to see that Infinite_Loop
>>>> wouldn't go on forever, so the halting is correct.
>>>>
>>> OK so you have proven that you are unequivocally a liar when you say
>>> that an infinite loop does not go on forever.
>>>
>>>
>>
>> WHERE DID I SAY THAT?
>>
>> Seems to be that YOU are the one lying,
>>
>> I said that you have no copy of H0 that simulates that input forever,
>> not that IS the same compuation as H0, as implied by your definition,
>
> So you agree that H0 correctly determines that its simulation of
> Infinite_Loop would never stop running if this simulation was never
> aborted?
>

The conclusion is correct but the wording is illogical.

H0 either does or does not abort its simulation.

SInce it answers, it does.

Therefore the phrase "if this simulation was never aborted" can't mean
the meaning you give for your definition of H being correct for P, as No
H0 that gives an answer also shows that *ITS* non-aborting simulation
would never reach a final state.

That is your flaw, sometimes you assert the importance that it is THIS
DECIDER doing the simulation, and sometimes you gloss over that fact.

Thus, either you need to accept that the phase "Ths simumation" means a
complete simulation done by some other machine, or you have the problem
that your condition can not be met, H0 can not show that a simulation by
H0 of this input would go on forever, as the machine that you use to
show it just isn't H0.

Maybe your problem is you don't understand what it means to refer to a
particular program?

You are still failing and just flailing trying to show something that
isn't true, and your strawmen are turn out to be too tough for you to
handle, because you lies have given them hidden strength when they are
reveiled.

On 9/16/2022 5:31 PM, Richard Damon wrote:
> On 9/16/22 6:11 PM, olcott wrote:
>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>> On 9/16/22 5:42 PM, olcott wrote:
>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>
>>>>>>>>>> You have to carefully study every single word that I said and
>>>>>>>>>> then you will see that Hx/Px pairs include an infinite set of
>>>>>>>>>> definitions of Hx.
>>>>>>>>>>
>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides
>>>>>>>>>> that Px never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>>>>> I have proved that none of the partially or fully simulated Px
>>>>>>>> inputs simulated by Hx ever reach their final state.
>>>>>>>>
>>>>>>>
>>>>>>> Right.
>>>>>>>
>>>>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>>>>
>>>>>>> Right, and that subset that is fully simulated is PRECISELY the
>>>>>>> subset based on Hx's that don't abort.
>>>>>>>
>>>>>>>>
>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>> decision on whether or not it must abort the simulation of its
>>>>>>>> input to prevent infinite simulation then every Hx that returns
>>>>>>>> 0 is correct.
>>>>>>>
>>>>>>> But an Hx that DOES abort is not a member of the subset that you
>>>>>>> showed create Px's that were completely simulated to show
>>>>>>> non-halting, so you have ZERO proof that its input is non-halting
>>>>>> If that reasoning was valid then it would apply equally to this:
>>>>>
>>>>> Yes, it applies there. The issue is that YOU are not noticing that
>>>>> you are actually applying some logic to see that Infinite_Loop
>>>>> wouldn't go on forever, so the halting is correct.
>>>>>
>>>> OK so you have proven that you are unequivocally a liar when you say
>>>> that an infinite loop does not go on forever.
>>>>
>>>>
>>>
>>> WHERE DID I SAY THAT?
>>>
>>> Seems to be that YOU are the one lying,
>>>
>>> I said that you have no copy of H0 that simulates that input forever,
>>> not that IS the same compuation as H0, as implied by your definition,
>>
>> So you agree that H0 correctly determines that its simulation of
>> Infinite_Loop would never stop running if this simulation was never
>> aborted?
>>
>
> The conclusion is correct but the wording is illogical.
>
> H0 either does or does not abort its simulation.
>

There are only two mutually exclusive categories for every possible
behavior of elements of the infinite set of encodings of H0 where H0
correctly simulates its input:
(a) Abort the simulation of its input some point.
(b) Never abort the simulation of its input at any point.

When H0 returns 0 it does this based on correctly matching a correct
infinite behavior pattern that correctly determines the actual behavior
of every element of set (b).

--
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 9/16/22 6:45 PM, olcott wrote:
> On 9/16/2022 5:31 PM, Richard Damon wrote:
>> On 9/16/22 6:11 PM, olcott wrote:
>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>> return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>
>>>>>>>>>>> You have to carefully study every single word that I said and
>>>>>>>>>>> then you will see that Hx/Px pairs include an infinite set of
>>>>>>>>>>> definitions of Hx.
>>>>>>>>>>>
>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides
>>>>>>>>>>> that Px never halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>>>>>> I have proved that none of the partially or fully simulated Px
>>>>>>>>> inputs simulated by Hx ever reach their final state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right.
>>>>>>>>
>>>>>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>>>>>
>>>>>>>> Right, and that subset that is fully simulated is PRECISELY the
>>>>>>>> subset based on Hx's that don't abort.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>> decision on whether or not it must abort the simulation of its
>>>>>>>>> input to prevent infinite simulation then every Hx that returns
>>>>>>>>> 0 is correct.
>>>>>>>>
>>>>>>>> But an Hx that DOES abort is not a member of the subset that you
>>>>>>>> showed create Px's that were completely simulated to show
>>>>>>>> non-halting, so you have ZERO proof that its input is non-halting
>>>>>>> If that reasoning was valid then it would apply equally to this:
>>>>>>
>>>>>> Yes, it applies there. The issue is that YOU are not noticing that
>>>>>> you are actually applying some logic to see that Infinite_Loop
>>>>>> wouldn't go on forever, so the halting is correct.
>>>>>>
>>>>> OK so you have proven that you are unequivocally a liar when you
>>>>> say that an infinite loop does not go on forever.
>>>>>
>>>>>
>>>>
>>>> WHERE DID I SAY THAT?
>>>>
>>>> Seems to be that YOU are the one lying,
>>>>
>>>> I said that you have no copy of H0 that simulates that input
>>>> forever, not that IS the same compuation as H0, as implied by your
>>>> definition,
>>>
>>> So you agree that H0 correctly determines that its simulation of
>>> Infinite_Loop would never stop running if this simulation was never
>>> aborted?
>>>
>>
>> The conclusion is correct but the wording is illogical.
>>
>> H0 either does or does not abort its simulation.
>>
>
> There are only two mutually exclusive categories for every possible
> behavior of elements of the infinite set of encodings of H0 where H0
> correctly simulates its input:

So, your Simulationg Halt Deciders ARENT'T *A* Computation, but sets of
them?

That means you don't understand what a computation is. Or even what a
computater program is.

> (a) Abort the simulation of its input some point.
> (b) Never abort the simulation of its input at any point.

Right, so which ONE is H0?

Please write a program that represents this SET.

You clearly don't understand what a PROGRAM is.

>
> When H0 returns 0 it does this based on correctly matching a correct
> infinite behavior pattern that correctly determines the actual behavior
> of every element of set (b).
>

So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.

H0a(Infinite_Loop) aborts its simulation, but can't prove it is
corrrect, because H0a doesn't meet the requriements of showing that its
input is non-halting by completely simulating it.

H0b(Infinite_Loop) doesn't abort its simulation, and does prove that
non-halting would be correct, but doesn't give the answer.

This shows your flaw, when we try to extend this to the H/P pair P needs
to be a SPECIFIEC PROGRAM that call a SPECIFIC H, but instead it seems
to be something that somehow calls an unspecified decider from a set,
which isn't what a Turing Machine is defined to be.

You have thus just shows that you have ZERO understanding of what a
computer program or a computation actually are.

You have shown that your POOP theory is totally unrelated in any
interesting way to the Halting Problem, and that you have thus
apparently wasted these last 18 years of your life.

Sorry, you just are a FAILURE.

On 9/16/2022 3:01 PM, Paul N wrote:
> On Friday, September 16, 2022 at 8:36:09 PM UTC+1, olcott wrote:
>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>> void Px(ptr x)
>>>> {
>>>> int Halt_Status = Hx(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>> }
>>>>
>>> This means nothing without a definition of Hx
>>> Once again - what are you trying to prove?
>> You have to carefully study every single word that I said and then you
>> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>>
>> I have proved that for some Hx/Px pairs Hx correctly decides that Px
>> never halts.
>
> You've proved nothing of the sort and you know you haven't.
>
> And your statement that "No one has found any error in the above" is a downright lie, comp.theory is full of posts by people pointing out your errors.

The ONLY proof that I am correct only works on the gullible fools that
don't notice the strawman deception of changing the subject and then
forming a rebuttal of this changed subject.

*straw man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man

I am beginning to think that you are only a troll and don't give a rat's
ass for truth because all of your "rebuttals" were only based on
changing the subject.

When we go point-by-point through each point made in this original V2
post, assessing the exact words that are specified by each point no
error can be found because the meaning of the words of these points
proves that they are correct.

--
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 Fri, 16 Sep 2022 11:17:18 -0500
olcott <polcott2@gmail.com> wrote:

> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", Hx(Px, Px));
> }
>
> *Understanding the above code proves this*
> There are zero elements of infinite set of Hx/Px pairs such that the
> correct *partial or complete* simulation of Px by Hx reaches the
> final state of Px.

Your Hx gives an incorrect halting decision if Px is rewritten as:

void Px(ptr x)
{ int Halt_Status = Hx(x, x);
(void)Halt_Status;
return;
}

It is patently obvious to everyone except you that if Hx is a valid
halt decider then it must return a value to Px meaning Px will then
halt. Your Hx gives a halting decision of non-halting which is
erroneous.

/Flibble

On 9/16/2022 5:58 PM, Richard Damon wrote:
> On 9/16/22 6:45 PM, olcott wrote:
>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>> On 9/16/22 6:11 PM, olcott wrote:
>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>
>>>>>>>>>>>> You have to carefully study every single word that I said
>>>>>>>>>>>> and then you will see that Hx/Px pairs include an infinite
>>>>>>>>>>>> set of definitions of Hx.
>>>>>>>>>>>>
>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly decides
>>>>>>>>>>>> that Px never halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>>>>>>> I have proved that none of the partially or fully simulated Px
>>>>>>>>>> inputs simulated by Hx ever reach their final state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right.
>>>>>>>>>
>>>>>>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>>>>>>
>>>>>>>>> Right, and that subset that is fully simulated is PRECISELY the
>>>>>>>>> subset based on Hx's that don't abort.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>>> decision on whether or not it must abort the simulation of its
>>>>>>>>>> input to prevent infinite simulation then every Hx that
>>>>>>>>>> returns 0 is correct.
>>>>>>>>>
>>>>>>>>> But an Hx that DOES abort is not a member of the subset that
>>>>>>>>> you showed create Px's that were completely simulated to show
>>>>>>>>> non-halting, so you have ZERO proof that its input is non-halting
>>>>>>>> If that reasoning was valid then it would apply equally to this:
>>>>>>>
>>>>>>> Yes, it applies there. The issue is that YOU are not noticing
>>>>>>> that you are actually applying some logic to see that
>>>>>>> Infinite_Loop wouldn't go on forever, so the halting is correct.
>>>>>>>
>>>>>> OK so you have proven that you are unequivocally a liar when you
>>>>>> say that an infinite loop does not go on forever.
>>>>>>
>>>>>>
>>>>>
>>>>> WHERE DID I SAY THAT?
>>>>>
>>>>> Seems to be that YOU are the one lying,
>>>>>
>>>>> I said that you have no copy of H0 that simulates that input
>>>>> forever, not that IS the same compuation as H0, as implied by your
>>>>> definition,
>>>>
>>>> So you agree that H0 correctly determines that its simulation of
>>>> Infinite_Loop would never stop running if this simulation was never
>>>> aborted?
>>>>
>>>
>>> The conclusion is correct but the wording is illogical.
>>>
>>> H0 either does or does not abort its simulation.
>>>
>>
>> There are only two mutually exclusive categories for every possible
>> behavior of elements of the infinite set of encodings of H0 where H0
>> correctly simulates its input:
>
> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but sets of
> them?
>
> That means you don't understand what a computation is. Or even what a
> computater program is.
>
>
>> (a) Abort the simulation of its input some point.
>> (b) Never abort the simulation of its input at any point.
>
> Right, so which ONE is H0?
>
> Please write a program that represents this SET.
>
> You clearly don't understand what a PROGRAM is.
>
>>
>> When H0 returns 0 it does this based on correctly matching a correct
>> infinite behavior pattern that correctly determines the actual
>> behavior of every element of set (b).
>>
>
> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>

Did I stutter?
Every element of the set of encodings of H0 that returns 0 correctly
determines the halt status of Infinite_Loop for every possible encoding
of H0 that correctly and completely simulates Infinite_Loop.

A subset of these encodings of H0 that return 0 do so on the basis of
correctly matching a correct infinite behavior pattern that conclusively
proves that Infinite_Loop never halts.

*H0 and Infinite_loop are contained within halt7.c*

*complete halt deciding system including*
*(a) x86utm operating system*
*(b) complete x86 emulator*
*(c) All of the various halt deciders and their inputs are contained in
Halt7.c*
https://liarparadox.org/2022_09_07.zip

This system currently only compiles under:
Microsoft Visual Studio Community 2017
https://visualstudio.microsoft.com/vs/older-downloads/

--
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 9/16/22 7:04 PM, olcott wrote:
> On 9/16/2022 3:01 PM, Paul N wrote:
>> On Friday, September 16, 2022 at 8:36:09 PM UTC+1, olcott wrote:
>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>> void Px(ptr x)
>>>>> {
>>>>> int Halt_Status = Hx(x, x);
>>>>> if (Halt_Status)
>>>>> HERE: goto HERE;
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>> }
>>>>>
>>>> This means nothing without a definition of Hx
>>>> Once again - what are you trying to prove?
>>> You have to carefully study every single word that I said and then you
>>> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>>>
>>> I have proved that for some Hx/Px pairs Hx correctly decides that Px
>>> never halts.
>>
>> You've proved nothing of the sort and you know you haven't.
>>
>> And your statement that "No one has found any error in the above" is a
>> downright lie, comp.theory is full of posts by people pointing out
>> your errors.
>
> The ONLY proof that I am correct only works on the gullible fools that
> don't notice the strawman deception of changing the subject and then
> forming a rebuttal of this changed subject.
>

You are ADMITTING that only "guillible fools" beleive you and your
strawman arguements.

> *straw man*
> An intentionally misrepresented proposition that is set up because it is
> easier to defeat than an opponent's real argument.
> https://www.lexico.com/en/definition/straw_man

Yep, exactly what you are doing.

In reality, Halting is defined by the behavior of the ACTUAL MACHINE,
whose description is given the decider, or by definitional equivalence,
the actual UTM simulation of it.

Your Strawman is to replace that with the non-UTM simulation by the
decider, or the replacing of rhe input with something that isn't
actually the input that the decider was given.

>
> I am beginning to think that you are only a troll and don't give a rat's
> ass for truth because all of your "rebuttals" were only based on
> changing the subject.

No, they are always pointing back to the ACTUAL subject that you claim
to be working on.

>
> When we go point-by-point through each point made in this original V2
> post, assessing the exact words that are specified by each point no
> error can be found because the meaning of the words of these points
> proves that they are correct.
>
>

LIE.

Those errors HAVE been pointed out and you are just to stupid to
understand the errors that have been pointed out.

(Or too pig-headed to accept that you are wrong).

The fact that NO ONE accepts you proposal when fully explained should
give you pause as to who is right.