On 9/17/22 11:07 AM, olcott wrote:
> On 9/17/2022 6:06 AM, Richard Damon wrote:
>> On 9/17/22 12:15 AM, olcott wrote:
>>> On 9/16/2022 10:56 PM, Richard Damon wrote:
>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>> 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.
>>>>>>>
>>>>>>> A proof by example (over generalization) is not a fallacy when it
>>>>>>> includes the infinite set of every possible example. In this case
>>>>>>> it becomes categorically exhaustive reasoning (CAR)**.
>>>>>>
>>>>>> Really? Your ONE example is infinite?
>>>>>>
>>>>>> Even showing an infinte number of examples isn't exahustive since
>>>>>> we can show an infintie number of cases you did NOT look at.
>>>>>
>>>>> You did not pay enough attention, here is what I said:
>>>>> *the infinite set of every possible example*
>>>>>
>>>>> We can know that every integer > 5 is also > 3 without checking
>>>>> each one.
>>>>>
>>>>>>>
>>>>>>> The above infinite recursion criteria has zero false positives
>>>>>>> across the infinite set of every instance of infinite recursion.
>>>>>>>
>>>>>>
>>>>>> WRONG. If fails on P(P).
>>>>> int Hx(ptr x, ptr y)
>>>>> {
>>>>>    x(y); // is P(P) when Hx(P,P) is invoked.
>>>>> }
>>>>>
>>>>> The above Hx is one element of the infinite set of Hx/Px pairs.
>>>>
>>>> But not the one that *THE* P calls, you know, the one that calls the
>>>> H that is supposed to get the right answer.
>>>>
>>>
>>> The above one is the one that Hx must report on.
>>>
>>>>>
>>>>>
>>>>> Because you agreed with a key point recently I am confident that we
>>>>> can have an actual honest dialogue.
>>>>>
>>>>
>>>> Only if you are willing to change an be HONEST.
>>>>
>>>
>>> I have always been honest.
>>> Even in the case that Ben pointed out when I claimed that I had two
>>> Turing machines and instead had something computationally equivalent
>>> to two Turing machines. In other words for all practical purposes I
>>> did have two Turing machines, thus close enough.
>>>
>>>> So far it has just been me pointing out your stupid mistakes.
>>>>
>>>
>>> All of my recent "stupid mistakes" are merely your lack of
>>> comprehension of my difficult ideas.
>>>
>>>>
>>>> Remember, Programs/Machines don't call/use "Sets" of program/machines.
>>>>
>>>
>>> Set theory is how categorically exhaustive reasoning is applied.
>>>
>>> If all X are Y then anything that says all X are Y is necessarily
>>> correct. (All male humans are humans).
>>>
>>> If all correct and complete simulations of Px by Hx never halt then
>>> when some Hx returns 0 meaning that all correct and complete
>>> simulations of Px by Hx never halt then these instances of Hx are
>>> necessarily correct.
>>>
>>>
>>
>> But the sub-set of all correct and complete simulations is NOT the
>> same as the set of all simulations of Px, so you haven't shown that
>> ALL Px will be non-halting.
>
> We began with all of the *partial or complete* simulations of Px by Hx

On 9/17/2022 11:24 AM, Richard Damon wrote:
>
> On 9/17/22 11:07 AM, olcott wrote:
>> On 9/17/2022 6:06 AM, Richard Damon wrote:
>>> On 9/17/22 12:15 AM, olcott wrote:
>>>> On 9/16/2022 10:56 PM, Richard Damon wrote:
>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>>
>>>>>>>> A proof by example (over generalization) is not a fallacy when
>>>>>>>> it includes the infinite set of every possible example. In this
>>>>>>>> case it becomes categorically exhaustive reasoning (CAR)**.
>>>>>>>
>>>>>>> Really? Your ONE example is infinite?
>>>>>>>
>>>>>>> Even showing an infinte number of examples isn't exahustive since
>>>>>>> we can show an infintie number of cases you did NOT look at.
>>>>>>
>>>>>> You did not pay enough attention, here is what I said:
>>>>>> *the infinite set of every possible example*
>>>>>>
>>>>>> We can know that every integer > 5 is also > 3 without checking
>>>>>> each one.
>>>>>>
>>>>>>>>
>>>>>>>> The above infinite recursion criteria has zero false positives
>>>>>>>> across the infinite set of every instance of infinite recursion.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG. If fails on P(P).
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>>    x(y); // is P(P) when Hx(P,P) is invoked.
>>>>>> }
>>>>>>
>>>>>> The above Hx is one element of the infinite set of Hx/Px pairs.
>>>>>
>>>>> But not the one that *THE* P calls, you know, the one that calls
>>>>> the H that is supposed to get the right answer.
>>>>>
>>>>
>>>> The above one is the one that Hx must report on.
>>>>
>>>>>>
>>>>>>
>>>>>> Because you agreed with a key point recently I am confident that
>>>>>> we can have an actual honest dialogue.
>>>>>>
>>>>>
>>>>> Only if you are willing to change an be HONEST.
>>>>>
>>>>
>>>> I have always been honest.
>>>> Even in the case that Ben pointed out when I claimed that I had two
>>>> Turing machines and instead had something computationally equivalent
>>>> to two Turing machines. In other words for all practical purposes I
>>>> did have two Turing machines, thus close enough.
>>>>
>>>>> So far it has just been me pointing out your stupid mistakes.
>>>>>
>>>>
>>>> All of my recent "stupid mistakes" are merely your lack of
>>>> comprehension of my difficult ideas.
>>>>
>>>>>
>>>>> Remember, Programs/Machines don't call/use "Sets" of program/machines.
>>>>>
>>>>
>>>> Set theory is how categorically exhaustive reasoning is applied.
>>>>
>>>> If all X are Y then anything that says all X are Y is necessarily
>>>> correct. (All male humans are humans).
>>>>
>>>> If all correct and complete simulations of Px by Hx never halt then
>>>> when some Hx returns 0 meaning that all correct and complete
>>>> simulations of Px by Hx never halt then these instances of Hx are
>>>> necessarily correct.
>>>>
>>>>
>>>
>>> But the sub-set of all correct and complete simulations is NOT the
>>> same as the set of all simulations of Px, so you haven't shown that
>>> ALL Px will be non-halting.
>>
>> We began with all of the *partial or complete* simulations of Px by Hx
>
> Which don't prove ANYTHING>
>
> PERIOD.
>
>>
>>  > *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.
>
> Which just proves they are POOP Deciders, not Halting Deciders.
>
> PERIOD.
>
>>
>> Then we took a subset of this set:
>>
>>  > *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.
>>  >
>
> And the subset that is proven to be non-halting contains ONLY those Px
> built on an Hx that does not abort.
>
> So ONLY that subset is proven non-halting.
>
> The subset of Hx that answer 0, has ZERO members in that subset, so you
> haven't established anything of what you claim.
>
> In fact, ALL the Px based on those Hx can be shown to be halting, so it
> is PROVED that ALL your Hx are wrong in one way of another, and thus the
> set of correct Simulating Halting Deciders is the EMPTY SET.
>
> FAIL.
>
>
>>>
>>> So you fail at knowing set theory too.
>>>
>>
>> No I just proved that you weren't paying enough attention.
>
> No, you are proving you don't know what you are talking about, as it
> fails to match the actual words you are using.
>
>
>>
>>> The subset of the Px shown to be non-halting is the sub-set of Px
>>> built on Hx's that don't abort
>>>
>>> Thus you haven't shown anything about a Px built on an Hx that does.
>>>
>>
>> No Px where 1 to ∞ instructions are correctly simulated by Hx reaches
>> its final state and halts, thus every Hx returning 0 correctly reports
>> this.
>>
>> This also correctly reports that no Px correctly and completely
>> simulated by Hx halts, thus every Hx returning 0 correctly reports this.
>
> Nope. Simulation of only a finite number of steps do not prove non-halting.
>
I have to give up on you because I have conclusively proved that there
are such things as non-halting behavior patterns that when correctly
matched do correctly predict that the simulation of the input never
stops running unless aborted and you simply ignore this proof.

On Saturday, September 17, 2022 at 4:07:40 PM UTC+1, olcott wrote:
> On 9/17/2022 6:06 AM, Richard Damon wrote:
> > On 9/17/22 12:15 AM, olcott wrote:
> >> On 9/16/2022 10:56 PM, Richard Damon wrote:
> >>> On 9/16/22 11:34 PM, olcott wrote:
> >>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
> >>>>>
> >>>>> On 9/16/22 10:17 PM, olcott wrote:
> >>>>>> 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.
> >>>>>>
> >>>>>> A proof by example (over generalization) is not a fallacy when it
> >>>>>> includes the infinite set of every possible example. In this case
> >>>>>> it becomes categorically exhaustive reasoning (CAR)**.
> >>>>>
> >>>>> Really? Your ONE example is infinite?
> >>>>>
> >>>>> Even showing an infinte number of examples isn't exahustive since
> >>>>> we can show an infintie number of cases you did NOT look at.
> >>>>
> >>>> You did not pay enough attention, here is what I said:
> >>>> *the infinite set of every possible example*
> >>>>
> >>>> We can know that every integer > 5 is also > 3 without checking each
> >>>> one.
> >>>>
> >>>>>>
> >>>>>> The above infinite recursion criteria has zero false positives
> >>>>>> across the infinite set of every instance of infinite recursion.
> >>>>>>
> >>>>>
> >>>>> WRONG. If fails on P(P).
> >>>> int Hx(ptr x, ptr y)
> >>>> {
> >>>> x(y); // is P(P) when Hx(P,P) is invoked.
> >>>> }
> >>>>
> >>>> The above Hx is one element of the infinite set of Hx/Px pairs.
> >>>
> >>> But not the one that *THE* P calls, you know, the one that calls the
> >>> H that is supposed to get the right answer.
> >>>
> >>
> >> The above one is the one that Hx must report on.
> >>
> >>>>
> >>>>
> >>>> Because you agreed with a key point recently I am confident that we
> >>>> can have an actual honest dialogue.
> >>>>
> >>>
> >>> Only if you are willing to change an be HONEST.
> >>>
> >>
> >> I have always been honest.
> >> Even in the case that Ben pointed out when I claimed that I had two
> >> Turing machines and instead had something computationally equivalent
> >> to two Turing machines. In other words for all practical purposes I
> >> did have two Turing machines, thus close enough.
> >>
> >>> So far it has just been me pointing out your stupid mistakes.
> >>>
> >>
> >> All of my recent "stupid mistakes" are merely your lack of
> >> comprehension of my difficult ideas.
> >>
> >>>
> >>> Remember, Programs/Machines don't call/use "Sets" of program/machines..
> >>>
> >>
> >> Set theory is how categorically exhaustive reasoning is applied.
> >>
> >> If all X are Y then anything that says all X are Y is necessarily
> >> correct. (All male humans are humans).
> >>
> >> If all correct and complete simulations of Px by Hx never halt then
> >> when some Hx returns 0 meaning that all correct and complete
> >> simulations of Px by Hx never halt then these instances of Hx are
> >> necessarily correct.
> >>
> >>
> >
> > But the sub-set of all correct and complete simulations is NOT the same
> > as the set of all simulations of Px, so you haven't shown that ALL Px
> > will be non-halting.
> We began with all of the *partial or complete* simulations of Px by Hx
> > *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.
> Then we took a subset of this set:
> > *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.
> >
> >
> > So you fail at knowing set theory too.
> >
> No I just proved that you weren't paying enough attention.

On 9/17/2022 12:03 PM, Paul N wrote:
> On Saturday, September 17, 2022 at 4:07:40 PM UTC+1, olcott wrote:
>> On 9/17/2022 6:06 AM, Richard Damon wrote:
>>> On 9/17/22 12:15 AM, olcott wrote:
>>>> On 9/16/2022 10:56 PM, Richard Damon wrote:
>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>> 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.
>>>>>>>>
>>>>>>>> A proof by example (over generalization) is not a fallacy when it
>>>>>>>> includes the infinite set of every possible example. In this case
>>>>>>>> it becomes categorically exhaustive reasoning (CAR)**.
>>>>>>>
>>>>>>> Really? Your ONE example is infinite?
>>>>>>>
>>>>>>> Even showing an infinte number of examples isn't exahustive since
>>>>>>> we can show an infintie number of cases you did NOT look at.
>>>>>>
>>>>>> You did not pay enough attention, here is what I said:
>>>>>> *the infinite set of every possible example*
>>>>>>
>>>>>> We can know that every integer > 5 is also > 3 without checking each
>>>>>> one.
>>>>>>
>>>>>>>>
>>>>>>>> The above infinite recursion criteria has zero false positives
>>>>>>>> across the infinite set of every instance of infinite recursion.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG. If fails on P(P).
>>>>>> int Hx(ptr x, ptr y)
>>>>>> {
>>>>>> x(y); // is P(P) when Hx(P,P) is invoked.
>>>>>> }
>>>>>>
>>>>>> The above Hx is one element of the infinite set of Hx/Px pairs.
>>>>>
>>>>> But not the one that *THE* P calls, you know, the one that calls the
>>>>> H that is supposed to get the right answer.
>>>>>
>>>>
>>>> The above one is the one that Hx must report on.
>>>>
>>>>>>
>>>>>>
>>>>>> Because you agreed with a key point recently I am confident that we
>>>>>> can have an actual honest dialogue.
>>>>>>
>>>>>
>>>>> Only if you are willing to change an be HONEST.
>>>>>
>>>>
>>>> I have always been honest.
>>>> Even in the case that Ben pointed out when I claimed that I had two
>>>> Turing machines and instead had something computationally equivalent
>>>> to two Turing machines. In other words for all practical purposes I
>>>> did have two Turing machines, thus close enough.
>>>>
>>>>> So far it has just been me pointing out your stupid mistakes.
>>>>>
>>>>
>>>> All of my recent "stupid mistakes" are merely your lack of
>>>> comprehension of my difficult ideas.
>>>>
>>>>>
>>>>> Remember, Programs/Machines don't call/use "Sets" of program/machines.
>>>>>
>>>>
>>>> Set theory is how categorically exhaustive reasoning is applied.
>>>>
>>>> If all X are Y then anything that says all X are Y is necessarily
>>>> correct. (All male humans are humans).
>>>>
>>>> If all correct and complete simulations of Px by Hx never halt then
>>>> when some Hx returns 0 meaning that all correct and complete
>>>> simulations of Px by Hx never halt then these instances of Hx are
>>>> necessarily correct.
>>>>
>>>>
>>>
>>> But the sub-set of all correct and complete simulations is NOT the same
>>> as the set of all simulations of Px, so you haven't shown that ALL Px
>>> will be non-halting.
>> We began with all of the *partial or complete* simulations of Px by Hx
>>> *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.
>> Then we took a subset of this set:
>>> *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.
>>>
>>>
>>> So you fail at knowing set theory too.
>>>
>> No I just proved that you weren't paying enough attention.
>
> Can you explain why you have gone from, a couple of weeks ago, claiming you had a single Hx which worked, to now talking about an infinite set of Hx s?

On Saturday, September 17, 2022 at 6:16:46 PM UTC+1, olcott wrote:
> On 9/17/2022 12:03 PM, Paul N wrote:
> > On Saturday, September 17, 2022 at 4:07:40 PM UTC+1, olcott wrote:
> >> On 9/17/2022 6:06 AM, Richard Damon wrote:
> >>> On 9/17/22 12:15 AM, olcott wrote:
> >>>> On 9/16/2022 10:56 PM, Richard Damon wrote:
> >>>>> On 9/16/22 11:34 PM, olcott wrote:
> >>>>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
> >>>>>>>
> >>>>>>> On 9/16/22 10:17 PM, olcott wrote:
> >>>>>>>> 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.
> >>>>>>>>
> >>>>>>>> A proof by example (over generalization) is not a fallacy when it
> >>>>>>>> includes the infinite set of every possible example. In this case
> >>>>>>>> it becomes categorically exhaustive reasoning (CAR)**.
> >>>>>>>
> >>>>>>> Really? Your ONE example is infinite?
> >>>>>>>
> >>>>>>> Even showing an infinte number of examples isn't exahustive since
> >>>>>>> we can show an infintie number of cases you did NOT look at.
> >>>>>>
> >>>>>> You did not pay enough attention, here is what I said:
> >>>>>> *the infinite set of every possible example*
> >>>>>>
> >>>>>> We can know that every integer > 5 is also > 3 without checking each
> >>>>>> one.
> >>>>>>
> >>>>>>>>
> >>>>>>>> The above infinite recursion criteria has zero false positives
> >>>>>>>> across the infinite set of every instance of infinite recursion.
> >>>>>>>>
> >>>>>>>
> >>>>>>> WRONG. If fails on P(P).
> >>>>>> int Hx(ptr x, ptr y)
> >>>>>> {
> >>>>>> x(y); // is P(P) when Hx(P,P) is invoked.
> >>>>>> }
> >>>>>>
> >>>>>> The above Hx is one element of the infinite set of Hx/Px pairs.
> >>>>>
> >>>>> But not the one that *THE* P calls, you know, the one that calls the
> >>>>> H that is supposed to get the right answer.
> >>>>>
> >>>>
> >>>> The above one is the one that Hx must report on.
> >>>>
> >>>>>>
> >>>>>>
> >>>>>> Because you agreed with a key point recently I am confident that we
> >>>>>> can have an actual honest dialogue.
> >>>>>>
> >>>>>
> >>>>> Only if you are willing to change an be HONEST.
> >>>>>
> >>>>
> >>>> I have always been honest.
> >>>> Even in the case that Ben pointed out when I claimed that I had two
> >>>> Turing machines and instead had something computationally equivalent
> >>>> to two Turing machines. In other words for all practical purposes I
> >>>> did have two Turing machines, thus close enough.
> >>>>
> >>>>> So far it has just been me pointing out your stupid mistakes.
> >>>>>
> >>>>
> >>>> All of my recent "stupid mistakes" are merely your lack of
> >>>> comprehension of my difficult ideas.
> >>>>
> >>>>>
> >>>>> Remember, Programs/Machines don't call/use "Sets" of program/machines.
> >>>>>
> >>>>
> >>>> Set theory is how categorically exhaustive reasoning is applied.
> >>>>
> >>>> If all X are Y then anything that says all X are Y is necessarily
> >>>> correct. (All male humans are humans).
> >>>>
> >>>> If all correct and complete simulations of Px by Hx never halt then
> >>>> when some Hx returns 0 meaning that all correct and complete
> >>>> simulations of Px by Hx never halt then these instances of Hx are
> >>>> necessarily correct.
> >>>>
> >>>>
> >>>
> >>> But the sub-set of all correct and complete simulations is NOT the same
> >>> as the set of all simulations of Px, so you haven't shown that ALL Px
> >>> will be non-halting.
> >> We began with all of the *partial or complete* simulations of Px by Hx
> >>> *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.
> >> Then we took a subset of this set:
> >>> *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.
> >>>
> >>>
> >>> So you fail at knowing set theory too.
> >>>
> >> No I just proved that you weren't paying enough attention.
> >
> > Can you explain why you have gone from, a couple of weeks ago, claiming you had a single Hx which worked, to now talking about an infinite set of Hx s?
> Richard kept saying that H does not determine the halt status of the
> correct sequence of instructions so I proved that Hx determines the
> correct halts status for all sequences of instructions where Px is
> simulated by Hx.

On 9/17/22 12:53 PM, olcott wrote:
> On 9/17/2022 11:24 AM, Richard Damon wrote:
>>
>> On 9/17/22 11:07 AM, olcott wrote:
>>> On 9/17/2022 6:06 AM, Richard Damon wrote:
>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>> On 9/16/2022 10:56 PM, Richard Damon wrote:
>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> A proof by example (over generalization) is not a fallacy when
>>>>>>>>> it includes the infinite set of every possible example. In this
>>>>>>>>> case it becomes categorically exhaustive reasoning (CAR)**.
>>>>>>>>
>>>>>>>> Really? Your ONE example is infinite?
>>>>>>>>
>>>>>>>> Even showing an infinte number of examples isn't exahustive
>>>>>>>> since we can show an infintie number of cases you did NOT look at.
>>>>>>>
>>>>>>> You did not pay enough attention, here is what I said:
>>>>>>> *the infinite set of every possible example*
>>>>>>>
>>>>>>> We can know that every integer > 5 is also > 3 without checking
>>>>>>> each one.
>>>>>>>
>>>>>>>>>
>>>>>>>>> The above infinite recursion criteria has zero false positives
>>>>>>>>> across the infinite set of every instance of infinite recursion.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG. If fails on P(P).
>>>>>>> int Hx(ptr x, ptr y)
>>>>>>> {
>>>>>>>    x(y); // is P(P) when Hx(P,P) is invoked.
>>>>>>> }
>>>>>>>
>>>>>>> The above Hx is one element of the infinite set of Hx/Px pairs.
>>>>>>
>>>>>> But not the one that *THE* P calls, you know, the one that calls
>>>>>> the H that is supposed to get the right answer.
>>>>>>
>>>>>
>>>>> The above one is the one that Hx must report on.
>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Because you agreed with a key point recently I am confident that
>>>>>>> we can have an actual honest dialogue.
>>>>>>>
>>>>>>
>>>>>> Only if you are willing to change an be HONEST.
>>>>>>
>>>>>
>>>>> I have always been honest.
>>>>> Even in the case that Ben pointed out when I claimed that I had two
>>>>> Turing machines and instead had something computationally
>>>>> equivalent to two Turing machines. In other words for all practical
>>>>> purposes I did have two Turing machines, thus close enough.
>>>>>
>>>>>> So far it has just been me pointing out your stupid mistakes.
>>>>>>
>>>>>
>>>>> All of my recent "stupid mistakes" are merely your lack of
>>>>> comprehension of my difficult ideas.
>>>>>
>>>>>>
>>>>>> Remember, Programs/Machines don't call/use "Sets" of
>>>>>> program/machines.
>>>>>>
>>>>>
>>>>> Set theory is how categorically exhaustive reasoning is applied.
>>>>>
>>>>> If all X are Y then anything that says all X are Y is necessarily
>>>>> correct. (All male humans are humans).
>>>>>
>>>>> If all correct and complete simulations of Px by Hx never halt then
>>>>> when some Hx returns 0 meaning that all correct and complete
>>>>> simulations of Px by Hx never halt then these instances of Hx are
>>>>> necessarily correct.
>>>>>
>>>>>
>>>>
>>>> But the sub-set of all correct and complete simulations is NOT the
>>>> same as the set of all simulations of Px, so you haven't shown that
>>>> ALL Px will be non-halting.
>>>
>>> We began with all of the *partial or complete* simulations of Px by Hx
>>
>> Which don't prove ANYTHING>
>>
>> PERIOD.
>>
>>>
>>>  > *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.
>>
>> Which just proves they are POOP Deciders, not Halting Deciders.
>>
>> PERIOD.
>>
>>>
>>> Then we took a subset of this set:
>>>
>>>  > *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.
>>>  >
>>
>> And the subset that is proven to be non-halting contains ONLY those Px
>> built on an Hx that does not abort.
>>
>> So ONLY that subset is proven non-halting.
>>
>> The subset of Hx that answer 0, has ZERO members in that subset, so
>> you haven't established anything of what you claim.
>>
>> In fact, ALL the Px based on those Hx can be shown to be halting, so
>> it is PROVED that ALL your Hx are wrong in one way of another, and
>> thus the set of correct Simulating Halting Deciders is the EMPTY SET.
>>
>> FAIL.
>>
>>
>>>>
>>>> So you fail at knowing set theory too.
>>>>
>>>
>>> No I just proved that you weren't paying enough attention.
>>
>> No, you are proving you don't know what you are talking about, as it
>> fails to match the actual words you are using.
>>
>>
>>>
>>>> The subset of the Px shown to be non-halting is the sub-set of Px
>>>> built on Hx's that don't abort
>>>>
>>>> Thus you haven't shown anything about a Px built on an Hx that does.
>>>>
>>>
>>> No Px where 1 to ∞ instructions are correctly simulated by Hx reaches
>>> its final state and halts, thus every Hx returning 0 correctly
>>> reports this.
>>>
>>> This also correctly reports that no Px correctly and completely
>>> simulated by Hx halts, thus every Hx returning 0 correctly reports this.
>>
>> Nope. Simulation of only a finite number of steps do not prove
>> non-halting.
>>
> I have to give up on you because I have conclusively proved that there
> are such things as non-halting behavior patterns that when correctly
> matched do correctly predict that the simulation of the input never
> stops running unless aborted and you simply ignore this proof.
>

On 9/17/2022 1:13 PM, Paul N wrote:
> On Saturday, September 17, 2022 at 6:16:46 PM UTC+1, olcott wrote:
>> On 9/17/2022 12:03 PM, Paul N wrote:
>>> On Saturday, September 17, 2022 at 4:07:40 PM UTC+1, olcott wrote:
>>>> On 9/17/2022 6:06 AM, Richard Damon wrote:
>>>>> On 9/17/22 12:15 AM, olcott wrote:
>>>>>> On 9/16/2022 10:56 PM, Richard Damon wrote:
>>>>>>> On 9/16/22 11:34 PM, olcott wrote:
>>>>>>>> On 9/16/2022 9:33 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/16/22 10:17 PM, olcott wrote:
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> A proof by example (over generalization) is not a fallacy when it
>>>>>>>>>> includes the infinite set of every possible example. In this case
>>>>>>>>>> it becomes categorically exhaustive reasoning (CAR)**.
>>>>>>>>>
>>>>>>>>> Really? Your ONE example is infinite?
>>>>>>>>>
>>>>>>>>> Even showing an infinte number of examples isn't exahustive since
>>>>>>>>> we can show an infintie number of cases you did NOT look at.
>>>>>>>>
>>>>>>>> You did not pay enough attention, here is what I said:
>>>>>>>> *the infinite set of every possible example*
>>>>>>>>
>>>>>>>> We can know that every integer > 5 is also > 3 without checking each
>>>>>>>> one.
>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The above infinite recursion criteria has zero false positives
>>>>>>>>>> across the infinite set of every instance of infinite recursion.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG. If fails on P(P).
>>>>>>>> int Hx(ptr x, ptr y)
>>>>>>>> {
>>>>>>>> x(y); // is P(P) when Hx(P,P) is invoked.
>>>>>>>> }
>>>>>>>>
>>>>>>>> The above Hx is one element of the infinite set of Hx/Px pairs.
>>>>>>>
>>>>>>> But not the one that *THE* P calls, you know, the one that calls the
>>>>>>> H that is supposed to get the right answer.
>>>>>>>
>>>>>>
>>>>>> The above one is the one that Hx must report on.
>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Because you agreed with a key point recently I am confident that we
>>>>>>>> can have an actual honest dialogue.
>>>>>>>>
>>>>>>>
>>>>>>> Only if you are willing to change an be HONEST.
>>>>>>>
>>>>>>
>>>>>> I have always been honest.
>>>>>> Even in the case that Ben pointed out when I claimed that I had two
>>>>>> Turing machines and instead had something computationally equivalent
>>>>>> to two Turing machines. In other words for all practical purposes I
>>>>>> did have two Turing machines, thus close enough.
>>>>>>
>>>>>>> So far it has just been me pointing out your stupid mistakes.
>>>>>>>
>>>>>>
>>>>>> All of my recent "stupid mistakes" are merely your lack of
>>>>>> comprehension of my difficult ideas.
>>>>>>
>>>>>>>
>>>>>>> Remember, Programs/Machines don't call/use "Sets" of program/machines.
>>>>>>>
>>>>>>
>>>>>> Set theory is how categorically exhaustive reasoning is applied.
>>>>>>
>>>>>> If all X are Y then anything that says all X are Y is necessarily
>>>>>> correct. (All male humans are humans).
>>>>>>
>>>>>> If all correct and complete simulations of Px by Hx never halt then
>>>>>> when some Hx returns 0 meaning that all correct and complete
>>>>>> simulations of Px by Hx never halt then these instances of Hx are
>>>>>> necessarily correct.
>>>>>>
>>>>>>
>>>>>
>>>>> But the sub-set of all correct and complete simulations is NOT the same
>>>>> as the set of all simulations of Px, so you haven't shown that ALL Px
>>>>> will be non-halting.
>>>> We began with all of the *partial or complete* simulations of Px by Hx
>>>>> *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.
>>>> Then we took a subset of this set:
>>>>> *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.
>>>>>
>>>>>
>>>>> So you fail at knowing set theory too.
>>>>>
>>>> No I just proved that you weren't paying enough attention.
>>>
>>> Can you explain why you have gone from, a couple of weeks ago, claiming you had a single Hx which worked, to now talking about an infinite set of Hx s?
>> Richard kept saying that H does not determine the halt status of the
>> correct sequence of instructions so I proved that Hx determines the
>> correct halts status for all sequences of instructions where Px is
>> simulated by Hx.
>
> So he said you were using the wrong Px, and you respond by throwing in infinitely more Hx s? That makes no sense.