On 9/16/2022 6:09 PM, Mr Flibble wrote:
> On Fri, 16 Sep 2022 11:17:18 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> void Px(ptr x)
>> {
>> int Halt_Status = Hx(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", Hx(Px, Px));
>> }
>>
>> *Understanding the above code proves this*
>> There are zero elements of infinite set of Hx/Px pairs such that the
>> correct *partial or complete* simulation of Px by Hx reaches the
>> final state of Px.
>
> Your Hx gives an incorrect halting decision if Px is rewritten as:
>
> void Px(ptr x)
> {
> int Halt_Status = Hx(x, x);
> (void)Halt_Status;
> return;
> }
>
> It is patently obvious to everyone except you that if Hx is a valid
> halt decider then it must return a value to Px meaning Px will then
> halt. Your Hx gives a halting decision of non-halting which is
> erroneous.
>
> /Flibble
>

Why are you deliberately cross-posting when follow-up is explicitly set
of comp.theory?

When my pure function halt decider determines the halt status of the
above input it aborts this input before the call to itself is even
executed.

If you believe that a function that was never even executed must return
a value then you must be nuts.

If you can't see that the return value from Hx is unreachable from the
correctly simulated Px then you must be incompetent.

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

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

INCORRECT

>> only works on the gullible fools that
>> don't notice the strawman deception of changing the subject and then
>> forming a rebuttal of this changed subject.
>>
>
> You are ADMITTING that only "guillible fools" beleive you and your
> strawman arguements.
--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

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

No, apparently you are just lying or proving your stupidity.

You just don't know what a computation is, so what is required for
something to be a decider.

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

All "Encodings" of a given algorithm must behave the same, if all that
is varying is the "Encoding" (the symbolic representation of the
operations) and not the actual operations that are performed.

Maybe you don't understand what an encoding is. I dop remember you
dropping out of that class before you got to it.

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

Thus, your "encodings" are actually "encodings" but different actaul
implementations of a generic algorithm.

Thus you have a set of SPECIIF ALGORITHMS.

A decider must be a SPECIFIC ALGORITHM, so your set of different
variations on a generic algorithm is actually a SET OF DIFFERENT DECIDERS.

Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
deciders since they implement a different computaiton giving different
results for the same input.

>
> *H0 and Infinite_loop are contained within halt7.c*
>
> *complete halt deciding system including*
> *(a) x86utm operating system*
> *(b) complete x86 emulator*
> *(c) All of the various halt deciders and their inputs are contained in
> Halt7.c*
> https://liarparadox.org/2022_09_07.zip
>
> This system currently only compiles under:
> Microsoft Visual Studio Community 2017
> https://visualstudio.microsoft.com/vs/older-downloads/
>
>
>

On 9/16/2022 6:40 PM, Richard Damon wrote:
>
> On 9/16/22 7:12 PM, olcott wrote:
>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>> On 9/16/22 6:45 PM, olcott wrote:
>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You have to carefully study every single word that I said
>>>>>>>>>>>>>> and then you will see that Hx/Px pairs include an infinite
>>>>>>>>>>>>>> set of definitions of Hx.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are non-halting,
>>>>>>>>>>>> I have proved that none of the partially or fully simulated
>>>>>>>>>>>> Px inputs simulated by Hx ever reach their final state.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right.
>>>>>>>>>>>
>>>>>>>>>>>> A subset of these are the elements of Px fully simulated by Hx.
>>>>>>>>>>>
>>>>>>>>>>> Right, and that subset that is fully simulated is PRECISELY
>>>>>>>>>>> the subset based on Hx's that don't abort.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>>>>> decision on whether or not it must abort the simulation of
>>>>>>>>>>>> its input to prevent infinite simulation then every Hx that
>>>>>>>>>>>> returns 0 is correct.
>>>>>>>>>>>
>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset that
>>>>>>>>>>> you showed create Px's that were completely simulated to show
>>>>>>>>>>> non-halting, so you have ZERO proof that its input is
>>>>>>>>>>> non-halting
>>>>>>>>>> If that reasoning was valid then it would apply equally to this:
>>>>>>>>>
>>>>>>>>> Yes, it applies there. The issue is that YOU are not noticing
>>>>>>>>> that you are actually applying some logic to see that
>>>>>>>>> Infinite_Loop wouldn't go on forever, so the halting is correct.
>>>>>>>>>
>>>>>>>> OK so you have proven that you are unequivocally a liar when you
>>>>>>>> say that an infinite loop does not go on forever.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> WHERE DID I SAY THAT?
>>>>>>>
>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>
>>>>>>> I said that you have no copy of H0 that simulates that input
>>>>>>> forever, not that IS the same compuation as H0, as implied by
>>>>>>> your definition,
>>>>>>
>>>>>> So you agree that H0 correctly determines that its simulation of
>>>>>> Infinite_Loop would never stop running if this simulation was
>>>>>> never aborted?
>>>>>>
>>>>>
>>>>> The conclusion is correct but the wording is illogical.
>>>>>
>>>>> H0 either does or does not abort its simulation.
>>>>>
>>>>
>>>> There are only two mutually exclusive categories for every possible
>>>> behavior of elements of the infinite set of encodings of H0 where H0
>>>> correctly simulates its input:
>>>
>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but sets
>>> of them?
>>>
>>> That means you don't understand what a computation is. Or even what a
>>> computater program is.
>>>
>>>
>>>> (a) Abort the simulation of its input some point.
>>>> (b) Never abort the simulation of its input at any point.
>>>
>>> Right, so which ONE is H0?
>>>
>>> Please write a program that represents this SET.
>>>
>>> You clearly don't understand what a PROGRAM is.
>>>
>>>>
>>>> When H0 returns 0 it does this based on correctly matching a correct
>>>> infinite behavior pattern that correctly determines the actual
>>>> behavior of every element of set (b).
>>>>
>>>
>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>
>>
>> Did I stutter?
>
> No, apparently you are just lying or proving your stupidity.
>
> You just don't know what a computation is, so what is required for
> something to be a decider.
>
>> Every element of the set of encodings of H0 that returns 0 correctly
>> determines the halt status of Infinite_Loop for every possible
>> encoding of H0 that correctly and completely simulates Infinite_Loop.
>
> All "Encodings" of a given algorithm must behave the same, if all that
> is varying is the "Encoding" (the symbolic representation of the
> operations) and not the actual operations that are performed.
>
> Maybe you don't understand what an encoding is. I dop remember you
> dropping out of that class before you got to it.
>
>>
>> A subset of these encodings of H0 that return 0 do so on the basis of
>> correctly matching a correct infinite behavior pattern that
>> conclusively proves that Infinite_Loop never halts.
>
> Thus, your "encodings" are actually "encodings" but different actaul
> implementations of a generic algorithm.
>
> Thus you have a set of SPECIIF ALGORITHMS.
>
> A decider must be a SPECIFIC ALGORITHM, so your set of different
> variations on a generic algorithm is actually a SET OF DIFFERENT DECIDERS.
>
> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
> deciders since they implement a different computaiton giving different
> results for the same input.
>
>>
>> *H0 and Infinite_loop are contained within halt7.c*
>>
>> *complete halt deciding system including*
>> *(a) x86utm operating system*
>> *(b) complete x86 emulator*
>> *(c) All of the various halt deciders and their inputs are contained
>> in Halt7.c*
>> https://liarparadox.org/2022_09_07.zip
>>
>> This system currently only compiles under:
>> Microsoft Visual Studio Community 2017
>> https://visualstudio.microsoft.com/vs/older-downloads/
>>
>>
>>
>
> And note, that H0 is just a SPEICIIFIC implementation of your generic
> set you are talking about, and doesn't meet your requirements, as it
> never completely simulatutes its input, so it hasn't proven by its
> complete simulation of the input that it is non-halting.
>
> (It may be correct about that input being non-halting by the actual
> definition, but it shows the problem with YOUR definition, as there is
> no H0 that is that H0 that does the required complete simulation, just
> as there NEVER is for any of your deciders that give a non-halting answer.

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

Yep, YOU are calling yourself INCORECT.

You seem to be having troubles with your editing.

Is lying getting harder for you?

>
>>> only works on the gullible fools that don't notice the strawman
>>> deception of changing the subject and then forming a rebuttal of this
>>> changed subject.
>>>
>>
>> You are ADMITTING that only "guillible fools" beleive you and your
>> strawman arguements.

On 9/16/22 7:45 PM, olcott wrote:
> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>
>> On 9/16/22 7:12 PM, olcott wrote:
>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You have to carefully study every single word that I said
>>>>>>>>>>>>>>> and then you will see that Hx/Px pairs include an
>>>>>>>>>>>>>>> infinite set of definitions of Hx.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>> I have proved that none of the partially or fully simulated
>>>>>>>>>>>>> Px inputs simulated by Hx ever reach their final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right.
>>>>>>>>>>>>
>>>>>>>>>>>>> A subset of these are the elements of Px fully simulated by
>>>>>>>>>>>>> Hx.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and that subset that is fully simulated is PRECISELY
>>>>>>>>>>>> the subset based on Hx's that don't abort.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>>>>>> decision on whether or not it must abort the simulation of
>>>>>>>>>>>>> its input to prevent infinite simulation then every Hx that
>>>>>>>>>>>>> returns 0 is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset that
>>>>>>>>>>>> you showed create Px's that were completely simulated to
>>>>>>>>>>>> show non-halting, so you have ZERO proof that its input is
>>>>>>>>>>>> non-halting
>>>>>>>>>>> If that reasoning was valid then it would apply equally to this:
>>>>>>>>>>
>>>>>>>>>> Yes, it applies there. The issue is that YOU are not noticing
>>>>>>>>>> that you are actually applying some logic to see that
>>>>>>>>>> Infinite_Loop wouldn't go on forever, so the halting is correct.
>>>>>>>>>>
>>>>>>>>> OK so you have proven that you are unequivocally a liar when
>>>>>>>>> you say that an infinite loop does not go on forever.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>
>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>
>>>>>>>> I said that you have no copy of H0 that simulates that input
>>>>>>>> forever, not that IS the same compuation as H0, as implied by
>>>>>>>> your definition,
>>>>>>>
>>>>>>> So you agree that H0 correctly determines that its simulation of
>>>>>>> Infinite_Loop would never stop running if this simulation was
>>>>>>> never aborted?
>>>>>>>
>>>>>>
>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>
>>>>>> H0 either does or does not abort its simulation.
>>>>>>
>>>>>
>>>>> There are only two mutually exclusive categories for every possible
>>>>> behavior of elements of the infinite set of encodings of H0 where
>>>>> H0 correctly simulates its input:
>>>>
>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but sets
>>>> of them?
>>>>
>>>> That means you don't understand what a computation is. Or even what
>>>> a computater program is.
>>>>
>>>>
>>>>> (a) Abort the simulation of its input some point.
>>>>> (b) Never abort the simulation of its input at any point.
>>>>
>>>> Right, so which ONE is H0?
>>>>
>>>> Please write a program that represents this SET.
>>>>
>>>> You clearly don't understand what a PROGRAM is.
>>>>
>>>>>
>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>> correct infinite behavior pattern that correctly determines the
>>>>> actual behavior of every element of set (b).
>>>>>
>>>>
>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>
>>>
>>> Did I stutter?
>>
>> No, apparently you are just lying or proving your stupidity.
>>
>> You just don't know what a computation is, so what is required for
>> something to be a decider.
>>
>>> Every element of the set of encodings of H0 that returns 0 correctly
>>> determines the halt status of Infinite_Loop for every possible
>>> encoding of H0 that correctly and completely simulates Infinite_Loop.
>>
>> All "Encodings" of a given algorithm must behave the same, if all that
>> is varying is the "Encoding" (the symbolic representation of the
>> operations) and not the actual operations that are performed.
>>
>> Maybe you don't understand what an encoding is. I dop remember you
>> dropping out of that class before you got to it.
>>
>>>
>>> A subset of these encodings of H0 that return 0 do so on the basis of
>>> correctly matching a correct infinite behavior pattern that
>>> conclusively proves that Infinite_Loop never halts.
>>
>> Thus, your "encodings" are actually "encodings" but different actaul
>> implementations of a generic algorithm.
>>
>> Thus you have a set of SPECIIF ALGORITHMS.
>>
>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>> variations on a generic algorithm is actually a SET OF DIFFERENT
>> DECIDERS.
>>
>> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
>> deciders since they implement a different computaiton giving different
>> results for the same input.
>>
>>>
>>> *H0 and Infinite_loop are contained within halt7.c*
>>>
>>> *complete halt deciding system including*
>>> *(a) x86utm operating system*
>>> *(b) complete x86 emulator*
>>> *(c) All of the various halt deciders and their inputs are contained
>>> in Halt7.c*
>>> https://liarparadox.org/2022_09_07.zip
>>>
>>> This system currently only compiles under:
>>> Microsoft Visual Studio Community 2017
>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>
>>>
>>>
>>
>> And note, that H0 is just a SPEICIIFIC implementation of your generic
>> set you are talking about, and doesn't meet your requirements, as it
>> never completely simulatutes its input, so it hasn't proven by its
>> complete simulation of the input that it is non-halting.
>>
>> (It may be correct about that input being non-halting by the actual
>> definition, but it shows the problem with YOUR definition, as there is
>> no H0 that is that H0 that does the required complete simulation, just
>> as there NEVER is for any of your deciders that give a non-halting
>> answer.
>
> So you consistently fail to comprehend the idea of non-halting behavior
> patterns that accurately predict the behavior of complete simulations?
>

On 9/16/22 7:37 PM, olcott wrote:
> On 9/16/2022 6:09 PM, Mr Flibble wrote:
>> On Fri, 16 Sep 2022 11:17:18 -0500
>> olcott <polcott2@gmail.com> wrote:
>>
>>> void Px(ptr x)
>>> {
>>>     int Halt_Status = Hx(x, x);
>>>     if (Halt_Status)
>>>       HERE: goto HERE;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", Hx(Px, Px));
>>> }
>>>
>>> *Understanding the above code proves this*
>>> There are zero elements of infinite set of Hx/Px pairs such that the
>>> correct *partial or complete* simulation of Px by Hx reaches the
>>> final state of Px.
>>
>> Your Hx gives an incorrect halting decision if Px is rewritten as:
>>
>> void Px(ptr x)
>> {
>>     int Halt_Status = Hx(x, x);
>>     (void)Halt_Status;
>>     return;
>> }
>>
>> It is patently obvious to everyone except you that if Hx is a valid
>> halt decider then it must return a value to Px meaning Px will then
>> halt.  Your Hx gives a halting decision of non-halting which is
>> erroneous.
>>
>> /Flibble
>>
>
> Why are you deliberately cross-posting when follow-up is explicitly set
> of comp.theory?
>
> When my pure function halt decider determines the halt status of the
> above input it aborts this input before the call to itself is even
> executed.
>
> If you believe that a function that was never even executed must return
> a value then you must be nuts.
>
> If you can't see that the return value from Hx is unreachable from the
> correctly simulated Px then you must be incompetent.
>

You do understand that your posts to the other groups is just making
wider know your utter incompetnce.

"Follow-up to" is only a suggestion, and to claim that no one else is
allowe to show your error in the other groups just shows how weak your
arguement is.

On 9/16/2022 7:06 PM, Richard Damon wrote:
> On 9/16/22 7:45 PM, olcott wrote:
>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>
>>> On 9/16/22 7:12 PM, olcott wrote:
>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You have to carefully study every single word that I
>>>>>>>>>>>>>>>> said and then you will see that Hx/Px pairs include an
>>>>>>>>>>>>>>>> infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their final
>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A subset of these are the elements of Px fully simulated
>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and that subset that is fully simulated is PRECISELY
>>>>>>>>>>>>> the subset based on Hx's that don't abort.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>>>>>>> decision on whether or not it must abort the simulation of
>>>>>>>>>>>>>> its input to prevent infinite simulation then every Hx
>>>>>>>>>>>>>> that returns 0 is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset
>>>>>>>>>>>>> that you showed create Px's that were completely simulated
>>>>>>>>>>>>> to show non-halting, so you have ZERO proof that its input
>>>>>>>>>>>>> is non-halting
>>>>>>>>>>>> If that reasoning was valid then it would apply equally to
>>>>>>>>>>>> this:
>>>>>>>>>>>
>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not noticing
>>>>>>>>>>> that you are actually applying some logic to see that
>>>>>>>>>>> Infinite_Loop wouldn't go on forever, so the halting is correct.
>>>>>>>>>>>
>>>>>>>>>> OK so you have proven that you are unequivocally a liar when
>>>>>>>>>> you say that an infinite loop does not go on forever.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>
>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>
>>>>>>>>> I said that you have no copy of H0 that simulates that input
>>>>>>>>> forever, not that IS the same compuation as H0, as implied by
>>>>>>>>> your definition,
>>>>>>>>
>>>>>>>> So you agree that H0 correctly determines that its simulation of
>>>>>>>> Infinite_Loop would never stop running if this simulation was
>>>>>>>> never aborted?
>>>>>>>>
>>>>>>>
>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>
>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>
>>>>>>
>>>>>> There are only two mutually exclusive categories for every
>>>>>> possible behavior of elements of the infinite set of encodings of
>>>>>> H0 where H0 correctly simulates its input:
>>>>>
>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but
>>>>> sets of them?
>>>>>
>>>>> That means you don't understand what a computation is. Or even what
>>>>> a computater program is.
>>>>>
>>>>>
>>>>>> (a) Abort the simulation of its input some point.
>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>
>>>>> Right, so which ONE is H0?
>>>>>
>>>>> Please write a program that represents this SET.
>>>>>
>>>>> You clearly don't understand what a PROGRAM is.
>>>>>
>>>>>>
>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>> correct infinite behavior pattern that correctly determines the
>>>>>> actual behavior of every element of set (b).
>>>>>>
>>>>>
>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>
>>>>
>>>> Did I stutter?
>>>
>>> No, apparently you are just lying or proving your stupidity.
>>>
>>> You just don't know what a computation is, so what is required for
>>> something to be a decider.
>>>
>>>> Every element of the set of encodings of H0 that returns 0 correctly
>>>> determines the halt status of Infinite_Loop for every possible
>>>> encoding of H0 that correctly and completely simulates Infinite_Loop.
>>>
>>> All "Encodings" of a given algorithm must behave the same, if all
>>> that is varying is the "Encoding" (the symbolic representation of the
>>> operations) and not the actual operations that are performed.
>>>
>>> Maybe you don't understand what an encoding is. I dop remember you
>>> dropping out of that class before you got to it.
>>>
>>>>
>>>> A subset of these encodings of H0 that return 0 do so on the basis
>>>> of correctly matching a correct infinite behavior pattern that
>>>> conclusively proves that Infinite_Loop never halts.
>>>
>>> Thus, your "encodings" are actually "encodings" but different actaul
>>> implementations of a generic algorithm.
>>>
>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>
>>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>>> variations on a generic algorithm is actually a SET OF DIFFERENT
>>> DECIDERS.
>>>
>>> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
>>> deciders since they implement a different computaiton giving
>>> different results for the same input.
>>>
>>>>
>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>
>>>> *complete halt deciding system including*
>>>> *(a) x86utm operating system*
>>>> *(b) complete x86 emulator*
>>>> *(c) All of the various halt deciders and their inputs are contained
>>>> in Halt7.c*
>>>> https://liarparadox.org/2022_09_07.zip
>>>>
>>>> This system currently only compiles under:
>>>> Microsoft Visual Studio Community 2017
>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>
>>>>
>>>>
>>>
>>> And note, that H0 is just a SPEICIIFIC implementation of your generic
>>> set you are talking about, and doesn't meet your requirements, as it
>>> never completely simulatutes its input, so it hasn't proven by its
>>> complete simulation of the input that it is non-halting.
>>>
>>> (It may be correct about that input being non-halting by the actual
>>> definition, but it shows the problem with YOUR definition, as there
>>> is no H0 that is that H0 that does the required complete simulation,
>>> just as there NEVER is for any of your deciders that give a
>>> non-halting answer.
>>
>> So you consistently fail to comprehend the idea of non-halting
>> behavior patterns that accurately predict the behavior of complete
>> simulations?
>>
>
> They CAN exist, but your definition doesn't allow for their use, as you
> are defining that only the correct and complete simulation by the
> decider counts.
>

On 9/16/22 8:21 PM, olcott wrote:
> On 9/16/2022 7:06 PM, Richard Damon wrote:
>> On 9/16/22 7:45 PM, olcott wrote:
>>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>>
>>>> On 9/16/22 7:12 PM, olcott wrote:
>>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You have to carefully study every single word that I
>>>>>>>>>>>>>>>>> said and then you will see that Hx/Px pairs include an
>>>>>>>>>>>>>>>>> infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their
>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A subset of these are the elements of Px fully simulated
>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and that subset that is fully simulated is
>>>>>>>>>>>>>> PRECISELY the subset based on Hx's that don't abort.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>>>>>>>> decision on whether or not it must abort the simulation
>>>>>>>>>>>>>>> of its input to prevent infinite simulation then every Hx
>>>>>>>>>>>>>>> that returns 0 is correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset
>>>>>>>>>>>>>> that you showed create Px's that were completely simulated
>>>>>>>>>>>>>> to show non-halting, so you have ZERO proof that its input
>>>>>>>>>>>>>> is non-halting
>>>>>>>>>>>>> If that reasoning was valid then it would apply equally to
>>>>>>>>>>>>> this:
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not
>>>>>>>>>>>> noticing that you are actually applying some logic to see
>>>>>>>>>>>> that Infinite_Loop wouldn't go on forever, so the halting is
>>>>>>>>>>>> correct.
>>>>>>>>>>>>
>>>>>>>>>>> OK so you have proven that you are unequivocally a liar when
>>>>>>>>>>> you say that an infinite loop does not go on forever.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>>
>>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>>
>>>>>>>>>> I said that you have no copy of H0 that simulates that input
>>>>>>>>>> forever, not that IS the same compuation as H0, as implied by
>>>>>>>>>> your definition,
>>>>>>>>>
>>>>>>>>> So you agree that H0 correctly determines that its simulation
>>>>>>>>> of Infinite_Loop would never stop running if this simulation
>>>>>>>>> was never aborted?
>>>>>>>>>
>>>>>>>>
>>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>>
>>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>>
>>>>>>>
>>>>>>> There are only two mutually exclusive categories for every
>>>>>>> possible behavior of elements of the infinite set of encodings of
>>>>>>> H0 where H0 correctly simulates its input:
>>>>>>
>>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but
>>>>>> sets of them?
>>>>>>
>>>>>> That means you don't understand what a computation is. Or even
>>>>>> what a computater program is.
>>>>>>
>>>>>>
>>>>>>> (a) Abort the simulation of its input some point.
>>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>>
>>>>>> Right, so which ONE is H0?
>>>>>>
>>>>>> Please write a program that represents this SET.
>>>>>>
>>>>>> You clearly don't understand what a PROGRAM is.
>>>>>>
>>>>>>>
>>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>>> correct infinite behavior pattern that correctly determines the
>>>>>>> actual behavior of every element of set (b).
>>>>>>>
>>>>>>
>>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>>
>>>>>
>>>>> Did I stutter?
>>>>
>>>> No, apparently you are just lying or proving your stupidity.
>>>>
>>>> You just don't know what a computation is, so what is required for
>>>> something to be a decider.
>>>>
>>>>> Every element of the set of encodings of H0 that returns 0
>>>>> correctly determines the halt status of Infinite_Loop for every
>>>>> possible encoding of H0 that correctly and completely simulates
>>>>> Infinite_Loop.
>>>>
>>>> All "Encodings" of a given algorithm must behave the same, if all
>>>> that is varying is the "Encoding" (the symbolic representation of
>>>> the operations) and not the actual operations that are performed.
>>>>
>>>> Maybe you don't understand what an encoding is. I dop remember you
>>>> dropping out of that class before you got to it.
>>>>
>>>>>
>>>>> A subset of these encodings of H0 that return 0 do so on the basis
>>>>> of correctly matching a correct infinite behavior pattern that
>>>>> conclusively proves that Infinite_Loop never halts.
>>>>
>>>> Thus, your "encodings" are actually "encodings" but different actaul
>>>> implementations of a generic algorithm.
>>>>
>>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>>
>>>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>>>> variations on a generic algorithm is actually a SET OF DIFFERENT
>>>> DECIDERS.
>>>>
>>>> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
>>>> deciders since they implement a different computaiton giving
>>>> different results for the same input.
>>>>
>>>>>
>>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>>
>>>>> *complete halt deciding system including*
>>>>> *(a) x86utm operating system*
>>>>> *(b) complete x86 emulator*
>>>>> *(c) All of the various halt deciders and their inputs are
>>>>> contained in Halt7.c*
>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>
>>>>> This system currently only compiles under:
>>>>> Microsoft Visual Studio Community 2017
>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>
>>>>>
>>>>>
>>>>
>>>> And note, that H0 is just a SPEICIIFIC implementation of your
>>>> generic set you are talking about, and doesn't meet your
>>>> requirements, as it never completely simulatutes its input, so it
>>>> hasn't proven by its complete simulation of the input that it is
>>>> non-halting.
>>>>
>>>> (It may be correct about that input being non-halting by the actual
>>>> definition, but it shows the problem with YOUR definition, as there
>>>> is no H0 that is that H0 that does the required complete simulation,
>>>> just as there NEVER is for any of your deciders that give a
>>>> non-halting answer.
>>>
>>> So you consistently fail to comprehend the idea of non-halting
>>> behavior patterns that accurately predict the behavior of complete
>>> simulations?
>>>
>>
>> They CAN exist, but your definition doesn't allow for their use, as
>> you are defining that only the correct and complete simulation by the
>> decider counts.
>>
>
> A simulating halt decider correctly matches a correct non-halting
> behavior pattern in a finite number of steps such that it correctly
> determines that if it did perform a correct and complete simulation of
> its input that this simulation would never stop running.
>

On 9/16/2022 7:30 PM, Richard Damon wrote:
>
> On 9/16/22 8:21 PM, olcott wrote:
>> On 9/16/2022 7:06 PM, Richard Damon wrote:
>>> On 9/16/22 7:45 PM, olcott wrote:
>>>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/16/22 7:12 PM, olcott wrote:
>>>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You have to carefully study every single word that I
>>>>>>>>>>>>>>>>>> said and then you will see that Hx/Px pairs include an
>>>>>>>>>>>>>>>>>> infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their
>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A subset of these are the elements of Px fully simulated
>>>>>>>>>>>>>>>> by Hx.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and that subset that is fully simulated is
>>>>>>>>>>>>>>> PRECISELY the subset based on Hx's that don't abort.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When every simulating halt decider bases its halt status
>>>>>>>>>>>>>>>> decision on whether or not it must abort the simulation
>>>>>>>>>>>>>>>> of its input to prevent infinite simulation then every
>>>>>>>>>>>>>>>> Hx that returns 0 is correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset
>>>>>>>>>>>>>>> that you showed create Px's that were completely
>>>>>>>>>>>>>>> simulated to show non-halting, so you have ZERO proof
>>>>>>>>>>>>>>> that its input is non-halting
>>>>>>>>>>>>>> If that reasoning was valid then it would apply equally to
>>>>>>>>>>>>>> this:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not
>>>>>>>>>>>>> noticing that you are actually applying some logic to see
>>>>>>>>>>>>> that Infinite_Loop wouldn't go on forever, so the halting
>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>> OK so you have proven that you are unequivocally a liar when
>>>>>>>>>>>> you say that an infinite loop does not go on forever.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>>>
>>>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>>>
>>>>>>>>>>> I said that you have no copy of H0 that simulates that input
>>>>>>>>>>> forever, not that IS the same compuation as H0, as implied by
>>>>>>>>>>> your definition,
>>>>>>>>>>
>>>>>>>>>> So you agree that H0 correctly determines that its simulation
>>>>>>>>>> of Infinite_Loop would never stop running if this simulation
>>>>>>>>>> was never aborted?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>>>
>>>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> There are only two mutually exclusive categories for every
>>>>>>>> possible behavior of elements of the infinite set of encodings
>>>>>>>> of H0 where H0 correctly simulates its input:
>>>>>>>
>>>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but
>>>>>>> sets of them?
>>>>>>>
>>>>>>> That means you don't understand what a computation is. Or even
>>>>>>> what a computater program is.
>>>>>>>
>>>>>>>
>>>>>>>> (a) Abort the simulation of its input some point.
>>>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>>>
>>>>>>> Right, so which ONE is H0?
>>>>>>>
>>>>>>> Please write a program that represents this SET.
>>>>>>>
>>>>>>> You clearly don't understand what a PROGRAM is.
>>>>>>>
>>>>>>>>
>>>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>>>> correct infinite behavior pattern that correctly determines the
>>>>>>>> actual behavior of every element of set (b).
>>>>>>>>
>>>>>>>
>>>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>>>
>>>>>>
>>>>>> Did I stutter?
>>>>>
>>>>> No, apparently you are just lying or proving your stupidity.
>>>>>
>>>>> You just don't know what a computation is, so what is required for
>>>>> something to be a decider.
>>>>>
>>>>>> Every element of the set of encodings of H0 that returns 0
>>>>>> correctly determines the halt status of Infinite_Loop for every
>>>>>> possible encoding of H0 that correctly and completely simulates
>>>>>> Infinite_Loop.
>>>>>
>>>>> All "Encodings" of a given algorithm must behave the same, if all
>>>>> that is varying is the "Encoding" (the symbolic representation of
>>>>> the operations) and not the actual operations that are performed.
>>>>>
>>>>> Maybe you don't understand what an encoding is. I dop remember you
>>>>> dropping out of that class before you got to it.
>>>>>
>>>>>>
>>>>>> A subset of these encodings of H0 that return 0 do so on the basis
>>>>>> of correctly matching a correct infinite behavior pattern that
>>>>>> conclusively proves that Infinite_Loop never halts.
>>>>>
>>>>> Thus, your "encodings" are actually "encodings" but different
>>>>> actaul implementations of a generic algorithm.
>>>>>
>>>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>>>
>>>>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>>>>> variations on a generic algorithm is actually a SET OF DIFFERENT
>>>>> DECIDERS.
>>>>>
>>>>> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
>>>>> deciders since they implement a different computaiton giving
>>>>> different results for the same input.
>>>>>
>>>>>>
>>>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>>>
>>>>>> *complete halt deciding system including*
>>>>>> *(a) x86utm operating system*
>>>>>> *(b) complete x86 emulator*
>>>>>> *(c) All of the various halt deciders and their inputs are
>>>>>> contained in Halt7.c*
>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>
>>>>>> This system currently only compiles under:
>>>>>> Microsoft Visual Studio Community 2017
>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> And note, that H0 is just a SPEICIIFIC implementation of your
>>>>> generic set you are talking about, and doesn't meet your
>>>>> requirements, as it never completely simulatutes its input, so it
>>>>> hasn't proven by its complete simulation of the input that it is
>>>>> non-halting.
>>>>>
>>>>> (It may be correct about that input being non-halting by the actual
>>>>> definition, but it shows the problem with YOUR definition, as there
>>>>> is no H0 that is that H0 that does the required complete
>>>>> simulation, just as there NEVER is for any of your deciders that
>>>>> give a non-halting answer.
>>>>
>>>> So you consistently fail to comprehend the idea of non-halting
>>>> behavior patterns that accurately predict the behavior of complete
>>>> simulations?
>>>>
>>>
>>> They CAN exist, but your definition doesn't allow for their use, as
>>> you are defining that only the correct and complete simulation by the
>>> decider counts.
>>>
>>
>> A simulating halt decider correctly matches a correct non-halting
>> behavior pattern in a finite number of steps such that it correctly
>> determines that if it did perform a correct and complete simulation of
>> its input that this simulation would never stop running.
>>
>
> But there is no pattern in the simulation of the input to H(P,P) to
> match in a finite number of steps, so your H can't "correctly determine"
> that the input is non-halting.
>
When simulating halt decider HH(Px,Px) simulates its input it can see that:
(1) Function HH(Px,Px) is called twice in sequence from the same machine
address of Px().
(2) With the same arguments to HH(Px,Px).
(3) With no control flow instructions between the invocation of Px() and
its call to HH(Px,Px) that could possibly escape repeated simulations.

On Friday, September 16, 2022 at 12:36:09 PM UTC-7, olcott wrote:
> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
> > On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
> >> void Px(ptr x)
> >> {
> >> int Halt_Status = Hx(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", Hx(Px, Px));
> >> }
> >>
> > This means nothing without a definition of Hx
> > Once again - what are you trying to prove?
> You have to carefully study every single word that I said and then you
> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>
You're assuming something that is not written here. You haven't
defined Hx/Px pairs. What are you assuming?

All Hx has to do is return a non-zero int and Px never returns.
Or, contrapostively, If PX returns Hx returns 0
So what?

On 9/16/2022 7:58 PM, dklei...@gmail.com wrote:
> On Friday, September 16, 2022 at 12:36:09 PM UTC-7, olcott wrote:
>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>> void Px(ptr x)
>>>> {
>>>> int Halt_Status = Hx(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>> }
>>>>
>>> This means nothing without a definition of Hx
>>> Once again - what are you trying to prove?
>> You have to carefully study every single word that I said and then you
>> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>>
> You're assuming something that is not written here. You haven't
> defined Hx/Px pairs. What are you assuming?

It is written in the part that you chopped out:

On 9/16/2022 11:17 AM, olcott wrote:
> *Understanding the above code proves this*
> There are zero elements of infinite set of Hx/Px pairs such that the
> correct *partial or complete* simulation of Px by Hx reaches the final
> state of Px.
>
> *THIS LOGICALLY FOLLOWS (as a subset) FROM ABOVE*
> (A) Every element of the infinite set of Hx/Px pairs that does
> a correct
> and complete simulation of its input never reaches the final state of
> this input.
>
> *THIS IS THE DEFINITION OF A UTM THUS KNOWN TO BE TRUE*
> (B) A correct and complete simulation of Px by Hx derives the actual
> behavior of Px.
>
> *THIS LOGICALLY FOLLOWS FROM (A) AND (B) PREMISES*
> (C) The actual behavior of this input never reaches the final state of
> this input.
>
> When the criteria for a simulating halt decider (SHD) is to correctly
> predict that its complete and correct simulation of its input would
> never reach the final state of this simulated input then:

>
> All Hx has to do is return a non-zero int and Px never returns.
> Or, contrapostively, If PX returns Hx returns 0
> So what?

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

On Fri, 16 Sep 2022 18:37:03 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/16/2022 6:09 PM, Mr Flibble wrote:
> > On Fri, 16 Sep 2022 11:17:18 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> void Px(ptr x)
> >> {
> >> int Halt_Status = Hx(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", Hx(Px, Px));
> >> }
> >>
> >> *Understanding the above code proves this*
> >> There are zero elements of infinite set of Hx/Px pairs such that
> >> the correct *partial or complete* simulation of Px by Hx reaches
> >> the final state of Px.
> >
> > Your Hx gives an incorrect halting decision if Px is rewritten as:
> >
> > void Px(ptr x)
> > {
> > int Halt_Status = Hx(x, x);
> > (void)Halt_Status;
> > return;
> > }
> >
> > It is patently obvious to everyone except you that if Hx is a valid
> > halt decider then it must return a value to Px meaning Px will then
> > halt. Your Hx gives a halting decision of non-halting which is
> > erroneous.
> >
> > /Flibble
> >
>
> Why are you deliberately cross-posting when follow-up is explicitly
> set of comp.theory?

I am deliberately cross-posting to the same newsgroups that you
originally posted to which to me seems entirely appropriate, and I have
done so again; if you don't like it then you shouldn't cross-post in
the first place.

>
> When my pure function halt decider determines the halt status of the
> above input it aborts this input before the call to itself is even
> executed.
>
> If you believe that a function that was never even executed must
> return a value then you must be nuts.
>
> If you can't see that the return value from Hx is unreachable from
> the correctly simulated Px then you must be incompetent.

A correct simulation of Px would show that Px halts: your simulation
is incorrect because your halting decider is broken.

/Flibble

On 9/16/2022 8:06 PM, Mr Flibble wrote:
> On Fri, 16 Sep 2022 18:37:03 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/16/2022 6:09 PM, Mr Flibble wrote:
>>> On Fri, 16 Sep 2022 11:17:18 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> void Px(ptr x)
>>>> {
>>>> int Halt_Status = Hx(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>> }
>>>>
>>>> *Understanding the above code proves this*
>>>> There are zero elements of infinite set of Hx/Px pairs such that
>>>> the correct *partial or complete* simulation of Px by Hx reaches
>>>> the final state of Px.
>>>
>>> Your Hx gives an incorrect halting decision if Px is rewritten as:
>>>
>>> void Px(ptr x)
>>> {
>>> int Halt_Status = Hx(x, x);
>>> (void)Halt_Status;
>>> return;
>>> }
>>>
>>> It is patently obvious to everyone except you that if Hx is a valid
>>> halt decider then it must return a value to Px meaning Px will then
>>> halt. Your Hx gives a halting decision of non-halting which is
>>> erroneous.
>>>
>>> /Flibble
>>>
>>
>> Why are you deliberately cross-posting when follow-up is explicitly
>> set of comp.theory?
>
> I am deliberately cross-posting to the same newsgroups that you
> originally posted to which to me seems entirely appropriate, and I have
> done so again; if you don't like it then you shouldn't cross-post in
> the first place.
>
Since you have been made fully aware that extensive cross-posting to
these groups can permanently kill these groups you are a spiteful jackass.

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

On 9/16/22 8:50 PM, olcott wrote:
> On 9/16/2022 7:30 PM, Richard Damon wrote:
>>
>> On 9/16/22 8:21 PM, olcott wrote:
>>> On 9/16/2022 7:06 PM, Richard Damon wrote:
>>>> On 9/16/22 7:45 PM, olcott wrote:
>>>>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/16/22 7:12 PM, olcott wrote:
>>>>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You have to carefully study every single word that I
>>>>>>>>>>>>>>>>>>> said and then you will see that Hx/Px pairs include
>>>>>>>>>>>>>>>>>>> an infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their
>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A subset of these are the elements of Px fully
>>>>>>>>>>>>>>>>> simulated by Hx.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, and that subset that is fully simulated is
>>>>>>>>>>>>>>>> PRECISELY the subset based on Hx's that don't abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When every simulating halt decider bases its halt
>>>>>>>>>>>>>>>>> status decision on whether or not it must abort the
>>>>>>>>>>>>>>>>> simulation of its input to prevent infinite simulation
>>>>>>>>>>>>>>>>> then every Hx that returns 0 is correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset
>>>>>>>>>>>>>>>> that you showed create Px's that were completely
>>>>>>>>>>>>>>>> simulated to show non-halting, so you have ZERO proof
>>>>>>>>>>>>>>>> that its input is non-halting
>>>>>>>>>>>>>>> If that reasoning was valid then it would apply equally
>>>>>>>>>>>>>>> to this:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not
>>>>>>>>>>>>>> noticing that you are actually applying some logic to see
>>>>>>>>>>>>>> that Infinite_Loop wouldn't go on forever, so the halting
>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> OK so you have proven that you are unequivocally a liar
>>>>>>>>>>>>> when you say that an infinite loop does not go on forever.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>>>>
>>>>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>>>>
>>>>>>>>>>>> I said that you have no copy of H0 that simulates that input
>>>>>>>>>>>> forever, not that IS the same compuation as H0, as implied
>>>>>>>>>>>> by your definition,
>>>>>>>>>>>
>>>>>>>>>>> So you agree that H0 correctly determines that its simulation
>>>>>>>>>>> of Infinite_Loop would never stop running if this simulation
>>>>>>>>>>> was never aborted?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>>>>
>>>>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> There are only two mutually exclusive categories for every
>>>>>>>>> possible behavior of elements of the infinite set of encodings
>>>>>>>>> of H0 where H0 correctly simulates its input:
>>>>>>>>
>>>>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but
>>>>>>>> sets of them?
>>>>>>>>
>>>>>>>> That means you don't understand what a computation is. Or even
>>>>>>>> what a computater program is.
>>>>>>>>
>>>>>>>>
>>>>>>>>> (a) Abort the simulation of its input some point.
>>>>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>>>>
>>>>>>>> Right, so which ONE is H0?
>>>>>>>>
>>>>>>>> Please write a program that represents this SET.
>>>>>>>>
>>>>>>>> You clearly don't understand what a PROGRAM is.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>>>>> correct infinite behavior pattern that correctly determines the
>>>>>>>>> actual behavior of every element of set (b).
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>>>>
>>>>>>>
>>>>>>> Did I stutter?
>>>>>>
>>>>>> No, apparently you are just lying or proving your stupidity.
>>>>>>
>>>>>> You just don't know what a computation is, so what is required for
>>>>>> something to be a decider.
>>>>>>
>>>>>>> Every element of the set of encodings of H0 that returns 0
>>>>>>> correctly determines the halt status of Infinite_Loop for every
>>>>>>> possible encoding of H0 that correctly and completely simulates
>>>>>>> Infinite_Loop.
>>>>>>
>>>>>> All "Encodings" of a given algorithm must behave the same, if all
>>>>>> that is varying is the "Encoding" (the symbolic representation of
>>>>>> the operations) and not the actual operations that are performed.
>>>>>>
>>>>>> Maybe you don't understand what an encoding is. I dop remember you
>>>>>> dropping out of that class before you got to it.
>>>>>>
>>>>>>>
>>>>>>> A subset of these encodings of H0 that return 0 do so on the
>>>>>>> basis of correctly matching a correct infinite behavior pattern
>>>>>>> that conclusively proves that Infinite_Loop never halts.
>>>>>>
>>>>>> Thus, your "encodings" are actually "encodings" but different
>>>>>> actaul implementations of a generic algorithm.
>>>>>>
>>>>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>>>>
>>>>>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>>>>>> variations on a generic algorithm is actually a SET OF DIFFERENT
>>>>>> DECIDERS.
>>>>>>
>>>>>> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
>>>>>> deciders since they implement a different computaiton giving
>>>>>> different results for the same input.
>>>>>>
>>>>>>>
>>>>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>>>>
>>>>>>> *complete halt deciding system including*
>>>>>>> *(a) x86utm operating system*
>>>>>>> *(b) complete x86 emulator*
>>>>>>> *(c) All of the various halt deciders and their inputs are
>>>>>>> contained in Halt7.c*
>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>
>>>>>>> This system currently only compiles under:
>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And note, that H0 is just a SPEICIIFIC implementation of your
>>>>>> generic set you are talking about, and doesn't meet your
>>>>>> requirements, as it never completely simulatutes its input, so it
>>>>>> hasn't proven by its complete simulation of the input that it is
>>>>>> non-halting.
>>>>>>
>>>>>> (It may be correct about that input being non-halting by the
>>>>>> actual definition, but it shows the problem with YOUR definition,
>>>>>> as there is no H0 that is that H0 that does the required complete
>>>>>> simulation, just as there NEVER is for any of your deciders that
>>>>>> give a non-halting answer.
>>>>>
>>>>> So you consistently fail to comprehend the idea of non-halting
>>>>> behavior patterns that accurately predict the behavior of complete
>>>>> simulations?
>>>>>
>>>>
>>>> They CAN exist, but your definition doesn't allow for their use, as
>>>> you are defining that only the correct and complete simulation by
>>>> the decider counts.
>>>>
>>>
>>> A simulating halt decider correctly matches a correct non-halting
>>> behavior pattern in a finite number of steps such that it correctly
>>> determines that if it did perform a correct and complete simulation
>>> of its input that this simulation would never stop running.
>>>
>>
>> But there is no pattern in the simulation of the input to H(P,P) to
>> match in a finite number of steps, so your H can't "correctly
>> determine" that the input is non-halting.
>>
> When simulating halt decider HH(Px,Px) simulates its input it can see that:
> (1) Function HH(Px,Px) is called twice in sequence from the same machine
> address of Px().
> (2) With the same arguments to HH(Px,Px).
> (3) With no control flow instructions between the invocation of Px() and
> its call to HH(Px,Px) that could possibly escape repeated simulations.
>

On 9/16/2022 8:29 PM, Richard Damon wrote:
> On 9/16/22 8:50 PM, olcott wrote:
>> On 9/16/2022 7:30 PM, Richard Damon wrote:
>>>
>>> On 9/16/22 8:21 PM, olcott wrote:
>>>> On 9/16/2022 7:06 PM, Richard Damon wrote:
>>>>> On 9/16/22 7:45 PM, olcott wrote:
>>>>>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/16/22 7:12 PM, olcott wrote:
>>>>>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You have to carefully study every single word that I
>>>>>>>>>>>>>>>>>>>> said and then you will see that Hx/Px pairs include
>>>>>>>>>>>>>>>>>>>> an infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx correctly
>>>>>>>>>>>>>>>>>>>> decides that Px never halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their
>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A subset of these are the elements of Px fully
>>>>>>>>>>>>>>>>>> simulated by Hx.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, and that subset that is fully simulated is
>>>>>>>>>>>>>>>>> PRECISELY the subset based on Hx's that don't abort.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When every simulating halt decider bases its halt
>>>>>>>>>>>>>>>>>> status decision on whether or not it must abort the
>>>>>>>>>>>>>>>>>> simulation of its input to prevent infinite simulation
>>>>>>>>>>>>>>>>>> then every Hx that returns 0 is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the subset
>>>>>>>>>>>>>>>>> that you showed create Px's that were completely
>>>>>>>>>>>>>>>>> simulated to show non-halting, so you have ZERO proof
>>>>>>>>>>>>>>>>> that its input is non-halting
>>>>>>>>>>>>>>>> If that reasoning was valid then it would apply equally
>>>>>>>>>>>>>>>> to this:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not
>>>>>>>>>>>>>>> noticing that you are actually applying some logic to see
>>>>>>>>>>>>>>> that Infinite_Loop wouldn't go on forever, so the halting
>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> OK so you have proven that you are unequivocally a liar
>>>>>>>>>>>>>> when you say that an infinite loop does not go on forever.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>>>>>
>>>>>>>>>>>>> I said that you have no copy of H0 that simulates that
>>>>>>>>>>>>> input forever, not that IS the same compuation as H0, as
>>>>>>>>>>>>> implied by your definition,
>>>>>>>>>>>>
>>>>>>>>>>>> So you agree that H0 correctly determines that its
>>>>>>>>>>>> simulation of Infinite_Loop would never stop running if this
>>>>>>>>>>>> simulation was never aborted?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>>>>>
>>>>>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> There are only two mutually exclusive categories for every
>>>>>>>>>> possible behavior of elements of the infinite set of encodings
>>>>>>>>>> of H0 where H0 correctly simulates its input:
>>>>>>>>>
>>>>>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation, but
>>>>>>>>> sets of them?
>>>>>>>>>
>>>>>>>>> That means you don't understand what a computation is. Or even
>>>>>>>>> what a computater program is.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>> (a) Abort the simulation of its input some point.
>>>>>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>>>>>
>>>>>>>>> Right, so which ONE is H0?
>>>>>>>>>
>>>>>>>>> Please write a program that represents this SET.
>>>>>>>>>
>>>>>>>>> You clearly don't understand what a PROGRAM is.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>>>>>> correct infinite behavior pattern that correctly determines
>>>>>>>>>> the actual behavior of every element of set (b).
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Did I stutter?
>>>>>>>
>>>>>>> No, apparently you are just lying or proving your stupidity.
>>>>>>>
>>>>>>> You just don't know what a computation is, so what is required
>>>>>>> for something to be a decider.
>>>>>>>
>>>>>>>> Every element of the set of encodings of H0 that returns 0
>>>>>>>> correctly determines the halt status of Infinite_Loop for every
>>>>>>>> possible encoding of H0 that correctly and completely simulates
>>>>>>>> Infinite_Loop.
>>>>>>>
>>>>>>> All "Encodings" of a given algorithm must behave the same, if all
>>>>>>> that is varying is the "Encoding" (the symbolic representation of
>>>>>>> the operations) and not the actual operations that are performed.
>>>>>>>
>>>>>>> Maybe you don't understand what an encoding is. I dop remember
>>>>>>> you dropping out of that class before you got to it.
>>>>>>>
>>>>>>>>
>>>>>>>> A subset of these encodings of H0 that return 0 do so on the
>>>>>>>> basis of correctly matching a correct infinite behavior pattern
>>>>>>>> that conclusively proves that Infinite_Loop never halts.
>>>>>>>
>>>>>>> Thus, your "encodings" are actually "encodings" but different
>>>>>>> actaul implementations of a generic algorithm.
>>>>>>>
>>>>>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>>>>>
>>>>>>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>>>>>>> variations on a generic algorithm is actually a SET OF DIFFERENT
>>>>>>> DECIDERS.
>>>>>>>
>>>>>>> Thus it IS correct that we have deciders H0a and H0b as DIFFERENT
>>>>>>> deciders since they implement a different computaiton giving
>>>>>>> different results for the same input.
>>>>>>>
>>>>>>>>
>>>>>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>>>>>
>>>>>>>> *complete halt deciding system including*
>>>>>>>> *(a) x86utm operating system*
>>>>>>>> *(b) complete x86 emulator*
>>>>>>>> *(c) All of the various halt deciders and their inputs are
>>>>>>>> contained in Halt7.c*
>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>
>>>>>>>> This system currently only compiles under:
>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And note, that H0 is just a SPEICIIFIC implementation of your
>>>>>>> generic set you are talking about, and doesn't meet your
>>>>>>> requirements, as it never completely simulatutes its input, so it
>>>>>>> hasn't proven by its complete simulation of the input that it is
>>>>>>> non-halting.
>>>>>>>
>>>>>>> (It may be correct about that input being non-halting by the
>>>>>>> actual definition, but it shows the problem with YOUR definition,
>>>>>>> as there is no H0 that is that H0 that does the required complete
>>>>>>> simulation, just as there NEVER is for any of your deciders that
>>>>>>> give a non-halting answer.
>>>>>>
>>>>>> So you consistently fail to comprehend the idea of non-halting
>>>>>> behavior patterns that accurately predict the behavior of complete
>>>>>> simulations?
>>>>>>
>>>>>
>>>>> They CAN exist, but your definition doesn't allow for their use, as
>>>>> you are defining that only the correct and complete simulation by
>>>>> the decider counts.
>>>>>
>>>>
>>>> A simulating halt decider correctly matches a correct non-halting
>>>> behavior pattern in a finite number of steps such that it correctly
>>>> determines that if it did perform a correct and complete simulation
>>>> of its input that this simulation would never stop running.
>>>>
>>>
>>> But there is no pattern in the simulation of the input to H(P,P) to
>>> match in a finite number of steps, so your H can't "correctly
>>> determine" that the input is non-halting.
>>>
>> When simulating halt decider HH(Px,Px) simulates its input it can see
>> that:
>> (1) Function HH(Px,Px) is called twice in sequence from the same
>> machine address of Px().
>> (2) With the same arguments to HH(Px,Px).
>> (3) With no control flow instructions between the invocation of Px()
>> and its call to HH(Px,Px) that could possibly escape repeated
>> simulations.
>>
>
> And that isn't proof of Non-Halting. Care to try to actually show a
> reliable reference that claims it is (not from you()
>
Anyone that fully understands it understands that it is essentially the
same proof that correctly detects infinite recursion. I am not giving up
on you because you did recently correctly understand and acknowledge a
key element of another proof.

On 9/16/22 9:55 PM, olcott wrote:
> On 9/16/2022 8:29 PM, Richard Damon wrote:
>> On 9/16/22 8:50 PM, olcott wrote:
>>> On 9/16/2022 7:30 PM, Richard Damon wrote:
>>>>
>>>> On 9/16/22 8:21 PM, olcott wrote:
>>>>> On 9/16/2022 7:06 PM, Richard Damon wrote:
>>>>>> On 9/16/22 7:45 PM, olcott wrote:
>>>>>>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/16/22 7:12 PM, olcott wrote:
>>>>>>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>>>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You have to carefully study every single word that
>>>>>>>>>>>>>>>>>>>>> I said and then you will see that Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>> include an infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx
>>>>>>>>>>>>>>>>>>>>> correctly decides that Px never halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their
>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A subset of these are the elements of Px fully
>>>>>>>>>>>>>>>>>>> simulated by Hx.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, and that subset that is fully simulated is
>>>>>>>>>>>>>>>>>> PRECISELY the subset based on Hx's that don't abort.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When every simulating halt decider bases its halt
>>>>>>>>>>>>>>>>>>> status decision on whether or not it must abort the
>>>>>>>>>>>>>>>>>>> simulation of its input to prevent infinite
>>>>>>>>>>>>>>>>>>> simulation then every Hx that returns 0 is correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the
>>>>>>>>>>>>>>>>>> subset that you showed create Px's that were
>>>>>>>>>>>>>>>>>> completely simulated to show non-halting, so you have
>>>>>>>>>>>>>>>>>> ZERO proof that its input is non-halting
>>>>>>>>>>>>>>>>> If that reasoning was valid then it would apply equally
>>>>>>>>>>>>>>>>> to this:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not
>>>>>>>>>>>>>>>> noticing that you are actually applying some logic to
>>>>>>>>>>>>>>>> see that Infinite_Loop wouldn't go on forever, so the
>>>>>>>>>>>>>>>> halting is correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OK so you have proven that you are unequivocally a liar
>>>>>>>>>>>>>>> when you say that an infinite loop does not go on forever.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I said that you have no copy of H0 that simulates that
>>>>>>>>>>>>>> input forever, not that IS the same compuation as H0, as
>>>>>>>>>>>>>> implied by your definition,
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you agree that H0 correctly determines that its
>>>>>>>>>>>>> simulation of Infinite_Loop would never stop running if
>>>>>>>>>>>>> this simulation was never aborted?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>>>>>>
>>>>>>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> There are only two mutually exclusive categories for every
>>>>>>>>>>> possible behavior of elements of the infinite set of
>>>>>>>>>>> encodings of H0 where H0 correctly simulates its input:
>>>>>>>>>>
>>>>>>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation,
>>>>>>>>>> but sets of them?
>>>>>>>>>>
>>>>>>>>>> That means you don't understand what a computation is. Or even
>>>>>>>>>> what a computater program is.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> (a) Abort the simulation of its input some point.
>>>>>>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>>>>>>
>>>>>>>>>> Right, so which ONE is H0?
>>>>>>>>>>
>>>>>>>>>> Please write a program that represents this SET.
>>>>>>>>>>
>>>>>>>>>> You clearly don't understand what a PROGRAM is.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>>>>>>> correct infinite behavior pattern that correctly determines
>>>>>>>>>>> the actual behavior of every element of set (b).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Did I stutter?
>>>>>>>>
>>>>>>>> No, apparently you are just lying or proving your stupidity.
>>>>>>>>
>>>>>>>> You just don't know what a computation is, so what is required
>>>>>>>> for something to be a decider.
>>>>>>>>
>>>>>>>>> Every element of the set of encodings of H0 that returns 0
>>>>>>>>> correctly determines the halt status of Infinite_Loop for every
>>>>>>>>> possible encoding of H0 that correctly and completely simulates
>>>>>>>>> Infinite_Loop.
>>>>>>>>
>>>>>>>> All "Encodings" of a given algorithm must behave the same, if
>>>>>>>> all that is varying is the "Encoding" (the symbolic
>>>>>>>> representation of the operations) and not the actual operations
>>>>>>>> that are performed.
>>>>>>>>
>>>>>>>> Maybe you don't understand what an encoding is. I dop remember
>>>>>>>> you dropping out of that class before you got to it.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> A subset of these encodings of H0 that return 0 do so on the
>>>>>>>>> basis of correctly matching a correct infinite behavior pattern
>>>>>>>>> that conclusively proves that Infinite_Loop never halts.
>>>>>>>>
>>>>>>>> Thus, your "encodings" are actually "encodings" but different
>>>>>>>> actaul implementations of a generic algorithm.
>>>>>>>>
>>>>>>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>>>>>>
>>>>>>>> A decider must be a SPECIFIC ALGORITHM, so your set of different
>>>>>>>> variations on a generic algorithm is actually a SET OF DIFFERENT
>>>>>>>> DECIDERS.
>>>>>>>>
>>>>>>>> Thus it IS correct that we have deciders H0a and H0b as
>>>>>>>> DIFFERENT deciders since they implement a different computaiton
>>>>>>>> giving different results for the same input.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>>>>>>
>>>>>>>>> *complete halt deciding system including*
>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>> *(c) All of the various halt deciders and their inputs are
>>>>>>>>> contained in Halt7.c*
>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>
>>>>>>>>> This system currently only compiles under:
>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And note, that H0 is just a SPEICIIFIC implementation of your
>>>>>>>> generic set you are talking about, and doesn't meet your
>>>>>>>> requirements, as it never completely simulatutes its input, so
>>>>>>>> it hasn't proven by its complete simulation of the input that it
>>>>>>>> is non-halting.
>>>>>>>>
>>>>>>>> (It may be correct about that input being non-halting by the
>>>>>>>> actual definition, but it shows the problem with YOUR
>>>>>>>> definition, as there is no H0 that is that H0 that does the
>>>>>>>> required complete simulation, just as there NEVER is for any of
>>>>>>>> your deciders that give a non-halting answer.
>>>>>>>
>>>>>>> So you consistently fail to comprehend the idea of non-halting
>>>>>>> behavior patterns that accurately predict the behavior of
>>>>>>> complete simulations?
>>>>>>>
>>>>>>
>>>>>> They CAN exist, but your definition doesn't allow for their use,
>>>>>> as you are defining that only the correct and complete simulation
>>>>>> by the decider counts.
>>>>>>
>>>>>
>>>>> A simulating halt decider correctly matches a correct non-halting
>>>>> behavior pattern in a finite number of steps such that it correctly
>>>>> determines that if it did perform a correct and complete simulation
>>>>> of its input that this simulation would never stop running.
>>>>>
>>>>
>>>> But there is no pattern in the simulation of the input to H(P,P) to
>>>> match in a finite number of steps, so your H can't "correctly
>>>> determine" that the input is non-halting.
>>>>
>>> When simulating halt decider HH(Px,Px) simulates its input it can see
>>> that:
>>> (1) Function HH(Px,Px) is called twice in sequence from the same
>>> machine address of Px().
>>> (2) With the same arguments to HH(Px,Px).
>>> (3) With no control flow instructions between the invocation of Px()
>>> and its call to HH(Px,Px) that could possibly escape repeated
>>> simulations.
>>>
>>
>> And that isn't proof of Non-Halting. Care to try to actually show a
>> reliable reference that claims it is (not from you()
>>
> Anyone that fully understands it understands that it is essentially the
> same proof that correctly detects infinite recursion. I am not giving up
> on you because you did recently correctly understand and acknowledge a
> key element of another proof.

On 9/16/2022 9:07 PM, Richard Damon wrote:
>
> On 9/16/22 9:55 PM, olcott wrote:
>> On 9/16/2022 8:29 PM, Richard Damon wrote:
>>> On 9/16/22 8:50 PM, olcott wrote:
>>>> On 9/16/2022 7:30 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/16/22 8:21 PM, olcott wrote:
>>>>>> On 9/16/2022 7:06 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 7:45 PM, olcott wrote:
>>>>>>>> On 9/16/2022 6:40 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/16/22 7:12 PM, olcott wrote:
>>>>>>>>>> On 9/16/2022 5:58 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/16/22 6:45 PM, olcott wrote:
>>>>>>>>>>>> On 9/16/2022 5:31 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/16/22 6:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/16/2022 4:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/16/22 5:42 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/16/2022 4:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/16/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/16/2022 4:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/16/22 4:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/16/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/16/22 3:36 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, September 16, 2022 at 9:17:21 AM
>>>>>>>>>>>>>>>>>>>>>>> UTC-7, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This means nothing without a definition of Hx
>>>>>>>>>>>>>>>>>>>>>>> Once again - what are you trying to prove?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You have to carefully study every single word that
>>>>>>>>>>>>>>>>>>>>>> I said and then you will see that Hx/Px pairs
>>>>>>>>>>>>>>>>>>>>>> include an infinite set of definitions of Hx.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have proved that for some Hx/Px pairs Hx
>>>>>>>>>>>>>>>>>>>>>> correctly decides that Px never halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, you have shown that SOME of the set of Px are
>>>>>>>>>>>>>>>>>>>>> non-halting,
>>>>>>>>>>>>>>>>>>>> I have proved that none of the partially or fully
>>>>>>>>>>>>>>>>>>>> simulated Px inputs simulated by Hx ever reach their
>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A subset of these are the elements of Px fully
>>>>>>>>>>>>>>>>>>>> simulated by Hx.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, and that subset that is fully simulated is
>>>>>>>>>>>>>>>>>>> PRECISELY the subset based on Hx's that don't abort.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When every simulating halt decider bases its halt
>>>>>>>>>>>>>>>>>>>> status decision on whether or not it must abort the
>>>>>>>>>>>>>>>>>>>> simulation of its input to prevent infinite
>>>>>>>>>>>>>>>>>>>> simulation then every Hx that returns 0 is correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But an Hx that DOES abort is not a member of the
>>>>>>>>>>>>>>>>>>> subset that you showed create Px's that were
>>>>>>>>>>>>>>>>>>> completely simulated to show non-halting, so you have
>>>>>>>>>>>>>>>>>>> ZERO proof that its input is non-halting
>>>>>>>>>>>>>>>>>> If that reasoning was valid then it would apply
>>>>>>>>>>>>>>>>>> equally to this:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, it applies there. The issue is that YOU are not
>>>>>>>>>>>>>>>>> noticing that you are actually applying some logic to
>>>>>>>>>>>>>>>>> see that Infinite_Loop wouldn't go on forever, so the
>>>>>>>>>>>>>>>>> halting is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OK so you have proven that you are unequivocally a liar
>>>>>>>>>>>>>>>> when you say that an infinite loop does not go on forever.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WHERE DID I SAY THAT?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Seems to be that YOU are the one lying,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I said that you have no copy of H0 that simulates that
>>>>>>>>>>>>>>> input forever, not that IS the same compuation as H0, as
>>>>>>>>>>>>>>> implied by your definition,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you agree that H0 correctly determines that its
>>>>>>>>>>>>>> simulation of Infinite_Loop would never stop running if
>>>>>>>>>>>>>> this simulation was never aborted?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The conclusion is correct but the wording is illogical.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H0 either does or does not abort its simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> There are only two mutually exclusive categories for every
>>>>>>>>>>>> possible behavior of elements of the infinite set of
>>>>>>>>>>>> encodings of H0 where H0 correctly simulates its input:
>>>>>>>>>>>
>>>>>>>>>>> So, your Simulationg Halt Deciders ARENT'T *A* Computation,
>>>>>>>>>>> but sets of them?
>>>>>>>>>>>
>>>>>>>>>>> That means you don't understand what a computation is. Or
>>>>>>>>>>> even what a computater program is.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> (a) Abort the simulation of its input some point.
>>>>>>>>>>>> (b) Never abort the simulation of its input at any point.
>>>>>>>>>>>
>>>>>>>>>>> Right, so which ONE is H0?
>>>>>>>>>>>
>>>>>>>>>>> Please write a program that represents this SET.
>>>>>>>>>>>
>>>>>>>>>>> You clearly don't understand what a PROGRAM is.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When H0 returns 0 it does this based on correctly matching a
>>>>>>>>>>>> correct infinite behavior pattern that correctly determines
>>>>>>>>>>>> the actual behavior of every element of set (b).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, appearently you have TWO DIFFERENT H0's, H0a, an H0b.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Did I stutter?
>>>>>>>>>
>>>>>>>>> No, apparently you are just lying or proving your stupidity.
>>>>>>>>>
>>>>>>>>> You just don't know what a computation is, so what is required
>>>>>>>>> for something to be a decider.
>>>>>>>>>
>>>>>>>>>> Every element of the set of encodings of H0 that returns 0
>>>>>>>>>> correctly determines the halt status of Infinite_Loop for
>>>>>>>>>> every possible encoding of H0 that correctly and completely
>>>>>>>>>> simulates Infinite_Loop.
>>>>>>>>>
>>>>>>>>> All "Encodings" of a given algorithm must behave the same, if
>>>>>>>>> all that is varying is the "Encoding" (the symbolic
>>>>>>>>> representation of the operations) and not the actual operations
>>>>>>>>> that are performed.
>>>>>>>>>
>>>>>>>>> Maybe you don't understand what an encoding is. I dop remember
>>>>>>>>> you dropping out of that class before you got to it.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> A subset of these encodings of H0 that return 0 do so on the
>>>>>>>>>> basis of correctly matching a correct infinite behavior
>>>>>>>>>> pattern that conclusively proves that Infinite_Loop never halts.
>>>>>>>>>
>>>>>>>>> Thus, your "encodings" are actually "encodings" but different
>>>>>>>>> actaul implementations of a generic algorithm.
>>>>>>>>>
>>>>>>>>> Thus you have a set of SPECIIF ALGORITHMS.
>>>>>>>>>
>>>>>>>>> A decider must be a SPECIFIC ALGORITHM, so your set of
>>>>>>>>> different variations on a generic algorithm is actually a SET
>>>>>>>>> OF DIFFERENT DECIDERS.
>>>>>>>>>
>>>>>>>>> Thus it IS correct that we have deciders H0a and H0b as
>>>>>>>>> DIFFERENT deciders since they implement a different computaiton
>>>>>>>>> giving different results for the same input.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *H0 and Infinite_loop are contained within halt7.c*
>>>>>>>>>>
>>>>>>>>>> *complete halt deciding system including*
>>>>>>>>>> *(a) x86utm operating system*
>>>>>>>>>> *(b) complete x86 emulator*
>>>>>>>>>> *(c) All of the various halt deciders and their inputs are
>>>>>>>>>> contained in Halt7.c*
>>>>>>>>>> https://liarparadox.org/2022_09_07.zip
>>>>>>>>>>
>>>>>>>>>> This system currently only compiles under:
>>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And note, that H0 is just a SPEICIIFIC implementation of your
>>>>>>>>> generic set you are talking about, and doesn't meet your
>>>>>>>>> requirements, as it never completely simulatutes its input, so
>>>>>>>>> it hasn't proven by its complete simulation of the input that
>>>>>>>>> it is non-halting.
>>>>>>>>>
>>>>>>>>> (It may be correct about that input being non-halting by the
>>>>>>>>> actual definition, but it shows the problem with YOUR
>>>>>>>>> definition, as there is no H0 that is that H0 that does the
>>>>>>>>> required complete simulation, just as there NEVER is for any of
>>>>>>>>> your deciders that give a non-halting answer.
>>>>>>>>
>>>>>>>> So you consistently fail to comprehend the idea of non-halting
>>>>>>>> behavior patterns that accurately predict the behavior of
>>>>>>>> complete simulations?
>>>>>>>>
>>>>>>>
>>>>>>> They CAN exist, but your definition doesn't allow for their use,
>>>>>>> as you are defining that only the correct and complete simulation
>>>>>>> by the decider counts.
>>>>>>>
>>>>>>
>>>>>> A simulating halt decider correctly matches a correct non-halting
>>>>>> behavior pattern in a finite number of steps such that it
>>>>>> correctly determines that if it did perform a correct and complete
>>>>>> simulation of its input that this simulation would never stop
>>>>>> running.
>>>>>>
>>>>>
>>>>> But there is no pattern in the simulation of the input to H(P,P) to
>>>>> match in a finite number of steps, so your H can't "correctly
>>>>> determine" that the input is non-halting.
>>>>>
>>>> When simulating halt decider HH(Px,Px) simulates its input it can
>>>> see that:
>>>> (1) Function HH(Px,Px) is called twice in sequence from the same
>>>> machine address of Px().
>>>> (2) With the same arguments to HH(Px,Px).
>>>> (3) With no control flow instructions between the invocation of Px()
>>>> and its call to HH(Px,Px) that could possibly escape repeated
>>>> simulations.
>>>>
>>>
>>> And that isn't proof of Non-Halting. Care to try to actually show a
>>> reliable reference that claims it is (not from you()
>>>
>> Anyone that fully understands it understands that it is essentially
>> the same proof that correctly detects infinite recursion. I am not
>> giving up on you because you did recently correctly understand and
>> acknowledge a key element of another proof.
>
> No, it isn't, because it omits a key part of the code.
>
> You are "essentially" showing youself to be a total idiot and clueless
> about what you are talking about.
>
> Since P(P) Halts, it CAN'T be correct and you show your lack of
> intelegence in thinking that it could be.
>
>
>>
>> H: Begin Simulation   Execution Trace Stored at:111fe5
>> [000010f2][00111fd1][00111fd5] 55         push ebp
>> [000010f3][00111fd1][00111fd5] 8bec       mov ebp,esp
>> [000010f5][00111fd1][00111fd5] 8b4508     mov eax,[ebp+08]
>> [000010f8][00111fcd][00000777] 50         push eax      // push 0x777
>> [000010f9][00111fc9][000010fe] e8f4ffffff call 000010f2 // call
>> Infinite_Recursion
>> [000010f2][00111fc5][00111fd1] 55         push ebp
>> [000010f3][00111fc5][00111fd1] 8bec       mov ebp,esp
>> [000010f5][00111fc5][00111fd1] 8b4508     mov eax,[ebp+08]
>> [000010f8][00111fc1][00000777] 50         push eax      // push 0x777
>> [000010f9][00111fbd][000010fe] e8f4ffffff call 000010f2 // call
>> Infinite_Recursion
>> H: Infinite Recursion Detected Simulation Stopped
>>
>> (1) Infinite_Recursion() is called twice in sequence from the same
>> machine address of Infinite_Recursion() .
>> (2) With the same arguments to Infinite_Recursion()
>> (3) With no control flow instructions between the invocation of
>> Infinite_Recursion() and the call to Infinite_Recursion() from
>> Infinite_Recursion()
>>
>>
>>
>
> FALLACY OF PROOF BY EXAMPLES.
>
> PROOF OF YOUR STUPIDITY.
>
> FAIL.