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.

This is a little bit more complex version of: when we know that X is a
dog then we are necessarily correct to say that X is a dog.

It is absurdly ridiculous to believe that it is utterly impossible for a
TM to fail recognize the pattern of the same two steps that keep repeating.

--
Copyright 2021 Pete Olcott

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