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.

That is a Fairy Dust Powered Unicorn. You keep 'claiming' it exists, but
I have proven it doesn't.

If you want to claim it, SHOW IT.

Else, the claim is just a LIE.

>
> 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.

Except the DEFINITION of Halting is based on the UNINTERRUPTED operation
of the 'program'. You can't pull the plug on it.

In fact, that definition even applies to Software Engineering, the only
behavior that the programmer will promise is the behavior of the program
when run 'unmolested'. You can't promise how a program will behave under
undo conditions.

The 'Behavior' of a PROGRAM (as opposed to an execution instance) is the
behavior when unmolested.

FAIL.

>
> 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

But it DOES (at least if H -> H.Qn) when tested by its DEFINITION, the
processing of it by a UTM.

So FAIL.

>
> 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

That is the UNSOUND proof as it is based on FALSE premises and definitions.

FAIL.

>
>> 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.
>>
>
>