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.

When you yank the power cord from a computer it does not execute a
single additional step, it stops immediately. As soon as embedded_H
stops simulating its input this simulated input is 100% totally dead.

The simulated input to embedded_H never reaches its own final state
The simulated input to embedded_H never reaches its own final state
The simulated input to embedded_H never reaches its own final state
The simulated input to embedded_H never reaches its own final state

This is complete proof that the simulated input to embedded_H never halts
This is complete proof that the simulated input to embedded_H never halts
This is complete proof that the simulated input to embedded_H never halts
This is complete proof that the simulated input to embedded_H never halts

> If H aborts its simulation, then the UTM will not repeat that pattern
> indefinitely, but will see the topy copy of H in H^ abort its simulation
> and go to Qn and Halt.
>
> No finite version of the FULL pattern that H sees is a non-halting pattern.
>
> The problem is the loop has a conditional in it that has H abort its
> simulation.
>
> This is one problem with replacing simulation with assumed direct
> exectuiton, it doesn't actually work for conditional
> simulation/execution under a debugger that might decide to abort. These
> cases effectively add a conditional between every instrucition, so the
> patterns that normally are indicative of infinite looping are no longer
> proved to be so by the simple proofs.
>
> FAIL.
>

--
Copyright 2021 Pete Olcott

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