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.

You need to do this as it is shown that the correct and complete
simulation of the input by an actual UTM will show that H(P,P) returning
0 is just wrong, as UTM(P,P) for a P built on an H that returns 0 for
H(P,P) is easily shown to be halting, so you need to use the illogical
definition to outlaw the proof that you are wrong.

You also run into the issue that you can't prove the existance of a
pattern in the simulation done by H(P,P) that actually proves it to be
non-halting, because it has been shown that any such pattern that it
might see can't be a actual non-halting pattern as if H uses it, then P
becomes Halting.

You don't seem to be able to comprhend that Logic has rules that need to
be followed, pesky things like PROOF, and needing to prove existance.