On 1/2/22 5:28 PM, olcott wrote:
> On 1/2/2022 4:26 PM, Richard Damon wrote:
>> On 1/2/22 5:13 PM, olcott wrote:
>>> On 1/2/2022 4:00 PM, Richard Damon wrote:
>>>>
>>>> On 1/2/22 4:32 PM, olcott wrote:
>>>>> On 1/2/2022 3:25 PM, Richard Damon wrote:
>>>>>> On 1/2/22 4:15 PM, olcott wrote:
>>>>>>> On 1/2/2022 2:55 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/2/22 3:43 PM, olcott wrote:
>>>>>>>>> I think at this point we can answer the key question: honest
>>>>>>>>> dialogue?
>>>>>>>>> The answer is no. None of my reviewers want an honest dialogue.
>>>>>>>>
>>>>>>>> No, YOU don't want an Honest Dialogue, as you ignore all the
>>>>>>>> points where people point out your ACTUAL mistakes.
>>>>>>>>
>>>>>>>> Ig you will not deal with people pointing out where you use the
>>>>>>>> wrong definitions or use invalid logic, then what dialog is
>>>>>>>> possible.
>>>>>>>>
>>>>>>>
>>>>>>> It is always a matter that I explain your mistake and then you
>>>>>>> switch to another mistake. around and around. You must be an
>>>>>>> atheist because a believer knows the (eternal incineration)
>>>>>>> penalty for lying.
>>>>>>
>>>>>> No, it is ALWAYS a matter that you will not look at what people
>>>>>> tell you is wrong, but just repeat your error without actually
>>>>>> looking at the errors in your
>>>>>>>
>>>>>>> For simplicity we will refer to the copy of Linz H at Ĥ.qx
>>>>>>> embedded_H.
>>>>>>
>>>>>> Again. No need for a new name, but whatever.
>>>>>>
>>>>>>>
>>>>>>> Simplified syntax adapted from bottom of page 319:
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> this input would never reach a final state and stop running.
>>>>>>
>>>>>> Here we go again. You don't ever learn so you have DOOMED yourself.
>>>>>>
>>>>>>>
>>>>>>> These steps would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> Yes, IF H behaves that way, it makes an H^ that works that way,
>>>>>> and will it is t
>>>>>>
>>>>>>>
>>>>>>> This proves that a human can detect that the simulation of the
>>>>>>> input to embedded_H would never reach its final state.
>>>>>>>
>>>>>>> computation that halts
>>>>>>> ...the Turing machine will halt whenever it enters a final state
>>>>>>> (Linz:1990:234)
>>>>>>>
>>>>>>> This proves that if embedded_H transitioned to Ĥ.qn is would be
>>>>>>> correct because a human can tell the its input meets the Linz
>>>>>>> criteria of never halting.
>>>>>>
>>>>>> Your Unicorn. You previously defined your H to NEVER abort.
>>>>>
>>>>> That you continue to lie about this is your eternal incinertion not
>>>>> mine. If eternal incineration is true then it remains true even if
>>>>> you don't believe in it.
>>>>
>>>> If I am lying, you can prove it be showing a program that actually
>>>> does this.
>>>>
>>>
>>> I am saying that we know it is the case that the infinite simulation
>>> of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ WOULD never reach the final state
>>> of this input and on this basis we also know that if embedded_H WOULD
>>> transition to Ĥ.qn it WOULD be correct.
>>
>> You are doing double speak again.
>>
>
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES
> WOULD is not DOES

And actually, in the sentence it is used in as the definition, they are
actually the same.

If the UTM WOULD halt, means that it DOES halt if let run long enough

If the UTM WOULD NOT halt, means that the UTM actually DOES NOT halt,
even it the UTM is allowed to run an unbounded number of steps.

If you are using it in a different sense, then YOU are the one misusing
the term and lying by doing so.

FAIL.

>
>> If H/embedded_H doesn't abort its simulation, the we have shown that
>> the computation H^ <H^> is indeed non-halting, but since H doesn't
>> abort its simulation it never can give that answer.
>>
>> It doesn't matter in this case that if 'magically' H did go to H.qn
>> that it would have the right answer, because it just doesn't do that.
>>
>> On the other hand, if H/embedded_H DOES abort its simulation and goes
>> to H.qn, then we have a DIFFERENT H^, and BECAUSE H went to H.qn, that
>> H^ will also go to H^.qn and HALT, and thus H was wrong.
>>
>> You have intermixed two different definitions of behavior of H that
>> can not occur at the same time. This is just incoherent double-speak
>> to try to impute a falsehood.
>>
>>>
>>> The way that you lie is to deceitfully change what I said and then
>>> form a rebuttal on the basis of this deceitful change.
>>
>> Please point out what statement I have made that is FACTUALLY incorrect.
>>
>> YOU are the one using double speak to imply a falsehood.
>>
>> Can you provide an H that does what you speak, that if left on its own
>> would never reach the final state, but also correctly goes to H.qn
>>
>> If not, STFU.
>>
>> The fact that Non-Halting is the right answer for the Halt Decider
>> that can never give it is NOT a counter example for Linz, you claiming
>> that some how it is such a thing is just a big fat lie.
>>
>> FAIL.
>>
>>>
>>>
>>>> If I am not lying, then YOU are, and YOUR life is as you just
>>>> described.
>>>>
>>>> Think of your eternal soul's fate if you continue to deny that Truth.
>>>>
>>>>>
>>>>> I never ever defined H to never abort and you know that you lie
>>>>> about this. It has always been about H predicting the future
>>>>> behavior of its input in the purely hypothetical case that H would
>>>>> not abort its input.
>>>>
>>>> If H does abort, the assuming in simulates forever is the UNICORN. A
>>>> machine that DOES abort, can't be used to prove that a computation
>>>> will never halt.
>>>>
>>>> It is REQUIRED to meet the requirements of Linz, that if H goes to
>>>> H.qn, that the H^ using it (as ALL H^ will do) will also go to H^.qn
>>>> and Halt.
>>>>
>>>> f H^ <H^> Halts, the H was not right to say that it wouldn't, which
>>>> is exactly what H <H^> <H^> -> H.qn says.
>>>>
>>>> Remember the requirement on H? That H wM w -> H.qn iff M w never Halts.
>>>>
>>>> Since in this case M == H^, wM == <H^>, w == <H^>, we have that to
>>>> meet the requirements we need that
>>>>
>>>> H <H^> <H^> -> H.qn iff H^ <H^> Never Halts.
>>>>
>>>> But since  H -> H.qn means H^ -> H^.qn and Halts, this is not true.
>>>>
>>>> Your H has FAILED to meet its requirements.
>>>>
>>>> This also means that any 'proof' you have made that impiles that H
>>>> was right must have an error, unless you can point to the error in
>>>> the above.
>>>>
>>>> Isn't that your whole bases of finding a counter to Linz, to show
>>>> that his proof can't be right?
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>
>>>
>>
>
>