Op 06.sep..2022 om 19:56 schreef olcott:

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

It seems that you, nor your opponents, are able to convince each other.
Maybe P is not pathological enough and it helps if we look at a slightly
more pathological P:
(This is pseudo code, not C or C++. It assumes that Hx was compiled
producing position independent code.)

void Px(ptr x)
{ void * Hc = malloc (sizeof (*Hx));
memcpy (Hc, Hx, sizeof (*Hx));

int Halt_Status = Hc(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

Would your Hx return the correct halt status in a finite time?

On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
> On 9/8/2022 3:25 PM, Paul N wrote:
> > On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
> >> On 9/8/2022 8:07 AM, Paul N wrote:
> >>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>
> >>>> Does any complete and correct simulation of Px by Hx ever stop running?
> >>>
> >>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >>>
> >> *We will call this the UTM subset*
> >> We are discussing the infinite set of Hx/Px pairs.
> >
> > Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
> >
> >> An infinite subset of
> >> these do a complete and correct simulation of their input.
> >
> > If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
> >
> >> Perhaps you fail to comprehend that all of this subset would remain
> >> stuck in infinitely recursive simulation such that Px never reaches its
> >> final state and the simulation never stops, thus Hx never returns any
> >> value.
> >
> > This point is moot, there are no pairs in this subset.
> >
> >> *Of the remaining subsets*
> >> (1) One of these ignores its input and translates the Lord's prayer into
> >> ancient Egyptian.
> >>
> >> (2) Another one of these ignores its input and makes all the moves where
> >> Deep Blue beat Garry Kasparov in the famous sixth match.
> >> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>
> >> (3) An infinite subset of the *remaining subsets* ignores its input and
> >> returns each element of the set of integers, thus one of them returns 1
> >> and another returns 0, this one is called the *wild guess halt decider*
> >
> > All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
> >
> >> (4) One of these implements the algorithm of my simulating halt decider
> >> https://liarparadox.org/2022_09_07.zip
> >
> > And this one will be wrong too, see above.
> >
> >> When it is the job of the halt decider to correctly predict whether or
> >> not its correct and complete simulation of its input would halt even the
> >> *wild guess halt decider* element of subset (3) is correct:
> >
> >> int Hx(ptr x, ptr y)
> >> {
> >> return 0;
> >> }
> >
> > No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
> All male humans are humans.
>
> all correct and complete simulations of Px by Hx never halt therefore
> any damn thing that says:
> "all correct and complete simulations of Px by Hx never halt therefore"
> *IS NECESSARILY CORRECT*

Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?

We were talking about "wild guess halt deciders". I thought that this would avoid all the arguments about simulations, as it clearly doesn't do one. Instead you have dropped that line of thought and are back to arguing about simulations.

And, as I proved above, there are no Hx/Px pairs where the Hx of the pair correctly predicts whether the Px of the pair halts. None at all. So it's completely pointless you arguing, in capitals, about how such pairs behave.

On 9/9/2022 6:49 AM, Paul N wrote:
> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>> On 9/8/2022 3:25 PM, Paul N wrote:
>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>
>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>>>
>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>>>>>
>>>> *We will call this the UTM subset*
>>>> We are discussing the infinite set of Hx/Px pairs.
>>>
>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
>>>
>>>> An infinite subset of
>>>> these do a complete and correct simulation of their input.
>>>
>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
>>>
>>>> Perhaps you fail to comprehend that all of this subset would remain
>>>> stuck in infinitely recursive simulation such that Px never reaches its
>>>> final state and the simulation never stops, thus Hx never returns any
>>>> value.
>>>
>>> This point is moot, there are no pairs in this subset.
>>>
>>>> *Of the remaining subsets*
>>>> (1) One of these ignores its input and translates the Lord's prayer into
>>>> ancient Egyptian.
>>>>
>>>> (2) Another one of these ignores its input and makes all the moves where
>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>
>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
>>>> returns each element of the set of integers, thus one of them returns 1
>>>> and another returns 0, this one is called the *wild guess halt decider*
>>>
>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
>>>
>>>> (4) One of these implements the algorithm of my simulating halt decider
>>>> https://liarparadox.org/2022_09_07.zip
>>>
>>> And this one will be wrong too, see above.
>>>
>>>> When it is the job of the halt decider to correctly predict whether or
>>>> not its correct and complete simulation of its input would halt even the
>>>> *wild guess halt decider* element of subset (3) is correct:
>>>
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>> return 0;
>>>> }
>>>
>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
>> All male humans are humans.
>>
>> all correct and complete simulations of Px by Hx never halt therefore
>> any damn thing that says:
>> "all correct and complete simulations of Px by Hx never halt therefore"
>> *IS NECESSARILY CORRECT*
>
> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
So you don't understand the above point that applies to every program
that return 0?

Some of these programs are wild guess halt deciders and some of these
programs correctly match a correct infinite behavior pattern and return
0 on this basis.

--
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/9/2022 5:04 AM, Fred. Zwarts wrote:
> Op 06.sep..2022 om 19:56 schreef olcott:
>
>> 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
>>
>
> It seems that you, nor your opponents, are able to convince each other.
> Maybe P is not pathological enough and it helps if we look at a slightly
> more pathological P:
> (This is pseudo code, not C or C++. It assumes that Hx was compiled
> producing position independent code.)
>
> void Px(ptr x)
> {
>   void * Hc = malloc (sizeof (*Hx));
>   memcpy (Hc, Hx, sizeof (*Hx));
>
>   int Halt_Status = Hc(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> Would your Hx return the correct halt status in a finite time?
>

I am only considering the conventional undecidable input HP template.
The whole rest of the world has had since 1936 and hasn't figured it out
yet, thus making it more complex serves no useful purpose.

--
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/8/2022 10:19 PM, Richard Damon wrote:
>
> On 9/8/22 10:44 PM, olcott wrote:
>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>> On 9/8/22 8:59 PM, olcott wrote:
>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>
>>>>>>>> All male humans are humans.
>>>>>>>>
>>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>>> therefore any damn thing that says:
>>>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>
>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>
>>>>>>
>>>>>> That is why I proved that every element of the infinite set of
>>>>>> Hx/Px pairs such that Hx correctly and completely simulates its
>>>>>> input Px never halts. *I named this set the HxPx_UTM set*
>>>>>>
>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>
>>>>>
>>>>> But you only proved the Px's built on the Hx's that don't answer
>>>>> were non-halting.
>>>> That is the entire domain of SHD Hx.
>>>>
>>>
>>> Then it isn't a Halt Decider, as a Halt Decider must be able to take
>>> in ALL computations.
>>
>>
>> typedef void (*ptr)();
>>
>> void Px(ptr x)
>> {
>>    int Halt_Status = Hx(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int Hx(ptr x, ptr y)
>> {
>>    x(y);
>> }
>>
>> Everyone has always said that a halt decider must predict the behavior
>> of the direct execution of the input thus Hx must base its halt status
>> decision on the above version of itself.
>>
>
> No, it must decider on its own version of itself. That is the DEFINITION.
>

If the criteria for a simulating halt decider (SHD) was:
"Does your correctly simulated input ever stop running ?"
the SDH would always have to return 1 indicating that its input stops
running on its own or its input stops running because the SHD correctly
matched a correct infinite behavior pattern and aborted the simulation
of its input.

This requires the halt status criteria to adopt the Linz convention that
a sequence of instructions (AKA moves) can only be construed as halting
when it reaches its own final state. This means that every correctly
simulated sequence that cannot possibly reach its final state specifies
a non-halting sequence.

For the entire infinite set of Hx/Px pairs where Hx correctly simulates
its input Px never reaches its final state. If there exists no encoding
of Hx such that its correct simulation of input ever reaches the final
state of Px then every Hx that reports this is necessarily correct.

Are all male humans human? Yes.

Does any encoding of Hx that correctly simulates Px ever reach the final
state of Px? No.

--
Copyright 2022 Pete Olcott

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

On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
> On 9/9/2022 6:49 AM, Paul N wrote:
> > On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
> >> On 9/8/2022 3:25 PM, Paul N wrote:
> >>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
> >>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>
> >>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
> >>>>>
> >>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >>>>>
> >>>> *We will call this the UTM subset*
> >>>> We are discussing the infinite set of Hx/Px pairs.
> >>>
> >>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
> >>>
> >>>> An infinite subset of
> >>>> these do a complete and correct simulation of their input.
> >>>
> >>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
> >>>
> >>>> Perhaps you fail to comprehend that all of this subset would remain
> >>>> stuck in infinitely recursive simulation such that Px never reaches its
> >>>> final state and the simulation never stops, thus Hx never returns any
> >>>> value.
> >>>
> >>> This point is moot, there are no pairs in this subset.
> >>>
> >>>> *Of the remaining subsets*
> >>>> (1) One of these ignores its input and translates the Lord's prayer into
> >>>> ancient Egyptian.
> >>>>
> >>>> (2) Another one of these ignores its input and makes all the moves where
> >>>> Deep Blue beat Garry Kasparov in the famous sixth match.
> >>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>
> >>>> (3) An infinite subset of the *remaining subsets* ignores its input and
> >>>> returns each element of the set of integers, thus one of them returns 1
> >>>> and another returns 0, this one is called the *wild guess halt decider*
> >>>
> >>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
> >>>
> >>>> (4) One of these implements the algorithm of my simulating halt decider
> >>>> https://liarparadox.org/2022_09_07.zip
> >>>
> >>> And this one will be wrong too, see above.
> >>>
> >>>> When it is the job of the halt decider to correctly predict whether or
> >>>> not its correct and complete simulation of its input would halt even the
> >>>> *wild guess halt decider* element of subset (3) is correct:
> >>>
> >>>> int Hx(ptr x, ptr y)
> >>>> {
> >>>> return 0;
> >>>> }
> >>>
> >>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
> >> All male humans are humans.
> >>
> >> all correct and complete simulations of Px by Hx never halt therefore
> >> any damn thing that says:
> >> "all correct and complete simulations of Px by Hx never halt therefore"
> >> *IS NECESSARILY CORRECT*
> >
> > Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?

> So you don't understand the above point that applies to every program
> that return 0?

If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.

> Some of these programs are wild guess halt deciders and some of these
> programs correctly match a correct infinite behavior pattern and return
> 0 on this basis.

If Hx(Px, Px) is zero, then Px halts. This is totally clear from the definition of Px. So NO program can both correctly match a correct infinite behaviour pattern and return 0 to show this.

I know you like to think that your SHD can do this, but it can't, as I have shown you umpteen times.

On 9/9/2022 12:49 PM, Paul N wrote:
> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
>> On 9/9/2022 6:49 AM, Paul N wrote:
>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>
>>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>>>>>
>>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>>>>>>>
>>>>>> *We will call this the UTM subset*
>>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>>
>>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
>>>>>
>>>>>> An infinite subset of
>>>>>> these do a complete and correct simulation of their input.
>>>>>
>>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
>>>>>
>>>>>> Perhaps you fail to comprehend that all of this subset would remain
>>>>>> stuck in infinitely recursive simulation such that Px never reaches its
>>>>>> final state and the simulation never stops, thus Hx never returns any
>>>>>> value.
>>>>>
>>>>> This point is moot, there are no pairs in this subset.
>>>>>
>>>>>> *Of the remaining subsets*
>>>>>> (1) One of these ignores its input and translates the Lord's prayer into
>>>>>> ancient Egyptian.
>>>>>>
>>>>>> (2) Another one of these ignores its input and makes all the moves where
>>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>
>>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
>>>>>> returns each element of the set of integers, thus one of them returns 1
>>>>>> and another returns 0, this one is called the *wild guess halt decider*
>>>>>
>>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
>>>>>
>>>>>> (4) One of these implements the algorithm of my simulating halt decider
>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>
>>>>> And this one will be wrong too, see above.
>>>>>
>>>>>> When it is the job of the halt decider to correctly predict whether or
>>>>>> not its correct and complete simulation of its input would halt even the
>>>>>> *wild guess halt decider* element of subset (3) is correct:
>>>>>
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>> return 0;
>>>>>> }
>>>>>
>>>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
>>>> All male humans are humans.
>>>>
>>>> all correct and complete simulations of Px by Hx never halt therefore
>>>> any damn thing that says:
>>>> "all correct and complete simulations of Px by Hx never halt therefore"
>>>> *IS NECESSARILY CORRECT*
>>>
>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
>
>> So you don't understand the above point that applies to every program
>> that return 0?
>
> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
>

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));
}

The code for Px is fully specified. The code for Hx is the infinite set
of every C function that takes a pair of ptr arguments. These arguments
can be ignored, summed together, multiplied together, simulated, or
anything else. One element of Hx ignores its arguments, translates the
Lord's prayer into ancient Egyptian and returns 56.

A subset of these C functions perform a correct partial or complete
simulation of their input. In none of the elements of this set does Px
ever reach its final state.

A subset of the original set return a value of 0, which turns out to be
the correct answer to the question:

Does there exist any element of the infinite set of Hx/Px pairs such
that Px correctly simulated by Hx reaches the final state of Px?

One element of the prior set correctly matches a correct infinite
behavior pattern, aborts the simulation of its input on the basis and
returns 0.

>> Some of these programs are wild guess halt deciders and some of these
>> programs correctly match a correct infinite behavior pattern and return
>> 0 on this basis.
>
> If Hx(Px, Px) is zero, then Px halts. This is totally clear from the definition of Px. So NO program can both correctly match a correct infinite behaviour pattern and return 0 to show this.
>
> I know you like to think that your SHD can do this, but it can't, as I have shown you umpteen times.

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

On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
> On 9/9/2022 12:49 PM, Paul N wrote:
> > On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
> >> On 9/9/2022 6:49 AM, Paul N wrote:
> >>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
> >>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
> >>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>
> >>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
> >>>>>>>
> >>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >>>>>>>
> >>>>>> *We will call this the UTM subset*
> >>>>>> We are discussing the infinite set of Hx/Px pairs.
> >>>>>
> >>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
> >>>>>
> >>>>>> An infinite subset of
> >>>>>> these do a complete and correct simulation of their input.
> >>>>>
> >>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
> >>>>>
> >>>>>> Perhaps you fail to comprehend that all of this subset would remain
> >>>>>> stuck in infinitely recursive simulation such that Px never reaches its
> >>>>>> final state and the simulation never stops, thus Hx never returns any
> >>>>>> value.
> >>>>>
> >>>>> This point is moot, there are no pairs in this subset.
> >>>>>
> >>>>>> *Of the remaining subsets*
> >>>>>> (1) One of these ignores its input and translates the Lord's prayer into
> >>>>>> ancient Egyptian.
> >>>>>>
> >>>>>> (2) Another one of these ignores its input and makes all the moves where
> >>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
> >>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>
> >>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
> >>>>>> returns each element of the set of integers, thus one of them returns 1
> >>>>>> and another returns 0, this one is called the *wild guess halt decider*
> >>>>>
> >>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
> >>>>>
> >>>>>> (4) One of these implements the algorithm of my simulating halt decider
> >>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>
> >>>>> And this one will be wrong too, see above.
> >>>>>
> >>>>>> When it is the job of the halt decider to correctly predict whether or
> >>>>>> not its correct and complete simulation of its input would halt even the
> >>>>>> *wild guess halt decider* element of subset (3) is correct:
> >>>>>
> >>>>>> int Hx(ptr x, ptr y)
> >>>>>> {
> >>>>>> return 0;
> >>>>>> }
> >>>>>
> >>>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
> >>>> All male humans are humans.
> >>>>
> >>>> all correct and complete simulations of Px by Hx never halt therefore
> >>>> any damn thing that says:
> >>>> "all correct and complete simulations of Px by Hx never halt therefore"
> >>>> *IS NECESSARILY CORRECT*
> >>>
> >>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
> >
> >> So you don't understand the above point that applies to every program
> >> that return 0?
> >
> > If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
> >
>
> 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));
> }
> The code for Px is fully specified. The code for Hx is the infinite set
> of every C function that takes a pair of ptr arguments. These arguments
> can be ignored, summed together, multiplied together, simulated, or
> anything else. One element of Hx ignores its arguments, translates the
> Lord's prayer into ancient Egyptian and returns 56.
>
> A subset of these C functions perform a correct partial or complete
> simulation of their input. In none of the elements of this set does Px
> ever reach its final state.
>
> A subset of the original set return a value of 0, which turns out to be
> the correct answer to the question:
>
> Does there exist any element of the infinite set of Hx/Px pairs such
> that Px correctly simulated by Hx reaches the final state of Px?
>
> One element of the prior set correctly matches a correct infinite
> behavior pattern, aborts the simulation of its input on the basis and
> returns 0.

You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:

void Px(ptr x)
{
int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
> HERE: goto HERE; // ... and so this line is not executed ...
> return; // ... and we get to here.
> }

So Px halts. There is no infinite behaviour pattern.

> >> Some of these programs are wild guess halt deciders and some of these
> >> programs correctly match a correct infinite behavior pattern and return
> >> 0 on this basis.
> >
> > If Hx(Px, Px) is zero, then Px halts. This is totally clear from the definition of Px. So NO program can both correctly match a correct infinite behaviour pattern and return 0 to show this.
> >
> > I know you like to think that your SHD can do this, but it can't, as I have shown you umpteen times.

On 9/9/2022 1:36 PM, Paul N wrote:
> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
>> On 9/9/2022 12:49 PM, Paul N wrote:
>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>>>>>>>
>>>>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>>>>>>>>>
>>>>>>>> *We will call this the UTM subset*
>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>>>>
>>>>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
>>>>>>>
>>>>>>>> An infinite subset of
>>>>>>>> these do a complete and correct simulation of their input.
>>>>>>>
>>>>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
>>>>>>>
>>>>>>>> Perhaps you fail to comprehend that all of this subset would remain
>>>>>>>> stuck in infinitely recursive simulation such that Px never reaches its
>>>>>>>> final state and the simulation never stops, thus Hx never returns any
>>>>>>>> value.
>>>>>>>
>>>>>>> This point is moot, there are no pairs in this subset.
>>>>>>>
>>>>>>>> *Of the remaining subsets*
>>>>>>>> (1) One of these ignores its input and translates the Lord's prayer into
>>>>>>>> ancient Egyptian.
>>>>>>>>
>>>>>>>> (2) Another one of these ignores its input and makes all the moves where
>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>
>>>>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
>>>>>>>> returns each element of the set of integers, thus one of them returns 1
>>>>>>>> and another returns 0, this one is called the *wild guess halt decider*
>>>>>>>
>>>>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
>>>>>>>
>>>>>>>> (4) One of these implements the algorithm of my simulating halt decider
>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>
>>>>>>> And this one will be wrong too, see above.
>>>>>>>
>>>>>>>> When it is the job of the halt decider to correctly predict whether or
>>>>>>>> not its correct and complete simulation of its input would halt even the
>>>>>>>> *wild guess halt decider* element of subset (3) is correct:
>>>>>>>
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>> return 0;
>>>>>>>> }
>>>>>>>
>>>>>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
>>>>>> All male humans are humans.
>>>>>>
>>>>>> all correct and complete simulations of Px by Hx never halt therefore
>>>>>> any damn thing that says:
>>>>>> "all correct and complete simulations of Px by Hx never halt therefore"
>>>>>> *IS NECESSARILY CORRECT*
>>>>>
>>>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
>>>
>>>> So you don't understand the above point that applies to every program
>>>> that return 0?
>>>
>>> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
>>>
>>
>> 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));
>> }
>> The code for Px is fully specified. The code for Hx is the infinite set
>> of every C function that takes a pair of ptr arguments. These arguments
>> can be ignored, summed together, multiplied together, simulated, or
>> anything else. One element of Hx ignores its arguments, translates the
>> Lord's prayer into ancient Egyptian and returns 56.
>>
>> A subset of these C functions perform a correct partial or complete
>> simulation of their input. In none of the elements of this set does Px
>> ever reach its final state.
>>
>> A subset of the original set return a value of 0, which turns out to be
>> the correct answer to the question:
>>
>> Does there exist any element of the infinite set of Hx/Px pairs such
>> that Px correctly simulated by Hx reaches the final state of Px?
>>
>> One element of the prior set correctly matches a correct infinite
>> behavior pattern, aborts the simulation of its input on the basis and
>> returns 0.
>
> You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:
>
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
>> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
>> HERE: goto HERE; // ... and so this line is not executed ...
>> return; // ... and we get to here.
>> }
>
> So Px halts. There is no infinite behaviour pattern.
>
It is pretty ridiculous that you say that Px halts for every Hx of the
infinite set of Hx.

On 9/9/2022 1:36 PM, Paul N wrote:
> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
>> On 9/9/2022 12:49 PM, Paul N wrote:
>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>>>>>>>
>>>>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>>>>>>>>>
>>>>>>>> *We will call this the UTM subset*
>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>>>>
>>>>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
>>>>>>>
>>>>>>>> An infinite subset of
>>>>>>>> these do a complete and correct simulation of their input.
>>>>>>>
>>>>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
>>>>>>>
>>>>>>>> Perhaps you fail to comprehend that all of this subset would remain
>>>>>>>> stuck in infinitely recursive simulation such that Px never reaches its
>>>>>>>> final state and the simulation never stops, thus Hx never returns any
>>>>>>>> value.
>>>>>>>
>>>>>>> This point is moot, there are no pairs in this subset.
>>>>>>>
>>>>>>>> *Of the remaining subsets*
>>>>>>>> (1) One of these ignores its input and translates the Lord's prayer into
>>>>>>>> ancient Egyptian.
>>>>>>>>
>>>>>>>> (2) Another one of these ignores its input and makes all the moves where
>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>
>>>>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
>>>>>>>> returns each element of the set of integers, thus one of them returns 1
>>>>>>>> and another returns 0, this one is called the *wild guess halt decider*
>>>>>>>
>>>>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
>>>>>>>
>>>>>>>> (4) One of these implements the algorithm of my simulating halt decider
>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>
>>>>>>> And this one will be wrong too, see above.
>>>>>>>
>>>>>>>> When it is the job of the halt decider to correctly predict whether or
>>>>>>>> not its correct and complete simulation of its input would halt even the
>>>>>>>> *wild guess halt decider* element of subset (3) is correct:
>>>>>>>
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>> return 0;
>>>>>>>> }
>>>>>>>
>>>>>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
>>>>>> All male humans are humans.
>>>>>>
>>>>>> all correct and complete simulations of Px by Hx never halt therefore
>>>>>> any damn thing that says:
>>>>>> "all correct and complete simulations of Px by Hx never halt therefore"
>>>>>> *IS NECESSARILY CORRECT*
>>>>>
>>>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
>>>
>>>> So you don't understand the above point that applies to every program
>>>> that return 0?
>>>
>>> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
>>>
>>
>> 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));
>> }
>> The code for Px is fully specified. The code for Hx is the infinite set
>> of every C function that takes a pair of ptr arguments. These arguments
>> can be ignored, summed together, multiplied together, simulated, or
>> anything else. One element of Hx ignores its arguments, translates the
>> Lord's prayer into ancient Egyptian and returns 56.
>>
>> A subset of these C functions perform a correct partial or complete
>> simulation of their input. In none of the elements of this set does Px
>> ever reach its final state.
>>
>> A subset of the original set return a value of 0, which turns out to be
>> the correct answer to the question:
>>
>> Does there exist any element of the infinite set of Hx/Px pairs such
>> that Px correctly simulated by Hx reaches the final state of Px?
>>
>> One element of the prior set correctly matches a correct infinite
>> behavior pattern, aborts the simulation of its input on the basis and
>> returns 0.
>
> You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:
>
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
>> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
>> HERE: goto HERE; // ... and so this line is not executed ...
>> return; // ... and we get to here.
>> }
>
> So Px halts. There is no infinite behaviour pattern.

On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott wrote:
> On 9/9/2022 1:36 PM, Paul N wrote:
> > On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
> >> On 9/9/2022 12:49 PM, Paul N wrote:
> >>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
> >>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
> >>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
> >>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
> >>>>>>>>>
> >>>>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >>>>>>>>>
> >>>>>>>> *We will call this the UTM subset*
> >>>>>>>> We are discussing the infinite set of Hx/Px pairs.
> >>>>>>>
> >>>>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
> >>>>>>>
> >>>>>>>> An infinite subset of
> >>>>>>>> these do a complete and correct simulation of their input.
> >>>>>>>
> >>>>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
> >>>>>>>
> >>>>>>>> Perhaps you fail to comprehend that all of this subset would remain
> >>>>>>>> stuck in infinitely recursive simulation such that Px never reaches its
> >>>>>>>> final state and the simulation never stops, thus Hx never returns any
> >>>>>>>> value.
> >>>>>>>
> >>>>>>> This point is moot, there are no pairs in this subset.
> >>>>>>>
> >>>>>>>> *Of the remaining subsets*
> >>>>>>>> (1) One of these ignores its input and translates the Lord's prayer into
> >>>>>>>> ancient Egyptian.
> >>>>>>>>
> >>>>>>>> (2) Another one of these ignores its input and makes all the moves where
> >>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
> >>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>
> >>>>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
> >>>>>>>> returns each element of the set of integers, thus one of them returns 1
> >>>>>>>> and another returns 0, this one is called the *wild guess halt decider*
> >>>>>>>
> >>>>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
> >>>>>>>
> >>>>>>>> (4) One of these implements the algorithm of my simulating halt decider
> >>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>
> >>>>>>> And this one will be wrong too, see above.
> >>>>>>>
> >>>>>>>> When it is the job of the halt decider to correctly predict whether or
> >>>>>>>> not its correct and complete simulation of its input would halt even the
> >>>>>>>> *wild guess halt decider* element of subset (3) is correct:
> >>>>>>>
> >>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>> {
> >>>>>>>> return 0;
> >>>>>>>> }
> >>>>>>>
> >>>>>>> No, this is wrong, it predicts Px will not halt, but Px does halt.. Try running it!
> >>>>>> All male humans are humans.
> >>>>>>
> >>>>>> all correct and complete simulations of Px by Hx never halt therefore
> >>>>>> any damn thing that says:
> >>>>>> "all correct and complete simulations of Px by Hx never halt therefore"
> >>>>>> *IS NECESSARILY CORRECT*
> >>>>>
> >>>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
> >>>
> >>>> So you don't understand the above point that applies to every program
> >>>> that return 0?
> >>>
> >>> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
> >>>
> >>
> >> 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));
> >> }
> >> The code for Px is fully specified. The code for Hx is the infinite set
> >> of every C function that takes a pair of ptr arguments. These arguments
> >> can be ignored, summed together, multiplied together, simulated, or
> >> anything else. One element of Hx ignores its arguments, translates the
> >> Lord's prayer into ancient Egyptian and returns 56.
> >>
> >> A subset of these C functions perform a correct partial or complete
> >> simulation of their input. In none of the elements of this set does Px
> >> ever reach its final state.
> >>
> >> A subset of the original set return a value of 0, which turns out to be
> >> the correct answer to the question:
> >>
> >> Does there exist any element of the infinite set of Hx/Px pairs such
> >> that Px correctly simulated by Hx reaches the final state of Px?
> >>
> >> One element of the prior set correctly matches a correct infinite
> >> behavior pattern, aborts the simulation of its input on the basis and
> >> returns 0.
> >
> > You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:
> >
> > void Px(ptr x)
> > {
> > int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
> >> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
> >> HERE: goto HERE; // ... and so this line is not executed ...
> >> return; // ... and we get to here.
> >> }
> >
> > So Px halts. There is no infinite behaviour pattern.
> I have to update my last reply because I realized that it was not
> accurate. I really only want an honest dialogue and I incorrectly said
> that you made a mistake that you did not make.

On 9/9/2022 2:31 PM, Paul N wrote:
> On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott wrote:
>> On 9/9/2022 1:36 PM, Paul N wrote:
>>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
>>>> On 9/9/2022 12:49 PM, Paul N wrote:
>>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
>>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
>>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
>>>>>>>>>>>
>>>>>>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
>>>>>>>>>>>
>>>>>>>>>> *We will call this the UTM subset*
>>>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>>>>>>
>>>>>>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
>>>>>>>>>
>>>>>>>>>> An infinite subset of
>>>>>>>>>> these do a complete and correct simulation of their input.
>>>>>>>>>
>>>>>>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
>>>>>>>>>
>>>>>>>>>> Perhaps you fail to comprehend that all of this subset would remain
>>>>>>>>>> stuck in infinitely recursive simulation such that Px never reaches its
>>>>>>>>>> final state and the simulation never stops, thus Hx never returns any
>>>>>>>>>> value.
>>>>>>>>>
>>>>>>>>> This point is moot, there are no pairs in this subset.
>>>>>>>>>
>>>>>>>>>> *Of the remaining subsets*
>>>>>>>>>> (1) One of these ignores its input and translates the Lord's prayer into
>>>>>>>>>> ancient Egyptian.
>>>>>>>>>>
>>>>>>>>>> (2) Another one of these ignores its input and makes all the moves where
>>>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
>>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>>>>>>
>>>>>>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
>>>>>>>>>> returns each element of the set of integers, thus one of them returns 1
>>>>>>>>>> and another returns 0, this one is called the *wild guess halt decider*
>>>>>>>>>
>>>>>>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
>>>>>>>>>
>>>>>>>>>> (4) One of these implements the algorithm of my simulating halt decider
>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>
>>>>>>>>> And this one will be wrong too, see above.
>>>>>>>>>
>>>>>>>>>> When it is the job of the halt decider to correctly predict whether or
>>>>>>>>>> not its correct and complete simulation of its input would halt even the
>>>>>>>>>> *wild guess halt decider* element of subset (3) is correct:
>>>>>>>>>
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>> return 0;
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
>>>>>>>> All male humans are humans.
>>>>>>>>
>>>>>>>> all correct and complete simulations of Px by Hx never halt therefore
>>>>>>>> any damn thing that says:
>>>>>>>> "all correct and complete simulations of Px by Hx never halt therefore"
>>>>>>>> *IS NECESSARILY CORRECT*
>>>>>>>
>>>>>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
>>>>>
>>>>>> So you don't understand the above point that applies to every program
>>>>>> that return 0?
>>>>>
>>>>> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
>>>>>
>>>>
>>>> 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));
>>>> }
>>>> The code for Px is fully specified. The code for Hx is the infinite set
>>>> of every C function that takes a pair of ptr arguments. These arguments
>>>> can be ignored, summed together, multiplied together, simulated, or
>>>> anything else. One element of Hx ignores its arguments, translates the
>>>> Lord's prayer into ancient Egyptian and returns 56.
>>>>
>>>> A subset of these C functions perform a correct partial or complete
>>>> simulation of their input. In none of the elements of this set does Px
>>>> ever reach its final state.
>>>>
>>>> A subset of the original set return a value of 0, which turns out to be
>>>> the correct answer to the question:
>>>>
>>>> Does there exist any element of the infinite set of Hx/Px pairs such
>>>> that Px correctly simulated by Hx reaches the final state of Px?
>>>>
>>>> One element of the prior set correctly matches a correct infinite
>>>> behavior pattern, aborts the simulation of its input on the basis and
>>>> returns 0.
>>>
>>> You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:
>>>
>>> void Px(ptr x)
>>> {
>>> int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
>>>> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
>>>> HERE: goto HERE; // ... and so this line is not executed ...
>>>> return; // ... and we get to here.
>>>> }
>>>
>>> So Px halts. There is no infinite behaviour pattern.
>> I have to update my last reply because I realized that it was not
>> accurate. I really only want an honest dialogue and I incorrectly said
>> that you made a mistake that you did not make.
>
> Thank you for this. Yes, I was saying that if Hx(Px, Px) returns 0 then Px halts.
>
>> A simulating halt decider (SHD) only reports on the behavior of what its
>> complete and correct simulation of its input would be, it never reports
>> on the actual behavior of what its partial simulation is.
>>
>> If a SHD reported on whether or not its input stopped running then in
>> those cases where the simulated input stopped on its own and those cases
>> where the simulation was aborted the simulated input stopped running.
>> This derives a correct halt decider with no discernment every input is
>> reported to stop running.
>>
>> To allow a SHD to have discernment it answers a different question:
>> Does any correct simulation of its input reach the final state of this
>> input?
>
> The snag is that Hx must always give the wrong answer for Px,

On 9/9/22 11:02 AM, olcott wrote:
> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>
>> On 9/8/22 10:44 PM, olcott wrote:
>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>
>>>>>>>>> All male humans are humans.
>>>>>>>>>
>>>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>>>> therefore any damn thing that says:
>>>>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>
>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>
>>>>>>>
>>>>>>> That is why I proved that every element of the infinite set of
>>>>>>> Hx/Px pairs such that Hx correctly and completely simulates its
>>>>>>> input Px never halts. *I named this set the HxPx_UTM set*
>>>>>>>
>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>
>>>>>>
>>>>>> But you only proved the Px's built on the Hx's that don't answer
>>>>>> were non-halting.
>>>>> That is the entire domain of SHD Hx.
>>>>>
>>>>
>>>> Then it isn't a Halt Decider, as a Halt Decider must be able to take
>>>> in ALL computations.
>>>
>>>
>>> typedef void (*ptr)();
>>>
>>> void Px(ptr x)
>>> {
>>>    int Halt_Status = Hx(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int Hx(ptr x, ptr y)
>>> {
>>>    x(y);
>>> }
>>>
>>> Everyone has always said that a halt decider must predict the
>>> behavior of the direct execution of the input thus Hx must base its
>>> halt status decision on the above version of itself.
>>>
>>
>> No, it must decider on its own version of itself. That is the DEFINITION.
>>
>
> If the criteria for a simulating halt decider (SHD) was:
> "Does your correctly simulated input ever stop running ?"
> the SDH would always have to return 1 indicating that its input stops
> running on its own or its input stops running because the SHD correctly
> matched a correct infinite behavior pattern and aborted the simulation
> of its input.

You keep on using the wrong definitoion, I think because you just don't
know what the words mean.

>
> This requires the halt status criteria to adopt the Linz convention that
> a sequence of instructions (AKA moves) can only be construed as halting
> when it reaches its own final state. This means that every correctly
> simulated sequence that cannot possibly reach its final state specifies
> a non-halting sequence.

Right, and it is only non-halting when the sequence of steps specified
by that input would NEVER halt if run/simulated for an unbounded number
of step.

A machine that is artificially stop, doesn't define if it would have
halted or not.

Thus, your definition, adding the words "By H", are incorrect.

A simulation that stop before reaching a final state, by itself, does
not prove anything about the Halting behavior of that input.

>
> For the entire infinite set of Hx/Px pairs where Hx correctly simulates
> its input Px never reaches its final state. If there exists no encoding
> of Hx such that its correct simulation of input ever reaches the final
> state of Px then every Hx that reports this is necessarily correct.

Doesn' matter. The ones of that set that DO a complete simulation, do
show that the Px built from them is non-halting, but never give that answer.

The one of that set that stop there simulation have abandoned their
ability to show if the input is halting or non-halting, and the actual
complete and correct simulation of those input shows that the WILL Halt
when completely simulated, thus Hx was WRONG.

>
> Are all male humans human? Yes.

But not all Hx show their input is non-halting, so you are just serving
you favorite dish, Herring with Red sauce.

>
> Does any encoding of Hx that correctly simulates Px ever reach the final
> state of Px? No.
>

No, but they don't give the correct answer either.

The ones that DO give an answer, give the wrong one, because the
complete simultion of their input (which they don't do) is shown to Halt.

You are just shown to be a blooming idiot that lies through his teeth
and is totally ignorant of what you talk about.

You illogical logic shows you don't understand what logic is either.

FAIL.

On 9/9/22 10:19 AM, olcott wrote:
> On 9/9/2022 6:49 AM, Paul N wrote:
>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
>>> On 9/8/2022 3:25 PM, Paul N wrote:
>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>
>>>>>>> Does any complete and correct simulation of Px by Hx ever stop
>>>>>>> running?
>>>>>>
>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx
>>>>>> returns non-zero then Px does not halt. So Hx can never do a
>>>>>> complete and correct simulation of Px and return the right answer.
>>>>>>
>>>>> *We will call this the UTM subset*
>>>>> We are discussing the infinite set of Hx/Px pairs.
>>>>
>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of
>>>> the pair calls the Hx of the pair as in the code above, but we're
>>>> not putting any restrictions on what Hx does?
>>>>
>>>>> An infinite subset of
>>>>> these do a complete and correct simulation of their input.
>>>>
>>>> If by this you mean that the Hx of the pair correctly predicts
>>>> whether the Px of the pair halts, then no, they ALL get it wrong, as
>>>> shown above.
>>>>
>>>>> Perhaps you fail to comprehend that all of this subset would remain
>>>>> stuck in infinitely recursive simulation such that Px never reaches
>>>>> its
>>>>> final state and the simulation never stops, thus Hx never returns any
>>>>> value.
>>>>
>>>> This point is moot, there are no pairs in this subset.
>>>>
>>>>> *Of the remaining subsets*
>>>>> (1) One of these ignores its input and translates the Lord's prayer
>>>>> into
>>>>> ancient Egyptian.
>>>>>
>>>>> (2) Another one of these ignores its input and makes all the moves
>>>>> where
>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
>>>>>
>>>>> (3) An infinite subset of the *remaining subsets* ignores its input
>>>>> and
>>>>> returns each element of the set of integers, thus one of them
>>>>> returns 1
>>>>> and another returns 0, this one is called the *wild guess halt
>>>>> decider*
>>>>
>>>> All of the wild guess deciders will be wrong. The one always
>>>> guessing 0 will always be wrong for Px, its Px will halt. The one
>>>> always guessing 1 will always be wrong for Px, its Px will not halt.
>>>> Follow the code of Px if you don't believe me.
>>>>
>>>>> (4) One of these implements the algorithm of my simulating halt
>>>>> decider
>>>>> https://liarparadox.org/2022_09_07.zip
>>>>
>>>> And this one will be wrong too, see above.
>>>>
>>>>> When it is the job of the halt decider to correctly predict whether or
>>>>> not its correct and complete simulation of its input would halt
>>>>> even the
>>>>> *wild guess halt decider* element of subset (3) is correct:
>>>>
>>>>> int Hx(ptr x, ptr y)
>>>>> {
>>>>> return 0;
>>>>> }
>>>>
>>>> No, this is wrong, it predicts Px will not halt, but Px does halt.
>>>> Try running it!
>>> All male humans are humans.
>>>
>>> all correct and complete simulations of Px by Hx never halt therefore
>>> any damn thing that says:
>>> "all correct and complete simulations of Px by Hx never halt therefore"
>>> *IS NECESSARILY CORRECT*
>>
>> Firstly, I see that you have ignored almost all of what I wrote and
>> are headed off in a different direction. I wonder why?
> So you don't understand the above point that applies to every program
> that return 0?
>
> Some of these programs are wild guess halt deciders and some of these
> programs correctly match a correct infinite behavior pattern and return
> 0 on this basis.
>

And ALL are wrong about the P built from them, since it Halts.

On 9/9/22 10:22 AM, olcott wrote:
> On 9/9/2022 5:04 AM, Fred. Zwarts wrote:
>> Op 06.sep..2022 om 19:56 schreef olcott:
>>
>>> 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
>>>
>>>
>>
>> It seems that you, nor your opponents, are able to convince each
>> other. Maybe P is not pathological enough and it helps if we look at a
>> slightly more pathological P:
>> (This is pseudo code, not C or C++. It assumes that Hx was compiled
>> producing position independent code.)
>>
>> void Px(ptr x)
>> {
>>    void * Hc = malloc (sizeof (*Hx));
>>    memcpy (Hc, Hx, sizeof (*Hx));
>>
>>    int Halt_Status = Hc(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> Would your Hx return the correct halt status in a finite time?
>>
>
> I am only considering the conventional undecidable input HP template.
> The whole rest of the world has had since 1936 and hasn't figured it out
> yet, thus making it more complex serves no useful purpose.
>

And you still haven't come up with a program that gets that one program
right.

So you have FAILED, and wasted your life.

On 9/9/2022 6:03 PM, Richard Damon wrote:
>
> On 9/9/22 11:02 AM, olcott wrote:
>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>
>>> On 9/8/22 10:44 PM, olcott wrote:
>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>> All male humans are humans.
>>>>>>>>>>
>>>>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>>>>> therefore any damn thing that says:
>>>>>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>
>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That is why I proved that every element of the infinite set of
>>>>>>>> Hx/Px pairs such that Hx correctly and completely simulates its
>>>>>>>> input Px never halts. *I named this set the HxPx_UTM set*
>>>>>>>>
>>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>>
>>>>>>>
>>>>>>> But you only proved the Px's built on the Hx's that don't answer
>>>>>>> were non-halting.
>>>>>> That is the entire domain of SHD Hx.
>>>>>>
>>>>>
>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able to
>>>>> take in ALL computations.
>>>>
>>>>
>>>> typedef void (*ptr)();
>>>>
>>>> void Px(ptr x)
>>>> {
>>>>    int Halt_Status = Hx(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return;
>>>> }
>>>>
>>>> int Hx(ptr x, ptr y)
>>>> {
>>>>    x(y);
>>>> }
>>>>
>>>> Everyone has always said that a halt decider must predict the
>>>> behavior of the direct execution of the input thus Hx must base its
>>>> halt status decision on the above version of itself.
>>>>
>>>
>>> No, it must decider on its own version of itself. That is the
>>> DEFINITION.
>>>
>>
>> If the criteria for a simulating halt decider (SHD) was:
>> "Does your correctly simulated input ever stop running ?"
>> the SDH would always have to return 1 indicating that its input stops
>> running on its own or its input stops running because the SHD
>> correctly matched a correct infinite behavior pattern and aborted the
>> simulation of its input.
>
> You keep on using the wrong definitoion, I think because you just don't
> know what the words mean.
>
>>
>> This requires the halt status criteria to adopt the Linz convention
>> that a sequence of instructions (AKA moves) can only be construed as
>> halting when it reaches its own final state. This means that every
>> correctly simulated sequence that cannot possibly reach its final
>> state specifies a non-halting sequence.
>
> Right, and it is only non-halting when the sequence of steps specified
> by that input would NEVER halt if run/simulated for an unbounded number
> of step.
>
> A machine that is artificially stop, doesn't define if it would have
> halted or not.
>
> Thus, your definition, adding the words  "By H", are incorrect.
>
> A simulation that stop before reaching a final state, by itself, does
> not prove anything about the Halting behavior of that input.

We have been through this too many times.
There is no sense continuing.

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

--
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/9/22 7:17 PM, olcott wrote:
> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>
>> On 9/9/22 11:02 AM, olcott wrote:
>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>
>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>
>>>>>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>>>>>> therefore any damn thing that says:
>>>>>>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>>
>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That is why I proved that every element of the infinite set of
>>>>>>>>> Hx/Px pairs such that Hx correctly and completely simulates its
>>>>>>>>> input Px never halts. *I named this set the HxPx_UTM set*
>>>>>>>>>
>>>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But you only proved the Px's built on the Hx's that don't answer
>>>>>>>> were non-halting.
>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>
>>>>>>
>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able to
>>>>>> take in ALL computations.
>>>>>
>>>>>
>>>>> typedef void (*ptr)();
>>>>>
>>>>> void Px(ptr x)
>>>>> {
>>>>>    int Halt_Status = Hx(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return;
>>>>> }
>>>>>
>>>>> int Hx(ptr x, ptr y)
>>>>> {
>>>>>    x(y);
>>>>> }
>>>>>
>>>>> Everyone has always said that a halt decider must predict the
>>>>> behavior of the direct execution of the input thus Hx must base its
>>>>> halt status decision on the above version of itself.
>>>>>
>>>>
>>>> No, it must decider on its own version of itself. That is the
>>>> DEFINITION.
>>>>
>>>
>>> If the criteria for a simulating halt decider (SHD) was:
>>> "Does your correctly simulated input ever stop running ?"
>>> the SDH would always have to return 1 indicating that its input stops
>>> running on its own or its input stops running because the SHD
>>> correctly matched a correct infinite behavior pattern and aborted the
>>> simulation of its input.
>>
>> You keep on using the wrong definitoion, I think because you just
>> don't know what the words mean.
>>
>>>
>>> This requires the halt status criteria to adopt the Linz convention
>>> that a sequence of instructions (AKA moves) can only be construed as
>>> halting when it reaches its own final state. This means that every
>>> correctly simulated sequence that cannot possibly reach its final
>>> state specifies a non-halting sequence.
>>
>> Right, and it is only non-halting when the sequence of steps specified
>> by that input would NEVER halt if run/simulated for an unbounded
>> number of step.
>>
>> A machine that is artificially stop, doesn't define if it would have
>> halted or not.
>>
>> Thus, your definition, adding the words  "By H", are incorrect.
>>
>> A simulation that stop before reaching a final state, by itself, does
>> not prove anything about the Halting behavior of that input.
>
> We have been through this too many times.
> There is no sense continuing.
>
> H0: Begin Simulation   Execution Trace Stored at:211fac
> [00001102][00211f9c][00211fa0] 55         push ebp
> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
> H0: Infinite Loop Detected Simulation Stopped
>
>
>

Red Herring.

Just because you can prove for ONE example from a partial a partial
trace that it will never halt, doesn't mean you can do it for all inputs.

FALLACY OF PROOF BY EXAMPLE.

You are just proving that you don't know what you are talking about.

Note, even for THIS example, the mear fact that H0 aborted a simulation
doesn't actually prove the results is non-halting.

You need to apply a valid deduction from a valid rule out of the trace
to show that.

In this case, if you go from one address to that exact same address with
no conditional instructions, is one valid rule for proving non-halting.

On 9/9/2022 9:17 PM, Richard Damon wrote:
> On 9/9/22 7:17 PM, olcott wrote:
>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>
>>> On 9/9/22 11:02 AM, olcott wrote:
>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>
>>>>>>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>>>>>>> therefore any damn thing that says:
>>>>>>>>>>>> "all correct and complete simulations of Px by Hx never halt
>>>>>>>>>>>> therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>>>
>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That is why I proved that every element of the infinite set of
>>>>>>>>>> Hx/Px pairs such that Hx correctly and completely simulates
>>>>>>>>>> its input Px never halts. *I named this set the HxPx_UTM set*
>>>>>>>>>>
>>>>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>> answer were non-halting.
>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>
>>>>>>>
>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able to
>>>>>>> take in ALL computations.
>>>>>>
>>>>>>
>>>>>> typedef void (*ptr)();
>>>>>>
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>>    x(y);
>>>>>> }
>>>>>>
>>>>>> Everyone has always said that a halt decider must predict the
>>>>>> behavior of the direct execution of the input thus Hx must base
>>>>>> its halt status decision on the above version of itself.
>>>>>>
>>>>>
>>>>> No, it must decider on its own version of itself. That is the
>>>>> DEFINITION.
>>>>>
>>>>
>>>> If the criteria for a simulating halt decider (SHD) was:
>>>> "Does your correctly simulated input ever stop running ?"
>>>> the SDH would always have to return 1 indicating that its input
>>>> stops running on its own or its input stops running because the SHD
>>>> correctly matched a correct infinite behavior pattern and aborted
>>>> the simulation of its input.
>>>
>>> You keep on using the wrong definitoion, I think because you just
>>> don't know what the words mean.
>>>
>>>>
>>>> This requires the halt status criteria to adopt the Linz convention
>>>> that a sequence of instructions (AKA moves) can only be construed as
>>>> halting when it reaches its own final state. This means that every
>>>> correctly simulated sequence that cannot possibly reach its final
>>>> state specifies a non-halting sequence.
>>>
>>> Right, and it is only non-halting when the sequence of steps
>>> specified by that input would NEVER halt if run/simulated for an
>>> unbounded number of step.
>>>
>>> A machine that is artificially stop, doesn't define if it would have
>>> halted or not.
>>>
>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>
>>> A simulation that stop before reaching a final state, by itself, does
>>> not prove anything about the Halting behavior of that input.
>>
>> We have been through this too many times.
>> There is no sense continuing.
>>
>> H0: Begin Simulation   Execution Trace Stored at:211fac
>> [00001102][00211f9c][00211fa0] 55         push ebp
>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>> H0: Infinite Loop Detected Simulation Stopped
>>
>>
>>
>
> Red Herring.
>
> Just because you can prove for ONE example from a partial a partial
> trace that it will never halt, doesn't mean you can do it for all inputs.
>

You have no interest in truth you only want to argue.

--
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/9/22 10:23 PM, olcott wrote:
> On 9/9/2022 9:17 PM, Richard Damon wrote:
>> On 9/9/22 7:17 PM, olcott wrote:
>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>
>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>
>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never halt
>>>>>>>>>>>>> therefore any damn thing that says:
>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>> halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>>>>
>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That is why I proved that every element of the infinite set
>>>>>>>>>>> of Hx/Px pairs such that Hx correctly and completely
>>>>>>>>>>> simulates its input Px never halts. *I named this set the
>>>>>>>>>>> HxPx_UTM set*
>>>>>>>>>>>
>>>>>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>>> answer were non-halting.
>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able to
>>>>>>>> take in ALL computations.
>>>>>>>
>>>>>>>
>>>>>>> typedef void (*ptr)();
>>>>>>>
>>>>>>> void Px(ptr x)
>>>>>>> {
>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> int Hx(ptr x, ptr y)
>>>>>>> {
>>>>>>>    x(y);
>>>>>>> }
>>>>>>>
>>>>>>> Everyone has always said that a halt decider must predict the
>>>>>>> behavior of the direct execution of the input thus Hx must base
>>>>>>> its halt status decision on the above version of itself.
>>>>>>>
>>>>>>
>>>>>> No, it must decider on its own version of itself. That is the
>>>>>> DEFINITION.
>>>>>>
>>>>>
>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>> "Does your correctly simulated input ever stop running ?"
>>>>> the SDH would always have to return 1 indicating that its input
>>>>> stops running on its own or its input stops running because the SHD
>>>>> correctly matched a correct infinite behavior pattern and aborted
>>>>> the simulation of its input.
>>>>
>>>> You keep on using the wrong definitoion, I think because you just
>>>> don't know what the words mean.
>>>>
>>>>>
>>>>> This requires the halt status criteria to adopt the Linz convention
>>>>> that a sequence of instructions (AKA moves) can only be construed
>>>>> as halting when it reaches its own final state. This means that
>>>>> every correctly simulated sequence that cannot possibly reach its
>>>>> final state specifies a non-halting sequence.
>>>>
>>>> Right, and it is only non-halting when the sequence of steps
>>>> specified by that input would NEVER halt if run/simulated for an
>>>> unbounded number of step.
>>>>
>>>> A machine that is artificially stop, doesn't define if it would have
>>>> halted or not.
>>>>
>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>
>>>> A simulation that stop before reaching a final state, by itself,
>>>> does not prove anything about the Halting behavior of that input.
>>>
>>> We have been through this too many times.
>>> There is no sense continuing.
>>>
>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>> H0: Infinite Loop Detected Simulation Stopped
>>>
>>>
>>>
>>
>> Red Herring.
>>
>> Just because you can prove for ONE example from a partial a partial
>> trace that it will never halt, doesn't mean you can do it for all inputs.
>>
>
> You have no interest in truth you only want to argue.
>

I can say the same about you.

You don't care what is ACTUALLY true, only what you want to be true to
match your incorrect ideas.

I have the ACTAUL DEFINITIONS on my side, you just make up meanings.

FAIL.

On 9/9/2022 9:29 PM, Richard Damon wrote:
> On 9/9/22 10:23 PM, olcott wrote:
>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>> On 9/9/22 7:17 PM, olcott wrote:
>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>> halt therefore any damn thing that says:
>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>> halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> That is why I proved that every element of the infinite set
>>>>>>>>>>>> of Hx/Px pairs such that Hx correctly and completely
>>>>>>>>>>>> simulates its input Px never halts. *I named this set the
>>>>>>>>>>>> HxPx_UTM set*
>>>>>>>>>>>>
>>>>>>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>>>> answer were non-halting.
>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able to
>>>>>>>>> take in ALL computations.
>>>>>>>>
>>>>>>>>
>>>>>>>> typedef void (*ptr)();
>>>>>>>>
>>>>>>>> void Px(ptr x)
>>>>>>>> {
>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>>    x(y);
>>>>>>>> }
>>>>>>>>
>>>>>>>> Everyone has always said that a halt decider must predict the
>>>>>>>> behavior of the direct execution of the input thus Hx must base
>>>>>>>> its halt status decision on the above version of itself.
>>>>>>>>
>>>>>>>
>>>>>>> No, it must decider on its own version of itself. That is the
>>>>>>> DEFINITION.
>>>>>>>
>>>>>>
>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>> the SDH would always have to return 1 indicating that its input
>>>>>> stops running on its own or its input stops running because the
>>>>>> SHD correctly matched a correct infinite behavior pattern and
>>>>>> aborted the simulation of its input.
>>>>>
>>>>> You keep on using the wrong definitoion, I think because you just
>>>>> don't know what the words mean.
>>>>>
>>>>>>
>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>> convention that a sequence of instructions (AKA moves) can only be
>>>>>> construed as halting when it reaches its own final state. This
>>>>>> means that every correctly simulated sequence that cannot possibly
>>>>>> reach its final state specifies a non-halting sequence.
>>>>>
>>>>> Right, and it is only non-halting when the sequence of steps
>>>>> specified by that input would NEVER halt if run/simulated for an
>>>>> unbounded number of step.
>>>>>
>>>>> A machine that is artificially stop, doesn't define if it would
>>>>> have halted or not.
>>>>>
>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>
>>>>> A simulation that stop before reaching a final state, by itself,
>>>>> does not prove anything about the Halting behavior of that input.
>>>>
>>>> We have been through this too many times.
>>>> There is no sense continuing.
>>>>
>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>
>>>>
>>>>
>>>
>>> Red Herring.
>>>
>>> Just because you can prove for ONE example from a partial a partial
>>> trace that it will never halt, doesn't mean you can do it for all
>>> inputs.
>>>
>>
>> You have no interest in truth you only want to argue.
>>
>
> I can say the same about you.
>
> You don't care what is ACTUALLY true, only what you want to be true to
> match your incorrect ideas.
>
> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>
> FAIL.

A simulating halt decider is a new thing and you reject it on that basis.

--
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/9/22 10:52 PM, olcott wrote:
> On 9/9/2022 9:29 PM, Richard Damon wrote:
>> On 9/9/22 10:23 PM, olcott wrote:
>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>> halt therefore any damn thing that says:
>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>> halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is why I proved that every element of the infinite set
>>>>>>>>>>>>> of Hx/Px pairs such that Hx correctly and completely
>>>>>>>>>>>>> simulates its input Px never halts. *I named this set the
>>>>>>>>>>>>> HxPx_UTM set*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements of the
>>>>>>>>>>>>> HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>>>>> answer were non-halting.
>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able
>>>>>>>>>> to take in ALL computations.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>
>>>>>>>>> void Px(ptr x)
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>> {
>>>>>>>>>    x(y);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Everyone has always said that a halt decider must predict the
>>>>>>>>> behavior of the direct execution of the input thus Hx must base
>>>>>>>>> its halt status decision on the above version of itself.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, it must decider on its own version of itself. That is the
>>>>>>>> DEFINITION.
>>>>>>>>
>>>>>>>
>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>> the SDH would always have to return 1 indicating that its input
>>>>>>> stops running on its own or its input stops running because the
>>>>>>> SHD correctly matched a correct infinite behavior pattern and
>>>>>>> aborted the simulation of its input.
>>>>>>
>>>>>> You keep on using the wrong definitoion, I think because you just
>>>>>> don't know what the words mean.
>>>>>>
>>>>>>>
>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>> convention that a sequence of instructions (AKA moves) can only
>>>>>>> be construed as halting when it reaches its own final state. This
>>>>>>> means that every correctly simulated sequence that cannot
>>>>>>> possibly reach its final state specifies a non-halting sequence.
>>>>>>
>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>> specified by that input would NEVER halt if run/simulated for an
>>>>>> unbounded number of step.
>>>>>>
>>>>>> A machine that is artificially stop, doesn't define if it would
>>>>>> have halted or not.
>>>>>>
>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>
>>>>>> A simulation that stop before reaching a final state, by itself,
>>>>>> does not prove anything about the Halting behavior of that input.
>>>>>
>>>>> We have been through this too many times.
>>>>> There is no sense continuing.
>>>>>
>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>
>>>>>
>>>>>
>>>>
>>>> Red Herring.
>>>>
>>>> Just because you can prove for ONE example from a partial a partial
>>>> trace that it will never halt, doesn't mean you can do it for all
>>>> inputs.
>>>>
>>>
>>> You have no interest in truth you only want to argue.
>>>
>>
>> I can say the same about you.
>>
>> You don't care what is ACTUALLY true, only what you want to be true to
>> match your incorrect ideas.
>>
>> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>>
>> FAIL.
>
> A simulating halt decider is a new thing and you reject it on that basis.
>

So, are you admitting that a Simulating Hlt Decider isn't a actual Halt
Decider, and thus not constrained by the definition of one?

Or will you admit that you want them to be Halt Deciders, and thus they
must behave as one.

You seem to act like they aren't constrained by the rules but still get
credit for being one, but that isn't a legal option.

Either you admit that you have been lying all these years that you have
been working on the actual Halting Problem because you H is just a
"PO-Simulationg Halt Decider" that isn't actually a Halt Decider, or you
admit that your machines are supposed to be Halt Deciders, but just give
the wrong answer based on what a Halt Decider is defined to need to give.

On 9/9/2022 10:28 PM, Richard Damon wrote:
> On 9/9/22 10:52 PM, olcott wrote:
>> On 9/9/2022 9:29 PM, Richard Damon wrote:
>>> On 9/9/22 10:23 PM, olcott wrote:
>>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>>> halt therefore any damn thing that says:
>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>>> halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And the second statement is nonsense because Px isn't *A*
>>>>>>>>>>>>>>> machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is why I proved that every element of the infinite
>>>>>>>>>>>>>> set of Hx/Px pairs such that Hx correctly and completely
>>>>>>>>>>>>>> simulates its input Px never halts. *I named this set the
>>>>>>>>>>>>>> HxPx_UTM set*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements of
>>>>>>>>>>>>>> the HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>>>>>> answer were non-halting.
>>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able
>>>>>>>>>>> to take in ALL computations.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>
>>>>>>>>>> void Px(ptr x)
>>>>>>>>>> {
>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>    return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>> {
>>>>>>>>>>    x(y);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Everyone has always said that a halt decider must predict the
>>>>>>>>>> behavior of the direct execution of the input thus Hx must
>>>>>>>>>> base its halt status decision on the above version of itself.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, it must decider on its own version of itself. That is the
>>>>>>>>> DEFINITION.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>>> the SDH would always have to return 1 indicating that its input
>>>>>>>> stops running on its own or its input stops running because the
>>>>>>>> SHD correctly matched a correct infinite behavior pattern and
>>>>>>>> aborted the simulation of its input.
>>>>>>>
>>>>>>> You keep on using the wrong definitoion, I think because you just
>>>>>>> don't know what the words mean.
>>>>>>>
>>>>>>>>
>>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>>> convention that a sequence of instructions (AKA moves) can only
>>>>>>>> be construed as halting when it reaches its own final state.
>>>>>>>> This means that every correctly simulated sequence that cannot
>>>>>>>> possibly reach its final state specifies a non-halting sequence.
>>>>>>>
>>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>>> specified by that input would NEVER halt if run/simulated for an
>>>>>>> unbounded number of step.
>>>>>>>
>>>>>>> A machine that is artificially stop, doesn't define if it would
>>>>>>> have halted or not.
>>>>>>>
>>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>>
>>>>>>> A simulation that stop before reaching a final state, by itself,
>>>>>>> does not prove anything about the Halting behavior of that input.
>>>>>>
>>>>>> We have been through this too many times.
>>>>>> There is no sense continuing.
>>>>>>
>>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Red Herring.
>>>>>
>>>>> Just because you can prove for ONE example from a partial a partial
>>>>> trace that it will never halt, doesn't mean you can do it for all
>>>>> inputs.
>>>>>
>>>>
>>>> You have no interest in truth you only want to argue.
>>>>
>>>
>>> I can say the same about you.
>>>
>>> You don't care what is ACTUALLY true, only what you want to be true
>>> to match your incorrect ideas.
>>>
>>> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>>>
>>> FAIL.
>>
>> A simulating halt decider is a new thing and you reject it on that basis.
>>
>
> So, are you admitting that a Simulating Hlt Decider isn't a actual Halt
> Decider, and thus not constrained by the definition of one?
A simulating halt decider is a new idea that you reject entirely on the
basis that it is a new idea. Airplanes contradicted the "definition"
that humans cannot fly.

On 9/10/22 12:04 AM, olcott wrote:
> On 9/9/2022 10:28 PM, Richard Damon wrote:
>> On 9/9/22 10:52 PM, olcott wrote:
>>> On 9/9/2022 9:29 PM, Richard Damon wrote:
>>>> On 9/9/22 10:23 PM, olcott wrote:
>>>>> On 9/9/2022 9:17 PM, Richard Damon wrote:
>>>>>> On 9/9/22 7:17 PM, olcott wrote:
>>>>>>> On 9/9/2022 6:03 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/9/22 11:02 AM, olcott wrote:
>>>>>>>>> On 9/8/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/8/22 10:44 PM, olcott wrote:
>>>>>>>>>>> On 9/8/2022 8:27 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/8/22 8:59 PM, olcott wrote:
>>>>>>>>>>>>> On 9/8/2022 7:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/8/22 8:25 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/8/2022 6:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/8/22 6:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All male humans are humans.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>>>> halt therefore any damn thing that says:
>>>>>>>>>>>>>>>>> "all correct and complete simulations of Px by Hx never
>>>>>>>>>>>>>>>>> halt therefore" *IS NECESSARILY CORRECT*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And the second statement is nonsense because Px isn't
>>>>>>>>>>>>>>>> *A* machine, just like Hx isn't A machine.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Each machine in the Px set can have different behaviors.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is why I proved that every element of the infinite
>>>>>>>>>>>>>>> set of Hx/Px pairs such that Hx correctly and completely
>>>>>>>>>>>>>>> simulates its input Px never halts. *I named this set the
>>>>>>>>>>>>>>> HxPx_UTM set*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus any damn thing that claims that the Px elements of
>>>>>>>>>>>>>>> the HxPx_UTM set never halt is necessarily correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you only proved the Px's built on the Hx's that don't
>>>>>>>>>>>>>> answer were non-halting.
>>>>>>>>>>>>> That is the entire domain of SHD Hx.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then it isn't a Halt Decider, as a Halt Decider must be able
>>>>>>>>>>>> to take in ALL computations.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>
>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>>>>> {
>>>>>>>>>>>    x(y);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Everyone has always said that a halt decider must predict the
>>>>>>>>>>> behavior of the direct execution of the input thus Hx must
>>>>>>>>>>> base its halt status decision on the above version of itself.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, it must decider on its own version of itself. That is the
>>>>>>>>>> DEFINITION.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If the criteria for a simulating halt decider (SHD) was:
>>>>>>>>> "Does your correctly simulated input ever stop running ?"
>>>>>>>>> the SDH would always have to return 1 indicating that its input
>>>>>>>>> stops running on its own or its input stops running because the
>>>>>>>>> SHD correctly matched a correct infinite behavior pattern and
>>>>>>>>> aborted the simulation of its input.
>>>>>>>>
>>>>>>>> You keep on using the wrong definitoion, I think because you
>>>>>>>> just don't know what the words mean.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> This requires the halt status criteria to adopt the Linz
>>>>>>>>> convention that a sequence of instructions (AKA moves) can only
>>>>>>>>> be construed as halting when it reaches its own final state.
>>>>>>>>> This means that every correctly simulated sequence that cannot
>>>>>>>>> possibly reach its final state specifies a non-halting sequence.
>>>>>>>>
>>>>>>>> Right, and it is only non-halting when the sequence of steps
>>>>>>>> specified by that input would NEVER halt if run/simulated for an
>>>>>>>> unbounded number of step.
>>>>>>>>
>>>>>>>> A machine that is artificially stop, doesn't define if it would
>>>>>>>> have halted or not.
>>>>>>>>
>>>>>>>> Thus, your definition, adding the words  "By H", are incorrect.
>>>>>>>>
>>>>>>>> A simulation that stop before reaching a final state, by itself,
>>>>>>>> does not prove anything about the Halting behavior of that input.
>>>>>>>
>>>>>>> We have been through this too many times.
>>>>>>> There is no sense continuing.
>>>>>>>
>>>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Red Herring.
>>>>>>
>>>>>> Just because you can prove for ONE example from a partial a
>>>>>> partial trace that it will never halt, doesn't mean you can do it
>>>>>> for all inputs.
>>>>>>
>>>>>
>>>>> You have no interest in truth you only want to argue.
>>>>>
>>>>
>>>> I can say the same about you.
>>>>
>>>> You don't care what is ACTUALLY true, only what you want to be true
>>>> to match your incorrect ideas.
>>>>
>>>> I have the ACTAUL DEFINITIONS on my side, you just make up meanings.
>>>>
>>>> FAIL.
>>>
>>> A simulating halt decider is a new thing and you reject it on that
>>> basis.
>>>
>>
>> So, are you admitting that a Simulating Hlt Decider isn't a actual
>> Halt Decider, and thus not constrained by the definition of one?
> A simulating halt decider is a new idea that you reject entirely on the
> basis that it is a new idea. Airplanes contradicted the "definition"
> that humans cannot fly.
>

On Friday, September 9, 2022 at 8:47:11 PM UTC+1, olcott wrote:
> On 9/9/2022 2:31 PM, Paul N wrote:
> > On Friday, September 9, 2022 at 8:10:10 PM UTC+1, olcott wrote:
> >> On 9/9/2022 1:36 PM, Paul N wrote:
> >>> On Friday, September 9, 2022 at 7:16:42 PM UTC+1, olcott wrote:
> >>>> On 9/9/2022 12:49 PM, Paul N wrote:
> >>>>> On Friday, September 9, 2022 at 3:19:07 PM UTC+1, olcott wrote:
> >>>>>> On 9/9/2022 6:49 AM, Paul N wrote:
> >>>>>>> On Thursday, September 8, 2022 at 11:34:08 PM UTC+1, olcott wrote:
> >>>>>>>> On 9/8/2022 3:25 PM, Paul N wrote:
> >>>>>>>>> On Thursday, September 8, 2022 at 4:50:20 PM UTC+1, olcott wrote:
> >>>>>>>>>> On 9/8/2022 8:07 AM, Paul N wrote:
> >>>>>>>>>>> On Thursday, September 8, 2022 at 4:09:44 AM UTC+1, olcott 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));
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>>> Does any complete and correct simulation of Px by Hx ever stop running?
> >>>>>>>>>>>
> >>>>>>>>>>> We can easily see that if Hx returns zero then Px halts, and if Hx returns non-zero then Px does not halt. So Hx can never do a complete and correct simulation of Px and return the right answer.
> >>>>>>>>>>>
> >>>>>>>>>> *We will call this the UTM subset*
> >>>>>>>>>> We are discussing the infinite set of Hx/Px pairs.
> >>>>>>>>>
> >>>>>>>>> Just to clarify, we're talking about pairs Hx and Px where the Px of the pair calls the Hx of the pair as in the code above, but we're not putting any restrictions on what Hx does?
> >>>>>>>>>
> >>>>>>>>>> An infinite subset of
> >>>>>>>>>> these do a complete and correct simulation of their input.
> >>>>>>>>>
> >>>>>>>>> If by this you mean that the Hx of the pair correctly predicts whether the Px of the pair halts, then no, they ALL get it wrong, as shown above.
> >>>>>>>>>
> >>>>>>>>>> Perhaps you fail to comprehend that all of this subset would remain
> >>>>>>>>>> stuck in infinitely recursive simulation such that Px never reaches its
> >>>>>>>>>> final state and the simulation never stops, thus Hx never returns any
> >>>>>>>>>> value.
> >>>>>>>>>
> >>>>>>>>> This point is moot, there are no pairs in this subset.
> >>>>>>>>>
> >>>>>>>>>> *Of the remaining subsets*
> >>>>>>>>>> (1) One of these ignores its input and translates the Lord's prayer into
> >>>>>>>>>> ancient Egyptian.
> >>>>>>>>>>
> >>>>>>>>>> (2) Another one of these ignores its input and makes all the moves where
> >>>>>>>>>> Deep Blue beat Garry Kasparov in the famous sixth match.
> >>>>>>>>>> https://en.wikipedia.org/wiki/Deep_Blue_versus_Garry_Kasparov#Game_6_2
> >>>>>>>>>>
> >>>>>>>>>> (3) An infinite subset of the *remaining subsets* ignores its input and
> >>>>>>>>>> returns each element of the set of integers, thus one of them returns 1
> >>>>>>>>>> and another returns 0, this one is called the *wild guess halt decider*
> >>>>>>>>>
> >>>>>>>>> All of the wild guess deciders will be wrong. The one always guessing 0 will always be wrong for Px, its Px will halt. The one always guessing 1 will always be wrong for Px, its Px will not halt. Follow the code of Px if you don't believe me.
> >>>>>>>>>
> >>>>>>>>>> (4) One of these implements the algorithm of my simulating halt decider
> >>>>>>>>>> https://liarparadox.org/2022_09_07.zip
> >>>>>>>>>
> >>>>>>>>> And this one will be wrong too, see above.
> >>>>>>>>>
> >>>>>>>>>> When it is the job of the halt decider to correctly predict whether or
> >>>>>>>>>> not its correct and complete simulation of its input would halt even the
> >>>>>>>>>> *wild guess halt decider* element of subset (3) is correct:
> >>>>>>>>>
> >>>>>>>>>> int Hx(ptr x, ptr y)
> >>>>>>>>>> {
> >>>>>>>>>> return 0;
> >>>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> No, this is wrong, it predicts Px will not halt, but Px does halt. Try running it!
> >>>>>>>> All male humans are humans.
> >>>>>>>>
> >>>>>>>> all correct and complete simulations of Px by Hx never halt therefore
> >>>>>>>> any damn thing that says:
> >>>>>>>> "all correct and complete simulations of Px by Hx never halt therefore"
> >>>>>>>> *IS NECESSARILY CORRECT*
> >>>>>>>
> >>>>>>> Firstly, I see that you have ignored almost all of what I wrote and are headed off in a different direction. I wonder why?
> >>>>>
> >>>>>> So you don't understand the above point that applies to every program
> >>>>>> that return 0?
> >>>>>
> >>>>> If you mean the four lines just above, no, I am not clear what they say. I'm not even sure you know what they say. I think you need some words after the second "therefore" to make them make sense.
> >>>>>
> >>>>
> >>>> 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));
> >>>> }
> >>>> The code for Px is fully specified. The code for Hx is the infinite set
> >>>> of every C function that takes a pair of ptr arguments. These arguments
> >>>> can be ignored, summed together, multiplied together, simulated, or
> >>>> anything else. One element of Hx ignores its arguments, translates the
> >>>> Lord's prayer into ancient Egyptian and returns 56.
> >>>>
> >>>> A subset of these C functions perform a correct partial or complete
> >>>> simulation of their input. In none of the elements of this set does Px
> >>>> ever reach its final state.
> >>>>
> >>>> A subset of the original set return a value of 0, which turns out to be
> >>>> the correct answer to the question:
> >>>>
> >>>> Does there exist any element of the infinite set of Hx/Px pairs such
> >>>> that Px correctly simulated by Hx reaches the final state of Px?
> >>>>
> >>>> One element of the prior set correctly matches a correct infinite
> >>>> behavior pattern, aborts the simulation of its input on the basis and
> >>>> returns 0.
> >>>
> >>> You've quoted the code of Px above, are you really incapable of actually understanding it? Let's see:
> >>>
> >>> void Px(ptr x)
> >>> {
> >>> int Halt_Status = Hx(x, x); // you say that Hx(x, x) returns 0, so Halt_Status is set to zero
> >>>> if (Halt_Status) // Halt_Status is zero, so this "if" fails...
> >>>> HERE: goto HERE; // ... and so this line is not executed ...
> >>>> return; // ... and we get to here.
> >>>> }
> >>>
> >>> So Px halts. There is no infinite behaviour pattern.
> >> I have to update my last reply because I realized that it was not
> >> accurate. I really only want an honest dialogue and I incorrectly said
> >> that you made a mistake that you did not make.
> >
> > Thank you for this. Yes, I was saying that if Hx(Px, Px) returns 0 then Px halts.
> >
> >> A simulating halt decider (SHD) only reports on the behavior of what its
> >> complete and correct simulation of its input would be, it never reports
> >> on the actual behavior of what its partial simulation is.
> >>
> >> If a SHD reported on whether or not its input stopped running then in
> >> those cases where the simulated input stopped on its own and those cases
> >> where the simulation was aborted the simulated input stopped running.
> >> This derives a correct halt decider with no discernment every input is
> >> reported to stop running.
> >>
> >> To allow a SHD to have discernment it answers a different question:
> >> Does any correct simulation of its input reach the final state of this
> >> input?
> >
> > The snag is that Hx must always give the wrong answer for Px,
> That is not true. Of the infinite set of Hx that correctly simulate Px
> none ever reach the final state of Px.