On 1/23/2022 6:09 PM, Richard Damon wrote:
> On 1/23/22 7:00 PM, olcott wrote:
>> On 1/23/2022 5:50 PM, Richard Damon wrote:
>>> On 1/23/22 6:16 PM, olcott wrote:
>>>> On 1/23/2022 5:06 PM, Richard Damon wrote:
>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>> On 1/23/2022 4:40 PM, Richard Damon wrote:
>>>>>>> On 1/23/22 5:18 PM, olcott wrote:
>>>>>>>> On 1/23/2022 4:01 PM, Richard Damon wrote:
>>>>>>>>> On 1/23/22 4:40 PM, olcott wrote:
>>>>>>>>>> On 1/23/2022 2:25 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/23/22 2:19 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 10:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is true for infinite loops, infinite recursion,
>>>>>>>>>>>>>>>> infinitely nested simulation and all other non halting
>>>>>>>>>>>>>>>> inputs:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When-so-ever any simulated input to any simulating halt
>>>>>>>>>>>>>>>> decider would never reach the final state of this
>>>>>>>>>>>>>>>> simulated input in any finite number of steps it is
>>>>>>>>>>>>>>>> always correct for the simulating halt decider to abort
>>>>>>>>>>>>>>>> its simulation and transition to its reject state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Can you PROVE that statement, or is this just one of your
>>>>>>>>>>>>>>> false 'self evident truth'.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Anyone that knows that x86 language can tell that its easy
>>>>>>>>>>>>>> to match the infinite loop pattern:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>> [000015fa](01)  55              push ebp
>>>>>>>>>>>>>> [000015fb](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>> [000015fd](02)  ebfe            jmp 000015fd
>>>>>>>>>>>>>> [000015ff](01)  5d              pop ebp
>>>>>>>>>>>>>> [00001600](01)  c3              ret
>>>>>>>>>>>>>> Size in bytes:(0007) [00001600]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4] 55              push ebp
>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4] 8bec            mov ebp,esp
>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4] ebfe            jmp
>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4] ebfe            jmp
>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>
>>>>>>>>>>>>> Showing that you can do one case does not prove that the
>>>>>>>>>>>>> same method works on all, particularly harder methods.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That is just you serving Red Herring.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And that pattern does NOT show up in the simulation by H of H^
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which makes it MORE lies by Red Herring.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Does the proof include the posibility that the input
>>>>>>>>>>>>>>> includes a copy of the decider?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is always the case that a simulating halt decider can
>>>>>>>>>>>>>> correctly base its halt status decision on the behavior
>>>>>>>>>>>>>> pure simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H -> H.Qn then H^ -> H^.Qn and Halts and for H^ <H^>
>>>>>>>>>>>>> proves H wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We know that this must be true because we know that the
>>>>>>>>>>>>>> pure UTM simulation of an Turing Machine description is
>>>>>>>>>>>>>> defined to have equivalent behavior to that of the direct
>>>>>>>>>>>>>> execution of the same machine
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but that does't prove what you sy.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are just LYING out of your POOP.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The problem is that IF the simulating halt decider does
>>>>>>>>>>>>>>> abort its input based on some condition, then it is no
>>>>>>>>>>>>>>> longer a source of truth for the halting status of that
>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is not answering the question: Does the input stop
>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU need to answer, which H are you using?
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H doesn't abort, then H^ is non-halting, but H will
>>>>>>>>>>>>> never answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H does abort and go to H.Qn, then the pure simulation of
>>>>>>>>>>>>> the input WILL halt at H^.Qn, so H was wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is answering the question:
>>>>>>>>>>>>>> Would the pure simulation of the input ever stop running?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and if H -> H.Qn it will.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>> YOU JUST AREN'T BRIGHT ENOUGH TO GET THIS. IT CAN BE
>>>>>>>>>>>> VERIFIED AS COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE
>>>>>>>>>>>> MEANING OF ITS WORDS.
>>>>>>>>>>>>
>>>>>>>>>>>> It is the case that if embedded_H recognizes an infinitely
>>>>>>>>>>>> repeating pattern in the simulation of its input such that
>>>>>>>>>>>> this correctly simulated input cannot possibly reach its
>>>>>>>>>>>> final state then this is complete prove that this simulated
>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>
>>>>>>>>>>>> If it COULD CORRECTLY recognize an infinitely repeating
>>>>>>>>>>>> pattern in its
>>>>>>>>>>> simulation that can not possibly reach its final state (when
>>>>>>>>>>> simulated by a UTM, not just H) then, YES, H can go to H.Qn.
>>>>>>>>>>>
>>>>>>>>>>> The problem is that due to 'pathological self-reference' in
>>>>>>>>>>> H^, ANY pattern that H sees in its simulation of <H^> <H^>
>>>>>>>>>>> that it transitions to H.Qn, will BY DEFINITION, become a
>>>>>>>>>>> halting pattern.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So a correctly simulated INPUT that cannot possibly reach its
>>>>>>>>>> final state reaches its final state anyway. YOU ARE DUMBER
>>>>>>>>>> THAN A BOX OF ROCKS !!!
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That's not what I said, I said there is no pattern that H use
>>>>>>>>> to detect that it won't halt, as any pattern that H uses to
>>>>>>>>> decide to go to H.Qn will be WRONG for H^ as if H goes to H.Qn,
>>>>>>>>> then H^ also goes to H^.Qn and Halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When the correctly simulated INPUT to embedded_H cannot possibly
>>>>>>>> reach its final state it is necessarily correct for embedded_H
>>>>>>>> to report that its correctly simulated INPUT cannot possibly
>>>>>>>> reach its final state.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right,  but you have only proved that H^ is non-halting for the
>>>>>>> case where H doesn't abort its simulation.
>>>>>>>
>>>>>>
>>>>>> Because you are dumber than a box of rocks (or perhaps you are a
>>>>>> bot?)
>>>>>> You did not notice that I never mentioned the word: "halting".
>>>>>>
>>>>>> For a human being you are much dumber than a box of rocks.
>>>>>>
>>>>>> For a bot you did quite well (you nearly passed the Turing test)
>>>>>> it took me this long to realize that you are not a human being.
>>>>>>
>>>>>
>>>>> But reaching final state is the same as Halting.
>>>>>
>>>>> You have only prove that the pure simulation of the input to H
>>>>> never reaches a final state for case when H doesn't abort its
>>>>> simulation.
>>>>>
>>>> You deliberate weasel words do not apply to what I said:
>>>>
>>>> (1) Premise: When the correctly simulated INPUT to embedded_H cannot
>>>> possibly reach its final state
>>>>
>>>> (2) Conclusion: It is necessarily correct for embedded_H to report
>>>> that its correctly simulated INPUT cannot possibly reach its final
>>>> state.
>>>>
>>>>
>>>
>>> And the correct simulation of the input to H is determined by the
>>> UTM, not H.
>>
>>
>> (2) is a logical consequence of (1).
>> It is logically incorrect to argue with a deductive logical premise.
>>
>
> But 1 is only true if H doesn't go to H.Qn, so H can't correctly go to
> H.Qn.
>

You are quite the deceiver making sure to always change the subject
rather than directly address the point at hand.

(2) logically follows from (1) is true.

> FAIL.
>
> H can't do what it needed to assume it didn't to prove the fact.
>
> You must be snorting your Unicorn POOP.
>

--
Copyright 2021 Pete Olcott

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