On 4/10/22 11:08 AM, olcott wrote:
> On 4/10/2022 6:03 AM, Richard Damon wrote:
>> On 4/9/22 11:19 PM, olcott wrote:
>>> On 4/9/2022 9:51 PM, Richard Damon wrote:
>>>>
>>>> On 4/9/22 10:32 PM, olcott wrote:
>>>>> On 4/9/2022 5:54 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 4/9/2022 7:20 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 4/8/2022 4:08 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 4/7/2022 8:14 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 4/7/2022 6:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 4/7/2022 10:51 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> THIS PROVES THAT I AM CORRECT
>>>>>>>>>>>>>>>>> It is the case that the correctly simulated input to
>>>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>>>> never possibly reach its own final state under any
>>>>>>>>>>>>>>>>> condition at all.
>>>>>>>>>>>>>>>>> Therefore embedded_H is necessarily correct to reject
>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet you won't answer two simple questions!  Why?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because I absolutely positively will not tolerate
>>>>>>>>>>>>>>> divergence from
>>>>>>>>>>>>>>> validating my 17 years worth of work.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you have no choice but to tolerate it.  If someone
>>>>>>>>>>>>>> wants to talk
>>>>>>>>>>>>>> about why you are wrong, they will do so.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are wrong (for the C version of H) because H(P,P) ==
>>>>>>>>>>>>>> false but P(P)
>>>>>>>>>>>>>> halts.  You are wrong about your TM H because H <Ĥ> <Ĥ>
>>>>>>>>>>>>>> transitions to
>>>>>>>>>>>>>> qn, but Ĥ applied to <Ĥ> is a halting computation. (Feel
>>>>>>>>>>>>>> free to deny
>>>>>>>>>>>>>> any of these facts if the mood takes you.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you believe (against the verified facts) that the
>>>>>>>>>>>>> simulated ⟨Ĥ0⟩
>>>>>>>>>>>>> reaches its final state of ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> I believe what you've told me: that you claim that
>>>>>>>>>>>> H(P,P)==false is
>>>>>>>>>>>> correct despite the fact that P(P) halts.  That's wrong.
>>>>>>>>>>>
>>>>>>>>>>> If the input to H(P,P) cannot possibly reach its final state
>>>>>>>>>>> then this
>>>>>>>>>>> input is correctly rejected and nothing in the universe can
>>>>>>>>>>> possibly
>>>>>>>>>>> contradict this.
>>>>>>>>>>
>>>>>>>>>> Agreed facts: (1) H(P,P) == false, (2) P(P) halts.  You don't
>>>>>>>>>> dispute
>>>>>>>>>> either (indeed they come from you).
>>>>>>>> At least you don't contend these facts.
>>>>>>>>
>>>>>>>>>> Your new line in waffle is just an attempt to distract
>>>>>>>>>> attention from a
>>>>>>>>>> very simple claim: that the wrong answer is the right one.
>>>>>>>>>
>>>>>>>>> Even Linz got this wrong because it is counter-intuitive.
>>>>>>>>>
>>>>>>>>> A halt decider must compute the mapping from its inputs (not
>>>>>>>>> any damn
>>>>>>>>> thing else in the universe) to its own final state on the basis
>>>>>>>>> of the
>>>>>>>>> behavior specified by these inputs
>>>>>>>>
>>>>>>>> That's not counter intuitive, it's basic.  Everyone knows this,
>>>>>>>> though
>>>>>>>> it took you a while to get round to it.  A halt decider accepts or
>>>>>>>> rejects a string based on the behaviour of the computation
>>>>>>>> specified by
>>>>>>>> that string.  Of course, you never got as far in my exercises as
>>>>>>>> specifying any TM that decides something on the basis of
>>>>>>>> behaviour, so
>>>>>>>> you really don't know how it's actually done.  That was, I
>>>>>>>> thought, the
>>>>>>>> whole point of the exercises -- to see how TMs are specified to
>>>>>>>> decide
>>>>>>>> properties of computations.
>>>>>>>
>>>>>>> You have to actually pay attention to this,
>>>>>>
>>>>>> Flip, flop!  Back to being wrong about TMs rather than being wrong
>>>>>> about
>>>>>> your old C junk.  These uncontested facts: (1) H(P,P) == false,
>>>>>> (2) P(P)
>>>>>> halts are why your H and P are wrong.
>>>>>>
>>>>>
>>>>> If you are able to break the problem down to it micro component
>>>>> parts and carefully analyze each of these separately instead of
>>>>> simply slipping down the slide of intuition then you can see that I
>>>>> am correct.
>>>>>
>>>>> If it is true that the correct simulation input to H(P,P) cannot
>>>>> possibly reach its own final state then
>>>>
>>>> Except that this ISN'T True.
>>>>
>>>> While H can't reach the end of its simulation, it is not the CORRECT
>>>> simulation.
>>>>
>>>> THe CORRECT simulation is that done by a UTM, which will match the
>>>> DIRECT EXECUTION.
>>>>
>>>> When you take that into consideration, we then see two cases,
>>>>
>>>> Either H DOESN'T abort its simulation, giving you the non-halting
>>>> answer you see, but then that H NEVER answers, so it fails to be a
>>>> DECIDER.
>>>>
>>>> If H DOES abort its simulation, then the CORRECT simulation of the
>>>> input, will be seen to halt (and H's simulation will be seen to not
>>>> be correct).
>>> The simulation of the input will halt because it correctly detects
>>> that its simulated input would never halt.
>>>
>>
>> I.E. you admit you don't know how logic works.
>>
>> Basic rule of Knowledge, you can't actually "know" something that
>> isn't true, that is false knowledge.
>
> I have a whole operating system that conclusively proves every detail of
> what I have said. That you simply disbelieve verified facts seems quite
> dishonest.
>

Nope, you don't, because that OS actually produce the output that proves
the opposite.

You don't seem to know enough to know you are wrong.

It seems to be the classic Garbage In, Garbage Out.

FAIL.