On 9/17/22 4:36 PM, olcott wrote:
> On 9/17/2022 3:27 PM, Richard Damon wrote:
>> On 9/17/22 3:56 PM, olcott wrote:
>>> On 9/17/2022 2:48 PM, Richard Damon wrote:
>>>> On 9/17/22 3:27 PM, olcott wrote:
>>>>> On 9/17/2022 2:14 PM, Richard Damon wrote:
>>>>>> On 9/17/22 2:50 PM, olcott wrote:
>>>>>>> On 9/17/2022 1:26 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, there exist non-halting behavior patterns, what you refuse
>>>>>>>> to see is that H's simulation of the input to H(P,P) can't
>>>>>>>> include one, since if H(P,P) returns 0, then P(P) Halts.
>>>>>>> Of the infinite set of Hx/Px where Hx correctly simulates Px no
>>>>>>> Px ever halts no matter what Hx does. Because you already know
>>>>>>> this that makes you a liar.
>>>>>>>
>>>>>>
>>>>>> What does it matter that no member of that set shows Hx correctly
>>>>>> simulating its Px to a final state? That isn't the question.
>>>>>>
>>>>> That is stipulated to be the question.
>>>>>
>>>>> All halt deciders are required to correctly predict whether or not
>>>>> their input would reach its own final state and halt.
>>>>>
>>>>> Since No Px correctly simulated by Hx every reaches its final state
>>>>> and halts Hx(Px,Px)==0 is necessarily correct.
>>>>>
>>>>>
>>>>
>>>> But no Hx that answer does a complete simulation,
>>> You are such a despicable liar.
>>>
>>
>> What did I say that was FACTUALLY untrue.
>>
>
> I have proven that simulating halt deciders correctly determine the
> non-halting status of inputs in a finite number of steps hundreds of
> times and *being the despicable liar that you are* you continue to
> simply ignore this proof.
>
>

On 9/17/22 4:51 PM, olcott wrote:
> On 9/17/2022 3:39 PM, Richard Damon wrote:
>> On 9/17/22 4:26 PM, olcott wrote:
>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>> On Saturday, September 17, 2022 at 9:12:24 PM UTC+1, olcott wrote:
>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>
>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> All male humans are humans, thus anyone saying that male humans
>>>>>>>>> are
>>>>>>>>> humans is correct.
>>>>>>>>>
>>>>>>>>> Every Px simulated by Hx never halts thus every Hx saying that
>>>>>>>>> every Px simulated by Hx never halts is correct.
>>>>>>>>
>>>>>>>> The only reason every Px simulated by Hx never halts is because Hx
>>>>>>>> is not correctly simulating every Px.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> You are incompetent about these things.
>>>>>>
>>>>>> Yes, you are indeed.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>> I have fully operational code that proves my point all you have is
>>>>> incoherent misconceptions.
>>>>>
>>>>> *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
>>>>
>>>> While you claim to have fully operational code, it's a pretty safe
>>>> bet that you will not actually run it and answer the following two
>>>> questions about it:
>>>>
>>>> What is the value of Hx(Px, Px)?
>>>> Does Px(Px) halt when you run it?
>>>>
>>>
>>> The elements of the infinite set of Hx/Px pairs contained in my
>>> project are named H/P and HH/PP.
>>>
>>>> You will dishonestly say I've changed the subject, or some similar
>>>> feeble excuse.
>>>
>>> When this Hx element of the set of Hx/Px pairs is directly executed
>>> it directly executes Px(Px) that never halts:
>>>
>>> Hx(ptr x, ptr y)
>>> {
>>>    x(y);
>>> }
>>>
>>
>> So, that Hx never gives an answer, so it doesn't matter that it makes
>> a Px that is non-halting. That Hx FAILS just like you FAIL at being a
>> correct decider.
>
> At least one of the Hx elements returning 0 does this on the basis that
> it correctly matched a correct infinite behavior pattern that correctly
> proves that no Px element of the Hx/Px pairs simulated by Hx halts.
>

On Friday, September 16, 2022 at 6:03:56 PM UTC-7, olcott wrote:
> On 9/16/2022 7:58 PM, dklei...@gmail.com wrote:
> > On Friday, September 16, 2022 at 12:36:09 PM UTC-7, olcott wrote:
> >> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
> >>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
> >>>> void Px(ptr x)
> >>>> {
> >>>> int Halt_Status = Hx(x, x);
> >>>> if (Halt_Status)
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>> }
> >>>>
> >>> This means nothing without a definition of Hx
> >>> Once again - what are you trying to prove?
> >> You have to carefully study every single word that I said and then you
> >> will see that Hx/Px pairs include an infinite set of definitions of Hx.
> >>
> > You're assuming something that is not written here. You haven't
> > defined Hx/Px pairs. What are you assuming?
> It is written in the part that you chopped out:
>
I don't think so. But if you are making an argument for a proposition
it is usually expected that all the terms you use be defined as part
of your argument.

> > There are zero elements of infinite set of Hx/Px pairs such that the
> > correct *partial or complete* simulation of Px by Hx reaches the final
> > state of Px.
>
This is not easy to translate into comprehensible mathematical
terms. What is most missing is a clear definition of what
"simulation" means. Otherwise "reaches the final state of Px" has
no recognizable meaning.

If we achieved that much clarity then it seems that Hx is any
function of two variables such that Hx simulates Px.

Then you assert the theorem that the simulation of Px by Hx
never reaches the final state of Px. I think you mean that
this theorem is illustrated by the "if Px returns, Hx(Px, Px)
returns 0". But these are not equivalent statements. Which
do you intend?

On 9/17/2022 4:13 PM, Richard Damon wrote:
>
> On 9/17/22 4:51 PM, olcott wrote:
>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>> On 9/17/22 4:26 PM, olcott wrote:
>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>> On Saturday, September 17, 2022 at 9:12:24 PM UTC+1, olcott wrote:
>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>
>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> All male humans are humans, thus anyone saying that male
>>>>>>>>>> humans are
>>>>>>>>>> humans is correct.
>>>>>>>>>>
>>>>>>>>>> Every Px simulated by Hx never halts thus every Hx saying that
>>>>>>>>>> every Px simulated by Hx never halts is correct.
>>>>>>>>>
>>>>>>>>> The only reason every Px simulated by Hx never halts is because Hx
>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> You are incompetent about these things.
>>>>>>>
>>>>>>> Yes, you are indeed.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>> I have fully operational code that proves my point all you have is
>>>>>> incoherent misconceptions.
>>>>>>
>>>>>> *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
>>>>>
>>>>> While you claim to have fully operational code, it's a pretty safe
>>>>> bet that you will not actually run it and answer the following two
>>>>> questions about it:
>>>>>
>>>>> What is the value of Hx(Px, Px)?
>>>>> Does Px(Px) halt when you run it?
>>>>>
>>>>
>>>> The elements of the infinite set of Hx/Px pairs contained in my
>>>> project are named H/P and HH/PP.
>>>>
>>>>> You will dishonestly say I've changed the subject, or some similar
>>>>> feeble excuse.
>>>>
>>>> When this Hx element of the set of Hx/Px pairs is directly executed
>>>> it directly executes Px(Px) that never halts:
>>>>
>>>> Hx(ptr x, ptr y)
>>>> {
>>>>    x(y);
>>>> }
>>>>
>>>
>>> So, that Hx never gives an answer, so it doesn't matter that it makes
>>> a Px that is non-halting. That Hx FAILS just like you FAIL at being a
>>> correct decider.
>>
>> At least one of the Hx elements returning 0 does this on the basis
>> that it correctly matched a correct infinite behavior pattern that
>> correctly proves that no Px element of the Hx/Px pairs simulated by Hx
>> halts.
>>
>
> Which one?
>
> What is that CORRECT pattern?
>
> Remenber, your CLAIMED pattern has been shown to be incorrect, as the
> P(P) based on the H that uses it is Halting BECAUSE H matched its
> simulation to that pattern.
>

On 9/17/22 5:35 PM, olcott wrote:
> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>
>> On 9/17/22 4:51 PM, olcott wrote:
>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM UTC+1, olcott wrote:
>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>
>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> All male humans are humans, thus anyone saying that male
>>>>>>>>>>> humans are
>>>>>>>>>>> humans is correct.
>>>>>>>>>>>
>>>>>>>>>>> Every Px simulated by Hx never halts thus every Hx saying that
>>>>>>>>>>> every Px simulated by Hx never halts is correct.
>>>>>>>>>>
>>>>>>>>>> The only reason every Px simulated by Hx never halts is
>>>>>>>>>> because Hx
>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are incompetent about these things.
>>>>>>>>
>>>>>>>> Yes, you are indeed.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>> I have fully operational code that proves my point all you have is
>>>>>>> incoherent misconceptions.
>>>>>>>
>>>>>>> *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
>>>>>>
>>>>>> While you claim to have fully operational code, it's a pretty safe
>>>>>> bet that you will not actually run it and answer the following two
>>>>>> questions about it:
>>>>>>
>>>>>> What is the value of Hx(Px, Px)?
>>>>>> Does Px(Px) halt when you run it?
>>>>>>
>>>>>
>>>>> The elements of the infinite set of Hx/Px pairs contained in my
>>>>> project are named H/P and HH/PP.
>>>>>
>>>>>> You will dishonestly say I've changed the subject, or some similar
>>>>>> feeble excuse.
>>>>>
>>>>> When this Hx element of the set of Hx/Px pairs is directly executed
>>>>> it directly executes Px(Px) that never halts:
>>>>>
>>>>> Hx(ptr x, ptr y)
>>>>> {
>>>>>    x(y);
>>>>> }
>>>>>
>>>>
>>>> So, that Hx never gives an answer, so it doesn't matter that it
>>>> makes a Px that is non-halting. That Hx FAILS just like you FAIL at
>>>> being a correct decider.
>>>
>>> At least one of the Hx elements returning 0 does this on the basis
>>> that it correctly matched a correct infinite behavior pattern that
>>> correctly proves that no Px element of the Hx/Px pairs simulated by
>>> Hx halts.
>>>
>>
>> Which one?
>>
>> What is that CORRECT pattern?
>>
>> Remenber, your CLAIMED pattern has been shown to be incorrect, as the
>> P(P) based on the H that uses it is Halting BECAUSE H matched its
>> simulation to that pattern.
>>
>
> When H(P,P) directly executes its input it proves that P(P) does not halt.

On 9/17/2022 4:31 PM, dklei...@gmail.com wrote:
> On Friday, September 16, 2022 at 6:03:56 PM UTC-7, olcott wrote:
>> On 9/16/2022 7:58 PM, dklei...@gmail.com wrote:
>>> On Friday, September 16, 2022 at 12:36:09 PM UTC-7, olcott wrote:
>>>> On 9/16/2022 2:04 PM, dklei...@gmail.com wrote:
>>>>> On Friday, September 16, 2022 at 9:17:21 AM UTC-7, olcott wrote:
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>> int Halt_Status = Hx(x, x);
>>>>>> if (Halt_Status)
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>> }
>>>>>>
>>>>> This means nothing without a definition of Hx
>>>>> Once again - what are you trying to prove?
>>>> You have to carefully study every single word that I said and then you
>>>> will see that Hx/Px pairs include an infinite set of definitions of Hx.
>>>>
>>> You're assuming something that is not written here. You haven't
>>> defined Hx/Px pairs. What are you assuming?
>> It is written in the part that you chopped out:
>>
> I don't think so. But if you are making an argument for a proposition
> it is usually expected that all the terms you use be defined as part
> of your argument.
>
>>> There are zero elements of infinite set of Hx/Px pairs such that the
>>> correct *partial or complete* simulation of Px by Hx reaches the final
>>> state of Px.
>>
> This is not easy to translate into comprehensible mathematical
> terms. What is most missing is a clear definition of what
> "simulation" means. Otherwise "reaches the final state of Px" has
> no recognizable meaning.
>

These are common terms of the art it seems ridiculously disingenuous
that you pretend to not know what these terms mean. I define them anyway.

> If we achieved that much clarity then it seems that Hx is any
> function of two variables such that Hx simulates Px.
>

In the key subset of the infinite set of Hx/Px pairs Hx is any compiled
C function that correctly simulates one or more steps of the machine
language of Px (its first argument) using an x86 emulator.

> Then you assert the theorem that the simulation of Px by Hx
> never reaches the final state of Px.

This is self-evident on the basis of the source-code of Px.
The C level "final state" of Px is its "return" instruction.

> I think you mean that
> this theorem is illustrated by the "if Px returns, Hx(Px, Px)
> returns 0". But these are not equivalent statements. Which
> do you intend?
>

The Hx elements of the Hx/Px pairs that return 0 correctly answer the
question: Does any Px correctly simulated by Hx halt?

At least with you I can rely on an honest dialogue.

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

On 9/17/2022 4:44 PM, Richard Damon wrote:
>
> On 9/17/22 5:35 PM, olcott wrote:
>> On 9/17/2022 4:13 PM, Richard Damon wrote:
>>>
>>> On 9/17/22 4:51 PM, olcott wrote:
>>>> On 9/17/2022 3:39 PM, Richard Damon wrote:
>>>>> On 9/17/22 4:26 PM, olcott wrote:
>>>>>> On 9/17/2022 3:19 PM, Paul N wrote:
>>>>>>> On Saturday, September 17, 2022 at 9:12:24 PM UTC+1, olcott wrote:
>>>>>>>> On 9/17/2022 3:02 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 17 Sep 2022 14:38:29 -0500
>>>>>>>>> olcott <polc...@gmail.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 9/17/2022 2:30 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sat, 17 Sep 2022 13:48:38 -0500
>>>>>>>>>>> olcott <non...@beez-waxes.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> All male humans are humans, thus anyone saying that male
>>>>>>>>>>>> humans are
>>>>>>>>>>>> humans is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> Every Px simulated by Hx never halts thus every Hx saying that
>>>>>>>>>>>> every Px simulated by Hx never halts is correct.
>>>>>>>>>>>
>>>>>>>>>>> The only reason every Px simulated by Hx never halts is
>>>>>>>>>>> because Hx
>>>>>>>>>>> is not correctly simulating every Px.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are incompetent about these things.
>>>>>>>>>
>>>>>>>>> Yes, you are indeed.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>> I have fully operational code that proves my point all you have is
>>>>>>>> incoherent misconceptions.
>>>>>>>>
>>>>>>>> *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
>>>>>>>
>>>>>>> While you claim to have fully operational code, it's a pretty
>>>>>>> safe bet that you will not actually run it and answer the
>>>>>>> following two questions about it:
>>>>>>>
>>>>>>> What is the value of Hx(Px, Px)?
>>>>>>> Does Px(Px) halt when you run it?
>>>>>>>
>>>>>>
>>>>>> The elements of the infinite set of Hx/Px pairs contained in my
>>>>>> project are named H/P and HH/PP.
>>>>>>
>>>>>>> You will dishonestly say I've changed the subject, or some
>>>>>>> similar feeble excuse.
>>>>>>
>>>>>> When this Hx element of the set of Hx/Px pairs is directly
>>>>>> executed it directly executes Px(Px) that never halts:
>>>>>>
>>>>>> Hx(ptr x, ptr y)
>>>>>> {
>>>>>>    x(y);
>>>>>> }
>>>>>>
>>>>>
>>>>> So, that Hx never gives an answer, so it doesn't matter that it
>>>>> makes a Px that is non-halting. That Hx FAILS just like you FAIL at
>>>>> being a correct decider.
>>>>
>>>> At least one of the Hx elements returning 0 does this on the basis
>>>> that it correctly matched a correct infinite behavior pattern that
>>>> correctly proves that no Px element of the Hx/Px pairs simulated by
>>>> Hx halts.
>>>>
>>>
>>> Which one?
>>>
>>> What is that CORRECT pattern?
>>>
>>> Remenber, your CLAIMED pattern has been shown to be incorrect, as the
>>> P(P) based on the H that uses it is Halting BECAUSE H matched its
>>> simulation to that pattern.
>>>
>>
>> When H(P,P) directly executes its input it proves that P(P) does not
>> halt.
>
> Except that *THE* P that was built from the H you claimed was giving the
> right answer, not one that doesn't.
Every Hx element that returns 0 correctly answers the question:
Does any Px element correctly simulated by Hx halt?