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.

Since you bave not posted any error in that proof, your claim fails to
be established and is shown to just be a fabrication.

in short, if H -> H.Qn, then H^ -> H^.Qn and Halts, and thus H was wrong.

PERIOD.

So, either H fails to answer, and is wrong, or H gives the wrong answer,
and is wrong.

Which way are you wrong?

FAIL.

You still seem to believe in and trust in Fairy Dust powered Unicorns.

>
>
>> I have already shown that the pattern you claim in not correct if H
>> can detect it.
>>
>> More Fairy Dust powered Unicorns.
>>
>> FAIL.
>>
>>>
>>> (2) it is necessarily correct for it to report that that its
>>> simulated input cannot possibly ever reach its halt state.
>>>
>>
>> Since (1) isn't established, (2) can't follow. FAIL.
>
>