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 ⟨Ĥ⟩ ⟨Ĥ⟩...

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

Bullshit. Not halting is never reaching the final state.

If the correctly simulated input to embedded_H cannot possibly reach its
final state in any finite number of steps thne this simulated input does
not halt.

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

--
Copyright 2021 Pete Olcott

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