On 1/25/2022 5:55 AM, Richard Damon wrote:
> On 1/25/22 12:27 AM, olcott wrote:
>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>
>>> On 1/25/22 12:04 AM, olcott wrote:
>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement. You seem to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the premises are always "given" to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true even if they are false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at soundness we are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> looking at validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this one point until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we have mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you arguing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions that they were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that the under
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the hypothetical condition where H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually determine that the UTM will run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in fact needed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be correct) for H to go to H.Qn and say
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (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.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that 'correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>> not H (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be correct other
>>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that is a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct simulation is the
>>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you are just eating
>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H CAN determine
>>>>>>>>>>>>>>>>>>>>>>>>>>> that this condition exists, so it would be
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct, but H might not be able to decide to
>>>>>>>>>>>>>>>>>>>>>>>>>>> do so. So it may be correct for it to do so,
>>>>>>>>>>>>>>>>>>>>>>>>>>> but it might not actually be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend to ignore
>>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined to
>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT abort, but you try to use (2) to claim
>>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is (2) must be
>>>>>>>>>>>>>>>>>>>>>>>>>>> the same H that the H^ in (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are actually in the
>>>>>>>>>>>>>>>>>>>>>>>>>>> actual meaning of the words you are using,
>>>>>>>>>>>>>>>>>>>>>>>>>>> from the context of the problem, but I state
>>>>>>>>>>>>>>>>>>>>>>>>>>> them because knowing you, you are going to
>>>>>>>>>>>>>>>>>>>>>>>>>>> try to break that restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first time that you
>>>>>>>>>>>>>>>>>>>>>>>>>> actually paid close attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that different from the
>>>>>>>>>>>>>>>>>>>>>>>>>>> statement of the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior of its pure
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input. N is
>>>>>>>>>>>>>>>>>>>>>>>>>> either the number of steps that it takes for
>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated input to reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>> or the number of steps required for H to match
>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite behavior pattern proving that its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>> final state. In this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT based on a
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps, but a simulation by a
>>>>>>>>>>>>>>>>>>>>>>>>> UTM which will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on the limited N
>>>>>>>>>>>>>>>>>>>>>>>>> step, so it needs to prove that its answer
>>>>>>>>>>>>>>>>>>>>>>>>> matches.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H is defined,
>>>>>>>>>>>>>>>>>>>>>>>>> and thus N is a SPECIFIC number, not an
>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how prove that a
>>>>>>>>>>>>>>>>>>>>>>>>> pattern exists in N steps that correct dectect
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to be
>>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually come up
>>>>>>>>>>>>>>>>>>>>>>>>> with it or show an actual error in the proof.
>>>>>>>>>>>>>>>>>>>>>>>>> You can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>> determines its 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.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into hypothecctica
>>>>>>>>>>>>>>>>>>>>>>> Unicoprn Terretory, but lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that means that
>>>>>>>>>>>>>>>>>>>>>>> there needs to exist a finite algroithm to
>>>>>>>>>>>>>>>>>>>>>>> determine this case, and that this result matches
>>>>>>>>>>>>>>>>>>>>>>> the behavior demonstrated by the definitional UTM
>>>>>>>>>>>>>>>>>>>>>>> simulataion of this input), that the input will
>>>>>>>>>>>>>>>>>>>>>>> NEVER reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to report that its
>>>>>>>>>>>>>>>>>>>>>>> input can not possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the proof that
>>>>>>>>>>>>>>>>>>>>>>> the input never reached its final state must have
>>>>>>>>>>>>>>>>>>>>>>> included that fact that the copy of H inside H^
>>>>>>>>>>>>>>>>>>>>>>> will also do the exact same thing with the exact
>>>>>>>>>>>>>>>>>>>>>>> same input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True, you need to be
>>>>>>>>>>>>>>>>>>>>>>> able to PROVE or actually provide the exact
>>>>>>>>>>>>>>>>>>>>>>> finite algorithm that it used to detemine this fact.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these
>>>>>>>>>>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation of N steps
>>>>>>>>>>>>>>>>>>>> matches an infinitely repeating pattern embedded_H
>>>>>>>>>>>>>>>>>>>> can correctly determine that this simulated input
>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state whether or not
>>>>>>>>>>>>>>>>>>>> embedded_H aborts its simulation of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^> is non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these
>>>>>>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If that is what happens, then obviously H never aborted
>>>>>>>>>>>>>>>>> its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation
>>>>>>>>>>>>>>>> of N steps of its input it is necessarily correct for it
>>>>>>>>>>>>>>>> to report that that its simulated input cannot possibly
>>>>>>>>>>>>>>>> ever reach its halt state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Only if it proved that it was correct if it does abort
>>>>>>>>>>>>>>> and go to H.Qn, which it can't.
>>>>>>>>>>>>>> With logical entailment the conclusion follows from the
>>>>>>>>>>>>>> premise(s) by logical necessity.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation of
>>>>>>>>>>>>>> N steps of its input
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which makes the falicay of assuming there is a CORRECT
>>>>>>>>>>>>> pattern for H to detect in H^, and that H has the ability
>>>>>>>>>>>>> to detect it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are either dishonest or not bright enough to see that
>>>>>>>>>>>> this is a pattern that would be very easy to match, so I
>>>>>>>>>>>> guess I am finally done with you.
>>>>>>>>>>>>
>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>> Which I have proven is NOT a correct pattern if H actually
>>>>>>>>>>> aborts on it and goes to H.Qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes so it seems that you simply are not bright enough.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, you have proved yourself too dishonest to actually try to
>>>>>>>>> prove something, but just continue to make your claims based on
>>>>>>>>> your Fairy Dust powered Unicorns.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you can't see how obvious that it is that the above pattern
>>>>>>>> infinitely repeats you are not very bright.
>>>>>>>
>>>>>>> And if you can't see that it is only infinitely looping if H
>>>>>>> never aborts, then you are dumber than a door nail.
>>>>>>>
>>>>>>
>>>>>> It is a behavior pattern that conclusively proves that the pure
>>>>>> simulation of the input cannot possibly reach its final state.
>>>>>> Further discussion seems unfruitful.
>>>>>>
>>>>>>
>>>>>
>>>>> No, it only proves that the pure simulation of an H^ built from an
>>>>> H that will NEVER abort is non-halting.
>>>>>
>>>>
>>>> No. It really does prove that the pure simulation of the input
>>>> cannot possibly reach the final state of this simulated input.
>>>>
>>>>
>>>
>>> How? Your trace is ignoring that there is a conditional inside the
>>> copy of H that is in H^.
>>>
>>> Thus, it doesn't meet the requrements for the 'rule' you are trying
>>> to quote, which isn't even written for the case of a simulator but
>>> direct execution, and the replacement of simulation with direct
>>> exection only applies to UNCONDITIONAL simulation.
>>>
>>
>> You just seem to willfully be stupid to understand that a simulating
>> halt decider never determines whether or not its input stops running.
>>
>> Instead it determines whether or not the Linz criteria can possibly be
>> is met:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>
> Lying by Double Speak again.
>
> By Definition, A Halt Decider decides if its Input represents a Halting
> Computation, which by definition means does the Computation the input
> represents Halt. This can be equivalently defined as decides if a UTM
> simulating its input will Halt or Not.
>
> To be correct, its answer must match the behavior of that machine.
>
> If you are saying that a "Halt Decider never determines whether or not
> its input stops runnning", then you are simply not talking about
> Computation Theory but just your fancy POOP, so nothing you say matters.
>
> FAIL.
>

Since I told you this hundreds of times you are very willfully very stupid:

Simulating halt deciders never determine whether or not their input
stops running. Every input to a simulating halt decider always stops
running either because it reached its final state or its simulation was
aborted. Simulating halt deciders determine whether or not the Linz
criteria can possibly be met: computation that halts … the Turing
machine will halt whenever it enters a final state. (Linz:1990:234)

--
Copyright 2021 Pete Olcott

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