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 HAS BEEN AGREED TO* // *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 this input derives the actual
behavior of this input.

*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*

*Hx(Px,Px)==0 // is correct*

*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

--
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 Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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.

No, the set of Hx/Px pairs that does a correct and complete simulation of its input (and gives the correct result) is zero.

If Hx(Px, Px) is zero, the "if" fails, and the program halts.
If Hx(Px, Px) is non-zero, the "if" succeeds, and the program does not halt.

You can only say Hx(Px, Px) gives the actual behaviour if you stick in a lot of weasel words which define "actual behaviour" to be something different from (and indeed opposite to) the actual behaviour.

The weasel words follow:

> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
> (B) A correct and complete simulation of this input derives the actual
> behavior of this input.
>
> *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*
>
>
> *Hx(Px,Px)==0 // is correct*
>
>
>
> *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

On Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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 this input derives the actual
> behavior of this input.
>
> *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*
>
>
> *Hx(Px,Px)==0 // is correct*
>
>
>
> *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

And you have proved yourself, yet again, to be not only mistaken but highly inconsiderate because you have put this into comp.lang.c and comp.lang.c++ although you know full well that it is of no relevance there.

On 9/6/2022 4:36 PM, Paul N wrote:
> On Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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.
>
> No, the set of Hx/Px pairs that does a correct and complete simulation of its input (and gives the correct result) is zero.
>
> If Hx(Px, Px) is zero, the "if" fails, and the program halts.
> If Hx(Px, Px) is non-zero, the "if" succeeds, and the program does not halt.
>
> You can only say Hx(Px, Px) gives the actual behaviour if you stick in a lot of weasel words which define "actual behaviour" to be something different from (and indeed opposite to) the actual behaviour.

Not at all: (*see below*)

>
> The weasel words follow:
>
>> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
>> (B) A correct and complete simulation of this input derives the actual
>> behavior of this input.
>>
>> *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*

*Hx(Px,Px)==0 // is correct* (see code defined above)

*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

--
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 Tue, 6 Sep 2022 17:08:50 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/6/2022 4:36 PM, Paul N wrote:
> > On Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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.
> >
> > No, the set of Hx/Px pairs that does a correct and complete
> > simulation of its input (and gives the correct result) is zero.
> >
> > If Hx(Px, Px) is zero, the "if" fails, and the program halts.
> > If Hx(Px, Px) is non-zero, the "if" succeeds, and the program does
> > not halt.
> >
> > You can only say Hx(Px, Px) gives the actual behaviour if you stick
> > in a lot of weasel words which define "actual behaviour" to be
> > something different from (and indeed opposite to) the actual
> > behaviour.
>
> Not at all: (*see below*)
>
> >
> > The weasel words follow:
> >
> >> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
> >> (B) A correct and complete simulation of this input derives the
> >> actual behavior of this input.
> >>
> >> *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*
>
>
> *Hx(Px,Px)==0 // is correct* (see code defined above)
>
>
> *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
>

Your decider still gives an incorrect result for the following variant
of Px which should always halt:

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

You've still get nothing.

/Flibble

On 9/6/2022 5:27 PM, Mr Flibble wrote:
> On Tue, 6 Sep 2022 17:08:50 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/6/2022 4:36 PM, Paul N wrote:
>>> On Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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.
>>>
>>> No, the set of Hx/Px pairs that does a correct and complete
>>> simulation of its input (and gives the correct result) is zero.
>>>
>>> If Hx(Px, Px) is zero, the "if" fails, and the program halts.
>>> If Hx(Px, Px) is non-zero, the "if" succeeds, and the program does
>>> not halt.
>>>
>>> You can only say Hx(Px, Px) gives the actual behaviour if you stick
>>> in a lot of weasel words which define "actual behaviour" to be
>>> something different from (and indeed opposite to) the actual
>>> behaviour.
>>
>> Not at all: (*see below*)
>>
>>>
>>> The weasel words follow:
>>>
>>>> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
>>>> (B) A correct and complete simulation of this input derives the
>>>> actual behavior of this input.
>>>>
>>>> *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*
>>
>>
>> *Hx(Px,Px)==0 // is correct* (see code defined above)
>>
>>
>> *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
>>
>
> Your decider still gives an incorrect result for the following variant
> of Px which should always halt:
>
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x);
> (void)Halt_Status;
> return;
> }
>
> You've still get nothing.
>
> /Flibble
>

void Pz(ptr x)
{ Hz(x, x);
return;
}

int main()
{ Hz(Pz);
}

*Everyone that is reasonably competent at software analysis will know*
There are zero elements of infinite set of Hz/Pz pairs such
that the correct *partial or complete* simulation of Pz by Hz
reaches the final state (return instruction) of Pz.

--
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 Tue, 6 Sep 2022 17:46:55 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/6/2022 5:27 PM, Mr Flibble wrote:
> > On Tue, 6 Sep 2022 17:08:50 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 9/6/2022 4:36 PM, Paul N wrote:
> >>> On Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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.
> >>>
> >>> No, the set of Hx/Px pairs that does a correct and complete
> >>> simulation of its input (and gives the correct result) is zero.
> >>>
> >>> If Hx(Px, Px) is zero, the "if" fails, and the program halts.
> >>> If Hx(Px, Px) is non-zero, the "if" succeeds, and the program does
> >>> not halt.
> >>>
> >>> You can only say Hx(Px, Px) gives the actual behaviour if you
> >>> stick in a lot of weasel words which define "actual behaviour" to
> >>> be something different from (and indeed opposite to) the actual
> >>> behaviour.
> >>
> >> Not at all: (*see below*)
> >>
> >>>
> >>> The weasel words follow:
> >>>
> >>>> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
> >>>> (B) A correct and complete simulation of this input derives the
> >>>> actual behavior of this input.
> >>>>
> >>>> *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*
> >>
> >>
> >> *Hx(Px,Px)==0 // is correct* (see code defined above)
> >>
> >>
> >> *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
> >>
> >
> > Your decider still gives an incorrect result for the following
> > variant of Px which should always halt:
> >
> > void Px(ptr x)
> > {
> > int Halt_Status = Hx(x, x);
> > (void)Halt_Status;
> > return;
> > }
> >
> > You've still get nothing.
> >
> > /Flibble
> >
>
>
> void Pz(ptr x)
> {
> Hz(x, x);
> return;
> }
>
> int main()
> {
> Hz(Pz);
> }
>
> *Everyone that is reasonably competent at software analysis will know*
> There are zero elements of infinite set of Hz/Pz pairs such
> that the correct *partial or complete* simulation of Pz by Hz
> reaches the final state (return instruction) of Pz.

Pz should always halt, if it doesn't then Hz is faulty: your decider is
faulty.

/Flibble

On 9/6/22 1:56 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));
> }
>
> *THIS HAS BEEN AGREED TO* // *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 this input derives the actual
> behavior of this input.
>
> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
> (C) The actual behavior of this input never reaches the final state of
> this input.

But Every H that IS a UTM fails to answer, and every H that answers
fails to be a UTM.

Since every Px is tied to a PARTICULAR Hx, there are no Px that have
their Hx return 0 and also have a UTM showing them to be non-halting.

Thus, the only Px's you have show to be non-halting are those associsted
with Hx's that don't answer.

>
> 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:
>

But, NO Hx did that for the input Hx(Px,Px).

FAIL

Every Hx(Px,Px) that answers 0 has UTM(Px,Px) Halting, thus its answer
is wrong.

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

Red Herring.

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

Red Herring,

Fallacy of Proof by Example

>
> *Hx(Px,Px)==0 // is correct*
>
>

Nope. UTM(Px,Px) Halts if Hx(Px,Px) returns 0.

>
> *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
>
>

Garbage.

You have proved yourself STUPID.

On 9/6/2022 5:57 PM, Mr Flibble wrote:
> On Tue, 6 Sep 2022 17:46:55 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/6/2022 5:27 PM, Mr Flibble wrote:
>>> On Tue, 6 Sep 2022 17:08:50 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 9/6/2022 4:36 PM, Paul N wrote:
>>>>> On Tuesday, September 6, 2022 at 6:56:25 PM UTC+1, 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 HAS BEEN AGREED TO* // *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.
>>>>>
>>>>> No, the set of Hx/Px pairs that does a correct and complete
>>>>> simulation of its input (and gives the correct result) is zero.
>>>>>
>>>>> If Hx(Px, Px) is zero, the "if" fails, and the program halts.
>>>>> If Hx(Px, Px) is non-zero, the "if" succeeds, and the program does
>>>>> not halt.
>>>>>
>>>>> You can only say Hx(Px, Px) gives the actual behaviour if you
>>>>> stick in a lot of weasel words which define "actual behaviour" to
>>>>> be something different from (and indeed opposite to) the actual
>>>>> behaviour.
>>>>
>>>> Not at all: (*see below*)
>>>>
>>>>>
>>>>> The weasel words follow:
>>>>>
>>>>>> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
>>>>>> (B) A correct and complete simulation of this input derives the
>>>>>> actual behavior of this input.
>>>>>>
>>>>>> *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*
>>>>
>>>>
>>>> *Hx(Px,Px)==0 // is correct* (see code defined above)
>>>>
>>>>
>>>> *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
>>>>
>>>
>>> Your decider still gives an incorrect result for the following
>>> variant of Px which should always halt:
>>>
>>> void Px(ptr x)
>>> {
>>> int Halt_Status = Hx(x, x);
>>> (void)Halt_Status;
>>> return;
>>> }
>>>
>>> You've still get nothing.
>>>
>>> /Flibble
>>>
>>
>>
>> void Pz(ptr x)
>> {
>> Hz(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> Hz(Pz);
>> }
>>
>> *Everyone that is reasonably competent at software analysis will know*
>> There are zero elements of infinite set of Hz/Pz pairs such
>> that the correct *partial or complete* simulation of Pz by Hz
>> reaches the final state (return instruction) of Pz.
>
> Pz should always halt, if it doesn't then Hz is faulty: your decider is
> faulty.
>
> /Flibble
>

I am not even saying that Hz is a decider, I am referring to every
element of the set where Hz performs a correct *partial or complete*
simulation of Pz.

--
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/6/2022 6:01 PM, Richard Damon wrote:
>
> On 9/6/22 1:56 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));
>> }
>>
>> *THIS HAS BEEN AGREED TO* // *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 this input derives the actual
>> behavior of this input.
>>
>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>> (C) The actual behavior of this input never reaches the final state of
>> this input.
>
>
> But Every H that IS a UTM fails to answer, and every H that answers
> fails to be a UTM.
>
> Since every Px is tied to a PARTICULAR Hx, there are no Px that have
> their Hx return 0 and also have a UTM showing them to be non-halting.
>
> Thus, the only Px's you have show to be non-halting are those associsted
> with Hx's that don't answer.
>
>>
>> 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:
>>
>
> But, NO Hx did that for the input Hx(Px,Px).

*You seem to insufficiently appreciate what this infinite set comprises*

One of the elements of this set correctly simulates some fixed number of
steps of its input and then after that exactly performs every chess move
that deep blue performed when it defeated Kasparov.
https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)

Another element of this set correctly simulates some fixed number of
steps of its input and then after that translates the Lords prayer into
ancient Egyptian.

If that it the case then at least one element of this set returns 0 on
the basis that it correctly matched a correct infinite behavior pattern.

--
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/6/22 7:20 PM, olcott wrote:
> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>
>> On 9/6/22 1:56 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));
>>> }
>>>
>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>> actual behavior of this input.
>>>
>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>> (C) The actual behavior of this input never reaches the final state
>>> of this input.
>>
>>
>> But Every H that IS a UTM fails to answer, and every H that answers
>> fails to be a UTM.
>>
>> Since every Px is tied to a PARTICULAR Hx, there are no Px that have
>> their Hx return 0 and also have a UTM showing them to be non-halting.
>>
>> Thus, the only Px's you have show to be non-halting are those
>> associsted with Hx's that don't answer.
>>
>>>
>>> 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:
>>>
>>
>> But, NO Hx did that for the input Hx(Px,Px).
>
> *You seem to insufficiently appreciate what this infinite set comprises*
>
> One of the elements of this set correctly simulates some fixed number of
> steps of its input and then after that exactly performs every chess move
> that deep blue performed when it defeated Kasparov.
> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>
> Another element of this set correctly simulates some fixed number of
> steps of its input and then after that translates the Lords prayer into
> ancient Egyptian.
>
> If that it the case then at least one element of this set returns 0 on
> the basis that it correctly matched a correct infinite behavior pattern.
>

But the decider H isn't a "Set", but a particular program, and P isn't
calling a "Set", but the particular H that is deciding it.

Try to write a single program that implements "The Set" that still meets
the requirements to be a computation.

Yes, many elements of the set will correctly decide on P's made from a
different element of the set, but those decision don't match the
requirements to be a counter example.

Yes, the impossible program can often be easily decided by a different
decider, it is only shown to be impossible for the one decider that it
was made for to not decide it. The key is that we can make such an
"Impossible Program" for ANY decider, so no decider can decide all
possible programs.

This is one reason the impossible program is often given a name based on
teh name of the decider (lkie H^) to point out what decider it was built
to frustrate.

Your talking of "Sets" of deciders just shows that you still don't
understand what you are talking about.

On 9/6/2022 7:41 PM, Richard Damon wrote:
> On 9/6/22 7:20 PM, olcott wrote:
>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>
>>> On 9/6/22 1:56 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));
>>>> }
>>>>
>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>>> actual behavior of this input.
>>>>
>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>> (C) The actual behavior of this input never reaches the final state
>>>> of this input.
>>>
>>>
>>> But Every H that IS a UTM fails to answer, and every H that answers
>>> fails to be a UTM.
>>>
>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that have
>>> their Hx return 0 and also have a UTM showing them to be non-halting.
>>>
>>> Thus, the only Px's you have show to be non-halting are those
>>> associsted with Hx's that don't answer.
>>>
>>>>
>>>> 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:
>>>>
>>>
>>> But, NO Hx did that for the input Hx(Px,Px).
>>
>> *You seem to insufficiently appreciate what this infinite set comprises*
>>
>> One of the elements of this set correctly simulates some fixed number
>> of steps of its input and then after that exactly performs every chess
>> move that deep blue performed when it defeated Kasparov.
>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>
>> Another element of this set correctly simulates some fixed number of
>> steps of its input and then after that translates the Lords prayer
>> into ancient Egyptian.
>>
>> If that it the case then at least one element of this set returns 0 on
>> the basis that it correctly matched a correct infinite behavior pattern.
>>
>
> But the decider H isn't a "Set", but a particular program,

thus one element of the of the infinite set of Hx/Px pairs.

--
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/6/22 9:08 PM, olcott wrote:
> On 9/6/2022 7:41 PM, Richard Damon wrote:
>> On 9/6/22 7:20 PM, olcott wrote:
>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>
>>>> On 9/6/22 1:56 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));
>>>>> }
>>>>>
>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>>>> actual behavior of this input.
>>>>>
>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>> (C) The actual behavior of this input never reaches the final state
>>>>> of this input.
>>>>
>>>>
>>>> But Every H that IS a UTM fails to answer, and every H that answers
>>>> fails to be a UTM.
>>>>
>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that have
>>>> their Hx return 0 and also have a UTM showing them to be non-halting.
>>>>
>>>> Thus, the only Px's you have show to be non-halting are those
>>>> associsted with Hx's that don't answer.
>>>>
>>>>>
>>>>> 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:
>>>>>
>>>>
>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>
>>> *You seem to insufficiently appreciate what this infinite set comprises*
>>>
>>> One of the elements of this set correctly simulates some fixed number
>>> of steps of its input and then after that exactly performs every
>>> chess move that deep blue performed when it defeated Kasparov.
>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>
>>> Another element of this set correctly simulates some fixed number of
>>> steps of its input and then after that translates the Lords prayer
>>> into ancient Egyptian.
>>>
>>> If that it the case then at least one element of this set returns 0
>>> on the basis that it correctly matched a correct infinite behavior
>>> pattern.
>>>
>>
>> But the decider H isn't a "Set", but a particular program,
>
> thus one element of the of the infinite set of Hx/Px pairs.
>
>

And NO element of the set of Hx correctly decides on its own Px that
calls that particular Hx.

If you disagree, name one, that is an Hx(Px,Px) that returns 0 for
Hx(Px,Px) but we also have that UTM(Px,Px) doesn't Halt. Remember Px
calls THAT Hx(Px,Px) not any other.

Remember, Since this Hx aborts, it isn't a UTM so we need to ask a REAL
UTM (or an Hx that doesn't abort the simulation) about what the real
answer is.

Your problem is that you Hx's all seem to assume that Px calls Hn that
doesn't abort, not themselves, and thus incorrect determine their behavior.

On 9/6/2022 8:41 PM, Richard Damon wrote:
> On 9/6/22 9:08 PM, olcott wrote:
>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>> On 9/6/22 7:20 PM, olcott wrote:
>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/6/22 1:56 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));
>>>>>> }
>>>>>>
>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>>>>> actual behavior of this input.
>>>>>>
>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>> (C) The actual behavior of this input never reaches the final
>>>>>> state of this input.
>>>>>
>>>>>
>>>>> But Every H that IS a UTM fails to answer, and every H that answers
>>>>> fails to be a UTM.
>>>>>
>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that
>>>>> have their Hx return 0 and also have a UTM showing them to be
>>>>> non-halting.
>>>>>
>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>> associsted with Hx's that don't answer.
>>>>>
>>>>>>
>>>>>> 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:
>>>>>>
>>>>>
>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>
>>>> *You seem to insufficiently appreciate what this infinite set
>>>> comprises*
>>>>
>>>> One of the elements of this set correctly simulates some fixed
>>>> number of steps of its input and then after that exactly performs
>>>> every chess move that deep blue performed when it defeated Kasparov.
>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>
>>>> Another element of this set correctly simulates some fixed number of
>>>> steps of its input and then after that translates the Lords prayer
>>>> into ancient Egyptian.
>>>>
>>>> If that it the case then at least one element of this set returns 0
>>>> on the basis that it correctly matched a correct infinite behavior
>>>> pattern.
>>>>
>>>
>>> But the decider H isn't a "Set", but a particular program,
>>
>> thus one element of the of the infinite set of Hx/Px pairs.
>>
>>
>
> And NO element of the set of Hx correctly decides on its own Px that
> calls that particular Hx.
>

Every element of the Hx/Px pairs that simply returns 0 correctly
predicts that its correct and complete simulation of its input would
never reach the final state of this input because every element of the
infinite set of Hx/Px pairs that correctly and completely simulates its
input never reaches the final state of this input.

A subset of these would also correctly match a correct infinite behavior
pattern that correctly predicts that its correct and complete simulation
of its input would never reach the final state of this input.

> If you disagree, name one, that is an Hx(Px,Px) that returns 0 for
> Hx(Px,Px) but we also have that UTM(Px,Px) doesn't Halt. Remember Px
> calls THAT Hx(Px,Px) not any other.
>
> Remember, Since this Hx aborts, it isn't a UTM so we need to ask a REAL
> UTM (or an Hx that doesn't abort the simulation) about what the real
> answer is.
>
> Your problem is that you Hx's all seem to assume that Px calls Hn that
> doesn't abort, not themselves, and thus incorrect determine their 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/7/22 10:14 AM, olcott wrote:
> On 9/6/2022 8:41 PM, Richard Damon wrote:
>> On 9/6/22 9:08 PM, olcott wrote:
>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/6/22 1:56 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));
>>>>>>> }
>>>>>>>
>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>>>>>> actual behavior of this input.
>>>>>>>
>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>> (C) The actual behavior of this input never reaches the final
>>>>>>> state of this input.
>>>>>>
>>>>>>
>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>> answers fails to be a UTM.
>>>>>>
>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that
>>>>>> have their Hx return 0 and also have a UTM showing them to be
>>>>>> non-halting.
>>>>>>
>>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>>> associsted with Hx's that don't answer.
>>>>>>
>>>>>>>
>>>>>>> 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:
>>>>>>>
>>>>>>
>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>
>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>> comprises*
>>>>>
>>>>> One of the elements of this set correctly simulates some fixed
>>>>> number of steps of its input and then after that exactly performs
>>>>> every chess move that deep blue performed when it defeated Kasparov.
>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>
>>>>> Another element of this set correctly simulates some fixed number
>>>>> of steps of its input and then after that translates the Lords
>>>>> prayer into ancient Egyptian.
>>>>>
>>>>> If that it the case then at least one element of this set returns 0
>>>>> on the basis that it correctly matched a correct infinite behavior
>>>>> pattern.
>>>>>
>>>>
>>>> But the decider H isn't a "Set", but a particular program,
>>>
>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>
>>>
>>
>> And NO element of the set of Hx correctly decides on its own Px that
>> calls that particular Hx.
>>
>
> Every element of the Hx/Px pairs that simply returns 0 correctly
> predicts that its correct and complete simulation of its input would
> never reach the final state of this input because every element of the
> infinite set of Hx/Px pairs that correctly and completely simulates its
> input never reaches the final state of this input.

No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
Hx(Px,P) will Halt.

Thus the CORRECT complete simulation of that input Halts, and you are
caught in a LIE.

if Hx(Px,Px) returns 0, then it did NOT do a COMPLETE simulation of its
input, and no other member of the set has looked at its i9nput, so they
dont mattter.

Note, if you DO run Hn(Pa,Pa) where Hn is a version of Hx that doesn't
abort, and Ha is a version of Hx that does on these inputs, and Pa the
the Px buiiolt on it, we wee that Hn(Pa,Pa) WILL do a complete
simulation, and see it halting, PROVING that Ha was wrong to say that
Ha(Pa,Pa) was the right answer.

>
> A subset of these would also correctly match a correct infinite behavior
> pattern that correctly predicts that its correct and complete simulation
> of its input would never reach the final state of this input.

Nope, The subset of Px that return 0 and have their input match a
CORRECT infinite behavior pattern is the EMPTY set.

Your repeating the unfounded, and disproven, claim, just shows your
stupidity and lack of honesty.

YOU FAIL and have sealed your disgrace.

>> If you disagree, name one, that is an Hx(Px,Px) that returns 0 for
>> Hx(Px,Px) but we also have that UTM(Px,Px) doesn't Halt. Remember Px
>> calls THAT Hx(Px,Px) not any other.
>>
>> Remember, Since this Hx aborts, it isn't a UTM so we need to ask a
>> REAL UTM (or an Hx that doesn't abort the simulation) about what the
>> real answer is.
>>
>> Your problem is that you Hx's all seem to assume that Px calls Hn that
>> doesn't abort, not themselves, and thus incorrect determine their
>> behavior.
>

On 9/7/2022 5:54 PM, Richard Damon wrote:
> On 9/7/22 10:14 AM, olcott wrote:
>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>> On 9/6/22 9:08 PM, olcott wrote:
>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/6/22 1:56 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));
>>>>>>>> }
>>>>>>>>
>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>>>>>>> actual behavior of this input.
>>>>>>>>
>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>> (C) The actual behavior of this input never reaches the final
>>>>>>>> state of this input.
>>>>>>>
>>>>>>>
>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>> answers fails to be a UTM.
>>>>>>>
>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that
>>>>>>> have their Hx return 0 and also have a UTM showing them to be
>>>>>>> non-halting.
>>>>>>>
>>>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>>>> associsted with Hx's that don't answer.
>>>>>>>
>>>>>>>>
>>>>>>>> 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:
>>>>>>>>
>>>>>>>
>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>
>>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>>> comprises*
>>>>>>
>>>>>> One of the elements of this set correctly simulates some fixed
>>>>>> number of steps of its input and then after that exactly performs
>>>>>> every chess move that deep blue performed when it defeated Kasparov.
>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>
>>>>>> Another element of this set correctly simulates some fixed number
>>>>>> of steps of its input and then after that translates the Lords
>>>>>> prayer into ancient Egyptian.
>>>>>>
>>>>>> If that it the case then at least one element of this set returns
>>>>>> 0 on the basis that it correctly matched a correct infinite
>>>>>> behavior pattern.
>>>>>>
>>>>>
>>>>> But the decider H isn't a "Set", but a particular program,
>>>>
>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>
>>>>
>>>
>>> And NO element of the set of Hx correctly decides on its own Px that
>>> calls that particular Hx.
>>>
>>
>> Every element of the Hx/Px pairs that simply returns 0 correctly
>> predicts that its correct and complete simulation of its input would
>> never reach the final state of this input because every element of the
>> infinite set of Hx/Px pairs that correctly and completely simulates
>> its input never reaches the final state of this input.
>
> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
> Hx(Px,P) will Halt.
>

If all X are Y and you disagree then you are wrong.

If every correct and complete simulation of the input to Hx never stops
running and it is the job of some Hx to predict whether or not the
correct and complete simulation of the input to Hx would ever stop
running then even this Hx is correct:

int Hx(ptr x, ptr y)
{ return 0;
}

--
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/7/22 7:01 PM, olcott wrote:
> On 9/7/2022 5:54 PM, Richard Damon wrote:
>> On 9/7/22 10:14 AM, olcott wrote:
>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives the
>>>>>>>>> actual behavior of this input.
>>>>>>>>>
>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>> (C) The actual behavior of this input never reaches the final
>>>>>>>>> state of this input.
>>>>>>>>
>>>>>>>>
>>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>>> answers fails to be a UTM.
>>>>>>>>
>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that
>>>>>>>> have their Hx return 0 and also have a UTM showing them to be
>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>>>>> associsted with Hx's that don't answer.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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:
>>>>>>>>>
>>>>>>>>
>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>
>>>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>>>> comprises*
>>>>>>>
>>>>>>> One of the elements of this set correctly simulates some fixed
>>>>>>> number of steps of its input and then after that exactly performs
>>>>>>> every chess move that deep blue performed when it defeated Kasparov.
>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>
>>>>>>> Another element of this set correctly simulates some fixed number
>>>>>>> of steps of its input and then after that translates the Lords
>>>>>>> prayer into ancient Egyptian.
>>>>>>>
>>>>>>> If that it the case then at least one element of this set returns
>>>>>>> 0 on the basis that it correctly matched a correct infinite
>>>>>>> behavior pattern.
>>>>>>>
>>>>>>
>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>
>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>
>>>>>
>>>>
>>>> And NO element of the set of Hx correctly decides on its own Px that
>>>> calls that particular Hx.
>>>>
>>>
>>> Every element of the Hx/Px pairs that simply returns 0 correctly
>>> predicts that its correct and complete simulation of its input would
>>> never reach the final state of this input because every element of
>>> the infinite set of Hx/Px pairs that correctly and completely
>>> simulates its input never reaches the final state of this input.
>>
>> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
>> Hx(Px,P) will Halt.
>>
>
> If all X are Y and you disagree then you are wrong.

What are X's and what are Y's?

>
> If every correct and complete simulation of the input to Hx never stops
> running and it is the job of some Hx to predict whether or not the
> correct and complete simulation of the input to Hx would ever stop
> running then even this Hx is correct:

Right, EVERT Hx that does a correct and complete simulation of its input
NEVER gives an answer about its corresponding input. Yes, those inputs
are non-halting, but Hx fails to identify them, and thus Hx isn't even a
decider.

The OTHER Hx's, that do abort their simulations, do NOT do a complete
simulation of their input, and for EVERY one of them, UTM(Px,Px) for the
Px built on them will Halt, so they are wrong.

Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail to
meet the requirements of a Halt Decider.

>
> int Hx(ptr x, ptr y)
> {
>   return 0;
> }
>
>

Right, and the Px built on that Halts, so it is wrong.

Do you think otherwise?

By your argument, EVERY input is non-halting, becuase that Hx is just as
right about any halting input.

You have been told this many times. The fact that you haven't learned
and continue to repeat this fabrication is proof that you are a
pathological liar, totally ignorant of the material you are talking
about, and a complete idiot.

This is your Legacy, to be the laughing stock of everyone who sees your
work.

On 9/7/2022 7:36 PM, Richard Damon wrote:
>
> On 9/7/22 7:01 PM, olcott wrote:
>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>> On 9/7/22 10:14 AM, olcott wrote:
>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives
>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>
>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>> (C) The actual behavior of this input never reaches the final
>>>>>>>>>> state of this input.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>>>> answers fails to be a UTM.
>>>>>>>>>
>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px that
>>>>>>>>> have their Hx return 0 and also have a UTM showing them to be
>>>>>>>>> non-halting.
>>>>>>>>>
>>>>>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>>>>>> associsted with Hx's that don't answer.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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:
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>
>>>>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>>>>> comprises*
>>>>>>>>
>>>>>>>> One of the elements of this set correctly simulates some fixed
>>>>>>>> number of steps of its input and then after that exactly
>>>>>>>> performs every chess move that deep blue performed when it
>>>>>>>> defeated Kasparov.
>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>
>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>> number of steps of its input and then after that translates the
>>>>>>>> Lords prayer into ancient Egyptian.
>>>>>>>>
>>>>>>>> If that it the case then at least one element of this set
>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>> infinite behavior pattern.
>>>>>>>>
>>>>>>>
>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>
>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>
>>>>>>
>>>>>
>>>>> And NO element of the set of Hx correctly decides on its own Px
>>>>> that calls that particular Hx.
>>>>>
>>>>
>>>> Every element of the Hx/Px pairs that simply returns 0 correctly
>>>> predicts that its correct and complete simulation of its input would
>>>> never reach the final state of this input because every element of
>>>> the infinite set of Hx/Px pairs that correctly and completely
>>>> simulates its input never reaches the final state of this input.
>>>
>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
>>> Hx(Px,P) will Halt.
>>>
>>
>> If all X are Y and you disagree then you are wrong.
>
> What are X's and what are Y's?
>
>>
>> If every correct and complete simulation of the input to Hx never
>> stops running and it is the job of some Hx to predict whether or not
>> the correct and complete simulation of the input to Hx would ever stop
>> running then even this Hx is correct:
>
> Right, EVERT Hx that does a correct and complete simulation of its input
> NEVER gives an answer about its corresponding input. Yes, those inputs
> are non-halting, but Hx fails to identify them, and thus Hx isn't even a
> decider.
>
> The OTHER Hx's, that do abort their simulations, do NOT do a complete
> simulation of their input, and for EVERY one of them, UTM(Px,Px) for the
> Px built on them will Halt, so they are wrong.
>
> Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail to
> meet the requirements of a Halt Decider.
>
>>
>> int Hx(ptr x, ptr y)
>> {
>>    return 0;
>> }
>>
>>
>
> Right, and the Px built on that Halts, so it is wrong.
>
This function computes the correct answer to every question where the
answer is yes.

bool Answer()
{ return true;
}

--
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/7/22 8:59 PM, olcott wrote:
> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>
>> On 9/7/22 7:01 PM, olcott wrote:
>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives
>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>
>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>> (C) The actual behavior of this input never reaches the final
>>>>>>>>>>> state of this input.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>>>>> answers fails to be a UTM.
>>>>>>>>>>
>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px
>>>>>>>>>> that have their Hx return 0 and also have a UTM showing them
>>>>>>>>>> to be non-halting.
>>>>>>>>>>
>>>>>>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>>>>>>> associsted with Hx's that don't answer.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 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:
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>
>>>>>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>>>>>> comprises*
>>>>>>>>>
>>>>>>>>> One of the elements of this set correctly simulates some fixed
>>>>>>>>> number of steps of its input and then after that exactly
>>>>>>>>> performs every chess move that deep blue performed when it
>>>>>>>>> defeated Kasparov.
>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>
>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>> number of steps of its input and then after that translates the
>>>>>>>>> Lords prayer into ancient Egyptian.
>>>>>>>>>
>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>> infinite behavior pattern.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>
>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And NO element of the set of Hx correctly decides on its own Px
>>>>>> that calls that particular Hx.
>>>>>>
>>>>>
>>>>> Every element of the Hx/Px pairs that simply returns 0 correctly
>>>>> predicts that its correct and complete simulation of its input
>>>>> would never reach the final state of this input because every
>>>>> element of the infinite set of Hx/Px pairs that correctly and
>>>>> completely simulates its input never reaches the final state of
>>>>> this input.
>>>>
>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
>>>> Hx(Px,P) will Halt.
>>>>
>>>
>>> If all X are Y and you disagree then you are wrong.
>>
>> What are X's and what are Y's?
>>
>>>
>>> If every correct and complete simulation of the input to Hx never
>>> stops running and it is the job of some Hx to predict whether or not
>>> the correct and complete simulation of the input to Hx would ever
>>> stop running then even this Hx is correct:
>>
>> Right, EVERT Hx that does a correct and complete simulation of its
>> input NEVER gives an answer about its corresponding input. Yes, those
>> inputs are non-halting, but Hx fails to identify them, and thus Hx
>> isn't even a decider.
>>
>> The OTHER Hx's, that do abort their simulations, do NOT do a complete
>> simulation of their input, and for EVERY one of them, UTM(Px,Px) for
>> the Px built on them will Halt, so they are wrong.
>>
>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail to
>> meet the requirements of a Halt Decider.
>>
>>>
>>> int Hx(ptr x, ptr y)
>>> {
>>>    return 0;
>>> }
>>>
>>>
>>
>> Right, and the Px built on that Halts, so it is wrong.
>>
> This function computes the correct answer to every question where the
> answer is yes.
>
> bool Answer()
> {
>   return true;
> }
>

So, since the CORRECT answer to the Hx(Px,Px) for the Px of the above Hx
is Halt, it isn't right.

You are just proving your level of brain damage.

WRONG answer are never right.

It seems, neither are you.

On 9/7/2022 8:02 PM, Richard Damon wrote:
> On 9/7/22 8:59 PM, olcott wrote:
>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>
>>> On 9/7/22 7:01 PM, olcott wrote:
>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives
>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>
>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>>>>>> answers fails to be a UTM.
>>>>>>>>>>>
>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px
>>>>>>>>>>> that have their Hx return 0 and also have a UTM showing them
>>>>>>>>>>> to be non-halting.
>>>>>>>>>>>
>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are those
>>>>>>>>>>> associsted with Hx's that don't answer.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> 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:
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>
>>>>>>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>>>>>>> comprises*
>>>>>>>>>>
>>>>>>>>>> One of the elements of this set correctly simulates some fixed
>>>>>>>>>> number of steps of its input and then after that exactly
>>>>>>>>>> performs every chess move that deep blue performed when it
>>>>>>>>>> defeated Kasparov.
>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>
>>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>>> number of steps of its input and then after that translates
>>>>>>>>>> the Lords prayer into ancient Egyptian.
>>>>>>>>>>
>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>>> infinite behavior pattern.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>
>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And NO element of the set of Hx correctly decides on its own Px
>>>>>>> that calls that particular Hx.
>>>>>>>
>>>>>>
>>>>>> Every element of the Hx/Px pairs that simply returns 0 correctly
>>>>>> predicts that its correct and complete simulation of its input
>>>>>> would never reach the final state of this input because every
>>>>>> element of the infinite set of Hx/Px pairs that correctly and
>>>>>> completely simulates its input never reaches the final state of
>>>>>> this input.
>>>>>
>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
>>>>> Hx(Px,P) will Halt.
>>>>>
>>>>
>>>> If all X are Y and you disagree then you are wrong.
>>>
>>> What are X's and what are Y's?
>>>
>>>>
>>>> If every correct and complete simulation of the input to Hx never
>>>> stops running and it is the job of some Hx to predict whether or not
>>>> the correct and complete simulation of the input to Hx would ever
>>>> stop running then even this Hx is correct:
>>>
>>> Right, EVERT Hx that does a correct and complete simulation of its
>>> input NEVER gives an answer about its corresponding input. Yes, those
>>> inputs are non-halting, but Hx fails to identify them, and thus Hx
>>> isn't even a decider.
>>>
>>> The OTHER Hx's, that do abort their simulations, do NOT do a complete
>>> simulation of their input, and for EVERY one of them, UTM(Px,Px) for
>>> the Px built on them will Halt, so they are wrong.
>>>
>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail to
>>> meet the requirements of a Halt Decider.
>>>
>>>>
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>>    return 0;
>>>> }
>>>>
>>>>
>>>
>>> Right, and the Px built on that Halts, so it is wrong.
>>>
>> This function computes the correct answer to every question where the
>> answer is yes.
>>
>> bool Answer()
>> {
>>    return true;
>> }
>>
>
> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the above Hx
> is Halt, it isn't right.
>

This function computes the correct answer to every question where the
answer is no.

bool Answer_No()
{ return false;
}

On 9/7/22 9:12 PM, olcott wrote:
> On 9/7/2022 8:02 PM, Richard Damon wrote:
>> On 9/7/22 8:59 PM, olcott wrote:
>>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>>
>>>> On 9/7/22 7:01 PM, olcott wrote:
>>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input derives
>>>>>>>>>>>>> the actual behavior of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>>>>>>> answers fails to be a UTM.
>>>>>>>>>>>>
>>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px
>>>>>>>>>>>> that have their Hx return 0 and also have a UTM showing them
>>>>>>>>>>>> to be non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are
>>>>>>>>>>>> those associsted with Hx's that don't answer.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>>
>>>>>>>>>>> *You seem to insufficiently appreciate what this infinite set
>>>>>>>>>>> comprises*
>>>>>>>>>>>
>>>>>>>>>>> One of the elements of this set correctly simulates some
>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>> exactly performs every chess move that deep blue performed
>>>>>>>>>>> when it defeated Kasparov.
>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>>
>>>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>>>> number of steps of its input and then after that translates
>>>>>>>>>>> the Lords prayer into ancient Egyptian.
>>>>>>>>>>>
>>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>>>> infinite behavior pattern.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>>
>>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And NO element of the set of Hx correctly decides on its own Px
>>>>>>>> that calls that particular Hx.
>>>>>>>>
>>>>>>>
>>>>>>> Every element of the Hx/Px pairs that simply returns 0 correctly
>>>>>>> predicts that its correct and complete simulation of its input
>>>>>>> would never reach the final state of this input because every
>>>>>>> element of the infinite set of Hx/Px pairs that correctly and
>>>>>>> completely simulates its input never reaches the final state of
>>>>>>> this input.
>>>>>>
>>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
>>>>>> Hx(Px,P) will Halt.
>>>>>>
>>>>>
>>>>> If all X are Y and you disagree then you are wrong.
>>>>
>>>> What are X's and what are Y's?
>>>>
>>>>>
>>>>> If every correct and complete simulation of the input to Hx never
>>>>> stops running and it is the job of some Hx to predict whether or
>>>>> not the correct and complete simulation of the input to Hx would
>>>>> ever stop running then even this Hx is correct:
>>>>
>>>> Right, EVERT Hx that does a correct and complete simulation of its
>>>> input NEVER gives an answer about its corresponding input. Yes,
>>>> those inputs are non-halting, but Hx fails to identify them, and
>>>> thus Hx isn't even a decider.
>>>>
>>>> The OTHER Hx's, that do abort their simulations, do NOT do a
>>>> complete simulation of their input, and for EVERY one of them,
>>>> UTM(Px,Px) for the Px built on them will Halt, so they are wrong.
>>>>
>>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail
>>>> to meet the requirements of a Halt Decider.
>>>>
>>>>>
>>>>> int Hx(ptr x, ptr y)
>>>>> {
>>>>>    return 0;
>>>>> }
>>>>>
>>>>>
>>>>
>>>> Right, and the Px built on that Halts, so it is wrong.
>>>>
>>> This function computes the correct answer to every question where the
>>> answer is yes.
>>>
>>> bool Answer()
>>> {
>>>    return true;
>>> }
>>>
>>
>> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the above
>> Hx is Halt, it isn't right.
>>
>
>
> This function computes the correct answer to every question where the
> answer is no.
>
> bool Answer_No()
> {
>   return false;
> }

On 9/7/2022 8:21 PM, Richard Damon wrote:
>
> On 9/7/22 9:12 PM, olcott wrote:
>> On 9/7/2022 8:02 PM, Richard Damon wrote:
>>> On 9/7/22 8:59 PM, olcott wrote:
>>>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/7/22 7:01 PM, olcott wrote:
>>>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input
>>>>>>>>>>>>>> derives the actual behavior of this input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H that
>>>>>>>>>>>>> answers fails to be a UTM.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px
>>>>>>>>>>>>> that have their Hx return 0 and also have a UTM showing
>>>>>>>>>>>>> them to be non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are
>>>>>>>>>>>>> those associsted with Hx's that don't answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>>>
>>>>>>>>>>>> *You seem to insufficiently appreciate what this infinite
>>>>>>>>>>>> set comprises*
>>>>>>>>>>>>
>>>>>>>>>>>> One of the elements of this set correctly simulates some
>>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>>> exactly performs every chess move that deep blue performed
>>>>>>>>>>>> when it defeated Kasparov.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>>>
>>>>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>>>>> number of steps of its input and then after that translates
>>>>>>>>>>>> the Lords prayer into ancient Egyptian.
>>>>>>>>>>>>
>>>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>>>>> infinite behavior pattern.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>>>
>>>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And NO element of the set of Hx correctly decides on its own Px
>>>>>>>>> that calls that particular Hx.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every element of the Hx/Px pairs that simply returns 0 correctly
>>>>>>>> predicts that its correct and complete simulation of its input
>>>>>>>> would never reach the final state of this input because every
>>>>>>>> element of the infinite set of Hx/Px pairs that correctly and
>>>>>>>> completely simulates its input never reaches the final state of
>>>>>>>> this input.
>>>>>>>
>>>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0 from
>>>>>>> Hx(Px,P) will Halt.
>>>>>>>
>>>>>>
>>>>>> If all X are Y and you disagree then you are wrong.
>>>>>
>>>>> What are X's and what are Y's?
>>>>>
>>>>>>
>>>>>> If every correct and complete simulation of the input to Hx never
>>>>>> stops running and it is the job of some Hx to predict whether or
>>>>>> not the correct and complete simulation of the input to Hx would
>>>>>> ever stop running then even this Hx is correct:
>>>>>
>>>>> Right, EVERT Hx that does a correct and complete simulation of its
>>>>> input NEVER gives an answer about its corresponding input. Yes,
>>>>> those inputs are non-halting, but Hx fails to identify them, and
>>>>> thus Hx isn't even a decider.
>>>>>
>>>>> The OTHER Hx's, that do abort their simulations, do NOT do a
>>>>> complete simulation of their input, and for EVERY one of them,
>>>>> UTM(Px,Px) for the Px built on them will Halt, so they are wrong.
>>>>>
>>>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail
>>>>> to meet the requirements of a Halt Decider.
>>>>>
>>>>>>
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>>    return 0;
>>>>>> }
>>>>>>
>>>>>>
>>>>>
>>>>> Right, and the Px built on that Halts, so it is wrong.
>>>>>
>>>> This function computes the correct answer to every question where
>>>> the answer is yes.
>>>>
>>>> bool Answer()
>>>> {
>>>>    return true;
>>>> }
>>>>
>>>
>>> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the above
>>> Hx is Halt, it isn't right.
>>>
>>
>>
>> This function computes the correct answer to every question where the
>> answer is no.
>>
>> bool Answer_No()
>> {
>>    return false;
>> }
>
> So.
>>
>> When the question is:
>> Does the complete and correct simulation of Px by Hx ever stop running?
>
> And the answer for the Px built on that Hx is YES.
>
> Px(Px) calls your Hx(Px,Px) it immediately returns false and Px halts.
>
> What is wrong with that simulation?
>
> Even YOU should be able to see that.
>
>>
>> Answer_No() provides the correct answer.
>
> How, since it halts?
void Px(ptr x)
{
Click here to read the complete article

On 9/7/22 9:43 PM, olcott wrote:
> On 9/7/2022 8:21 PM, Richard Damon wrote:
>>
>> On 9/7/22 9:12 PM, olcott wrote:
>>> On 9/7/2022 8:02 PM, Richard Damon wrote:
>>>> On 9/7/22 8:59 PM, olcott wrote:
>>>>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/7/22 7:01 PM, olcott wrote:
>>>>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input
>>>>>>>>>>>>>>> derives the actual behavior of this input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H
>>>>>>>>>>>>>> that answers fails to be a UTM.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no Px
>>>>>>>>>>>>>> that have their Hx return 0 and also have a UTM showing
>>>>>>>>>>>>>> them to be non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are
>>>>>>>>>>>>>> those associsted with Hx's that don't answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>>>>
>>>>>>>>>>>>> *You seem to insufficiently appreciate what this infinite
>>>>>>>>>>>>> set comprises*
>>>>>>>>>>>>>
>>>>>>>>>>>>> One of the elements of this set correctly simulates some
>>>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>>>> exactly performs every chess move that deep blue performed
>>>>>>>>>>>>> when it defeated Kasparov.
>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>>>>>> number of steps of its input and then after that translates
>>>>>>>>>>>>> the Lords prayer into ancient Egyptian.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>>>>>> infinite behavior pattern.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>>>>
>>>>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And NO element of the set of Hx correctly decides on its own
>>>>>>>>>> Px that calls that particular Hx.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Every element of the Hx/Px pairs that simply returns 0
>>>>>>>>> correctly predicts that its correct and complete simulation of
>>>>>>>>> its input would never reach the final state of this input
>>>>>>>>> because every element of the infinite set of Hx/Px pairs that
>>>>>>>>> correctly and completely simulates its input never reaches the
>>>>>>>>> final state of this input.
>>>>>>>>
>>>>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0
>>>>>>>> from Hx(Px,P) will Halt.
>>>>>>>>
>>>>>>>
>>>>>>> If all X are Y and you disagree then you are wrong.
>>>>>>
>>>>>> What are X's and what are Y's?
>>>>>>
>>>>>>>
>>>>>>> If every correct and complete simulation of the input to Hx never
>>>>>>> stops running and it is the job of some Hx to predict whether or
>>>>>>> not the correct and complete simulation of the input to Hx would
>>>>>>> ever stop running then even this Hx is correct:
>>>>>>
>>>>>> Right, EVERT Hx that does a correct and complete simulation of its
>>>>>> input NEVER gives an answer about its corresponding input. Yes,
>>>>>> those inputs are non-halting, but Hx fails to identify them, and
>>>>>> thus Hx isn't even a decider.
>>>>>>
>>>>>> The OTHER Hx's, that do abort their simulations, do NOT do a
>>>>>> complete simulation of their input, and for EVERY one of them,
>>>>>> UTM(Px,Px) for the Px built on them will Halt, so they are wrong.
>>>>>>
>>>>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they fail
>>>>>> to meet the requirements of a Halt Decider.
>>>>>>
>>>>>>>
>>>>>>> int Hx(ptr x, ptr y)
>>>>>>> {
>>>>>>>    return 0;
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, and the Px built on that Halts, so it is wrong.
>>>>>>
>>>>> This function computes the correct answer to every question where
>>>>> the answer is yes.
>>>>>
>>>>> bool Answer()
>>>>> {
>>>>>    return true;
>>>>> }
>>>>>
>>>>
>>>> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the
>>>> above Hx is Halt, it isn't right.
>>>>
>>>
>>>
>>> This function computes the correct answer to every question where the
>>> answer is no.
>>>
>>> bool Answer_No()
>>> {
>>>    return false;
>>> }
>>
>> So.
>>>
>>> When the question is:
>>> Does the complete and correct simulation of Px by Hx ever stop running?
>>
>> And the answer for the Px built on that Hx is YES.
>>
>> Px(Px) calls your Hx(Px,Px) it immediately returns false and Px halts.
>>
>> What is wrong with that simulation?
>>
>> Even YOU should be able to see that.
>>
>>>
>>> Answer_No() provides the correct answer.
>>
>> How, since it halts?
> void Px(ptr x)
> {
>   int Halt_Status = Hx(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> *You forgot that you agreed that you agreed that the answer is NO*
> Does the complete and correct simulation of Px by Hx ever stop running?
>
>

On 9/7/2022 8:50 PM, Richard Damon wrote:
> On 9/7/22 9:43 PM, olcott wrote:
>> On 9/7/2022 8:21 PM, Richard Damon wrote:
>>>
>>> On 9/7/22 9:12 PM, olcott wrote:
>>>> On 9/7/2022 8:02 PM, Richard Damon wrote:
>>>>> On 9/7/22 8:59 PM, olcott wrote:
>>>>>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/7/22 7:01 PM, olcott wrote:
>>>>>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input
>>>>>>>>>>>>>>>> derives the actual behavior of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H
>>>>>>>>>>>>>>> that answers fails to be a UTM.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no
>>>>>>>>>>>>>>> Px that have their Hx return 0 and also have a UTM
>>>>>>>>>>>>>>> showing them to be non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are
>>>>>>>>>>>>>>> those associsted with Hx's that don't answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seem to insufficiently appreciate what this infinite
>>>>>>>>>>>>>> set comprises*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> One of the elements of this set correctly simulates some
>>>>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>>>>> exactly performs every chess move that deep blue performed
>>>>>>>>>>>>>> when it defeated Kasparov.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Another element of this set correctly simulates some fixed
>>>>>>>>>>>>>> number of steps of its input and then after that
>>>>>>>>>>>>>> translates the Lords prayer into ancient Egyptian.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>>>>>> returns 0 on the basis that it correctly matched a correct
>>>>>>>>>>>>>> infinite behavior pattern.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>>>>>
>>>>>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And NO element of the set of Hx correctly decides on its own
>>>>>>>>>>> Px that calls that particular Hx.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every element of the Hx/Px pairs that simply returns 0
>>>>>>>>>> correctly predicts that its correct and complete simulation of
>>>>>>>>>> its input would never reach the final state of this input
>>>>>>>>>> because every element of the infinite set of Hx/Px pairs that
>>>>>>>>>> correctly and completely simulates its input never reaches the
>>>>>>>>>> final state of this input.
>>>>>>>>>
>>>>>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0
>>>>>>>>> from Hx(Px,P) will Halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If all X are Y and you disagree then you are wrong.
>>>>>>>
>>>>>>> What are X's and what are Y's?
>>>>>>>
>>>>>>>>
>>>>>>>> If every correct and complete simulation of the input to Hx
>>>>>>>> never stops running and it is the job of some Hx to predict
>>>>>>>> whether or not the correct and complete simulation of the input
>>>>>>>> to Hx would ever stop running then even this Hx is correct:
>>>>>>>
>>>>>>> Right, EVERT Hx that does a correct and complete simulation of
>>>>>>> its input NEVER gives an answer about its corresponding input.
>>>>>>> Yes, those inputs are non-halting, but Hx fails to identify them,
>>>>>>> and thus Hx isn't even a decider.
>>>>>>>
>>>>>>> The OTHER Hx's, that do abort their simulations, do NOT do a
>>>>>>> complete simulation of their input, and for EVERY one of them,
>>>>>>> UTM(Px,Px) for the Px built on them will Halt, so they are wrong.
>>>>>>>
>>>>>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they
>>>>>>> fail to meet the requirements of a Halt Decider.
>>>>>>>
>>>>>>>>
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>>    return 0;
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, and the Px built on that Halts, so it is wrong.
>>>>>>>
>>>>>> This function computes the correct answer to every question where
>>>>>> the answer is yes.
>>>>>>
>>>>>> bool Answer()
>>>>>> {
>>>>>>    return true;
>>>>>> }
>>>>>>
>>>>>
>>>>> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the
>>>>> above Hx is Halt, it isn't right.
>>>>>
>>>>
>>>>
>>>> This function computes the correct answer to every question where
>>>> the answer is no.
>>>>
>>>> bool Answer_No()
>>>> {
>>>>    return false;
>>>> }
>>>
>>> So.
>>>>
>>>> When the question is:
>>>> Does the complete and correct simulation of Px by Hx ever stop running?
>>>
>>> And the answer for the Px built on that Hx is YES.
>>>
>>> Px(Px) calls your Hx(Px,Px) it immediately returns false and Px halts.
>>>
>>> What is wrong with that simulation?
>>>
>>> Even YOU should be able to see that.
>>>
>>>>
>>>> Answer_No() provides the correct answer.
>>>
>>> How, since it halts?
>> void Px(ptr x)
>> {
>>    int Halt_Status = Hx(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> *You forgot that you agreed that you agreed that the answer is NO*
>> Does the complete and correct simulation of Px by Hx ever stop running?
>>
>>
>
> I never agreed that the answer was No. You are just lying again.
>
> I agreed that for the Hx that NEVER stops simulating, the answer is no,
>

On 9/7/22 9:58 PM, olcott wrote:
> On 9/7/2022 8:50 PM, Richard Damon wrote:
>> On 9/7/22 9:43 PM, olcott wrote:
>>> On 9/7/2022 8:21 PM, Richard Damon wrote:
>>>>
>>>> On 9/7/22 9:12 PM, olcott wrote:
>>>>> On 9/7/2022 8:02 PM, Richard Damon wrote:
>>>>>> On 9/7/22 8:59 PM, olcott wrote:
>>>>>>> On 9/7/2022 7:36 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/7/22 7:01 PM, olcott wrote:
>>>>>>>>> On 9/7/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>> On 9/7/22 10:14 AM, olcott wrote:
>>>>>>>>>>> On 9/6/2022 8:41 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/6/22 9:08 PM, olcott wrote:
>>>>>>>>>>>>> On 9/6/2022 7:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/6/22 7:20 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/6/2022 6:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/6/22 1:56 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));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *THIS HAS BEEN AGREED TO* // *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 this input
>>>>>>>>>>>>>>>>> derives the actual behavior of this input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
>>>>>>>>>>>>>>>>> (C) The actual behavior of this input never reaches the
>>>>>>>>>>>>>>>>> final state of this input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But Every H that IS a UTM fails to answer, and every H
>>>>>>>>>>>>>>>> that answers fails to be a UTM.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since every Px is tied to a PARTICULAR Hx, there are no
>>>>>>>>>>>>>>>> Px that have their Hx return 0 and also have a UTM
>>>>>>>>>>>>>>>> showing them to be non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, the only Px's you have show to be non-halting are
>>>>>>>>>>>>>>>> those associsted with Hx's that don't answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 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:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But, NO Hx did that for the input Hx(Px,Px).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seem to insufficiently appreciate what this infinite
>>>>>>>>>>>>>>> set comprises*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> One of the elements of this set correctly simulates some
>>>>>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>>>>>> exactly performs every chess move that deep blue
>>>>>>>>>>>>>>> performed when it defeated Kasparov.
>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_(chess_computer)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Another element of this set correctly simulates some
>>>>>>>>>>>>>>> fixed number of steps of its input and then after that
>>>>>>>>>>>>>>> translates the Lords prayer into ancient Egyptian.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If that it the case then at least one element of this set
>>>>>>>>>>>>>>> returns 0 on the basis that it correctly matched a
>>>>>>>>>>>>>>> correct infinite behavior pattern.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But the decider H isn't a "Set", but a particular program,
>>>>>>>>>>>>>
>>>>>>>>>>>>> thus one element of the of the infinite set of Hx/Px pairs.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And NO element of the set of Hx correctly decides on its own
>>>>>>>>>>>> Px that calls that particular Hx.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Every element of the Hx/Px pairs that simply returns 0
>>>>>>>>>>> correctly predicts that its correct and complete simulation
>>>>>>>>>>> of its input would never reach the final state of this input
>>>>>>>>>>> because every element of the infinite set of Hx/Px pairs that
>>>>>>>>>>> correctly and completely simulates its input never reaches
>>>>>>>>>>> the final state of this input.
>>>>>>>>>>
>>>>>>>>>> No, it doesn't because UTM(Px,Px) for those Hx that return 0
>>>>>>>>>> from Hx(Px,P) will Halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If all X are Y and you disagree then you are wrong.
>>>>>>>>
>>>>>>>> What are X's and what are Y's?
>>>>>>>>
>>>>>>>>>
>>>>>>>>> If every correct and complete simulation of the input to Hx
>>>>>>>>> never stops running and it is the job of some Hx to predict
>>>>>>>>> whether or not the correct and complete simulation of the input
>>>>>>>>> to Hx would ever stop running then even this Hx is correct:
>>>>>>>>
>>>>>>>> Right, EVERT Hx that does a correct and complete simulation of
>>>>>>>> its input NEVER gives an answer about its corresponding input.
>>>>>>>> Yes, those inputs are non-halting, but Hx fails to identify
>>>>>>>> them, and thus Hx isn't even a decider.
>>>>>>>>
>>>>>>>> The OTHER Hx's, that do abort their simulations, do NOT do a
>>>>>>>> complete simulation of their input, and for EVERY one of them,
>>>>>>>> UTM(Px,Px) for the Px built on them will Halt, so they are wrong.
>>>>>>>>
>>>>>>>> Yes, all X are Y, as in ALL your Hx's are WRONG, because they
>>>>>>>> fail to meet the requirements of a Halt Decider.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>> {
>>>>>>>>>    return 0;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, and the Px built on that Halts, so it is wrong.
>>>>>>>>
>>>>>>> This function computes the correct answer to every question where
>>>>>>> the answer is yes.
>>>>>>>
>>>>>>> bool Answer()
>>>>>>> {
>>>>>>>    return true;
>>>>>>> }
>>>>>>>
>>>>>>
>>>>>> So, since the CORRECT answer to the Hx(Px,Px) for the Px of the
>>>>>> above Hx is Halt, it isn't right.
>>>>>>
>>>>>
>>>>>
>>>>> This function computes the correct answer to every question where
>>>>> the answer is no.
>>>>>
>>>>> bool Answer_No()
>>>>> {
>>>>>    return false;
>>>>> }
>>>>
>>>> So.
>>>>>
>>>>> When the question is:
>>>>> Does the complete and correct simulation of Px by Hx ever stop
>>>>> running?
>>>>
>>>> And the answer for the Px built on that Hx is YES.
>>>>
>>>> Px(Px) calls your Hx(Px,Px) it immediately returns false and Px halts.
>>>>
>>>> What is wrong with that simulation?
>>>>
>>>> Even YOU should be able to see that.
>>>>
>>>>>
>>>>> Answer_No() provides the correct answer.
>>>>
>>>> How, since it halts?
>>> void Px(ptr x)
>>> {
>>>    int Halt_Status = Hx(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> *You forgot that you agreed that you agreed that the answer is NO*
>>> Does the complete and correct simulation of Px by Hx ever stop running?
>>>
>>>
>>
>> I never agreed that the answer was No. You are just lying again.
>>
>> I agreed that for the Hx that NEVER stops simulating, the answer is no,
>>
>
> You didn't understand the a complete simulation of an input that never
> stops running also never stops simulating?
>
>
Yes, I understand that. Why do you think a program that never STARTS
simulating does a complete simulation?