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.

Fairy Dust Powered Unicorns again.

No comment on my proof, and even snipped it out.

I guess it is too togh for you to argue against.

FAIL.

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

RED HERRING and false analogy.

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

Maybe that is your problem. You aren't interested in seeing where you
are wrong and turn the blind eye to the truth.

The problem is that loop only exists if H is an unconditional execution
of its input. And that case can't actual stop its running.

If you change H to be a simulator, then the actual pattern isn't that,
but that is only the path when you ignore the simulator part. Remember,
H really needs to simulate the copy of H it sees in H^, or at minimum
take its behavior into account, which includes that H has conditionality
in execution. You transformation is only valid if H is restricted to
NEVER abort (not just doesn't abort in the part of it that is sumulatd).

Thus you can only validly detect that pattern if you can't act on it,
because you have defined that H won't abort.

Thus H is only 'correct' if it dies with the knowledge, which actually
makes it incorrect in the eyes of the theory.

Your problem is that you just don't understand how these things work.

One point to remind you, in establish fields, 'Obviously True' is not
acceptable proof, if it really is obviosly true, then you should be able
to prove it.

Proofs MUST work from the ACCEPTED axioms (the core obvious truths that
are universally accepted in the field), the ACCEPTED definitions, the
established proven Theorems, and anything that you have actually been
able to prove by those items.

You haven't actually proved much at all, as you haven't actuallly quoted
much in the way of accepted fact to derive your logic.

If you can't see why H can't detect any