On 3/30/2022 3:28 PM, olcott wrote:
> On 3/30/2022 3:10 PM, Dennis Bush wrote:
>> On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
>>> On 3/30/2022 12:37 PM, Dennis Bush wrote:
>>>> On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:
>>>>> On 3/30/2022 12:20 PM, Dennis Bush wrote:
>>>>>> On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:
>>>>>>> On 3/30/2022 12:10 PM, Dennis Bush wrote:
>>>>>>>> On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:
>>>>>>>>> On 3/30/2022 11:53 AM, Dennis Bush wrote:
>>>>>>>>>> On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 3/30/2022 11:26 AM, Dennis Bush wrote:
>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott
>>>>>>>>>>>> wrote:
>>>>>>>>>>>>> On 3/30/2022 10:58 AM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 3/30/2022 8:13 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 3/30/2022 7:06 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/29/2022 10:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The Linz proof only examines Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> thus embedded_H applied to
>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is incorrectly
>>>>>>>>>>>>>>>>>>>>> assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behavior
>>>>>>>>>>>>>>>>>>>>> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved
>>>>>>>>>>>>>>>>>>>>> that they have
>>>>>>>>>>>>>>>>>>>>> distinctly different behavior
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And by "distinctly different behavior" you mean
>>>>>>>>>>>>>>>>>>>> "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
>>>>>>>>>>>>>>>>>>> It is self evidently that the simulated input to
>>>>>>>>>>>>>>>>>>> embedded_H cannot
>>>>>>>>>>>>>>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any
>>>>>>>>>>>>>>>>>>> finite number of
>>>>>>>>>>>>>>>>>>> steps of correct simulation by embedded_H and you
>>>>>>>>>>>>>>>>>>> know it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And by the same logic, It is self evidentl that the
>>>>>>>>>>>>>>>>>> simulated input <N><5> to H3a cannot possibly reach
>>>>>>>>>>>>>>>>>> its own final state of <N.qy> in any finite number of
>>>>>>>>>>>>>>>>>> steps of correct simulation by H3a and you know it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All that you are saying is that a halt determiner that
>>>>>>>>>>>>>>>>> was intentionally
>>>>>>>>>>>>>>>>> designed to get the wrong answer does get the wrong
>>>>>>>>>>>>>>>>> answer. It is not
>>>>>>>>>>>>>>>>> any rebuttal of my words at all and you know it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H3a can correctly determine that <Infinite_Loop><> is
>>>>>>>>>>>>>>>> non-halting, correct? So it's just a matter of
>>>>>>>>>>>>>>>> determining how to find it it gets the right answer.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I will change my words so that your spec meets these
>>>>>>>>>>>>>>>>> changed words:
>>>>>>>>>>>>>>>>> It is self evidently correct that the simulated input
>>>>>>>>>>>>>>>>> to h3a cannot
>>>>>>>>>>>>>>>>> possibly reach its own final state of ⟨N.qy⟩ in any
>>>>>>>>>>>>>>>>> insufficient number
>>>>>>>>>>>>>>>>> number of steps of correct simulation by H3a.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My specs says 1.. ∞ steps your spec says 1 .. 3 steps
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> embedded_Ha doesn't simulate <Ha^><Ha^> for infinite
>>>>>>>>>>>>>>>> steps either. It simulates for up to some n number of
>>>>>>>>>>>>>>>> steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Where N is the number of simulated steps required to
>>>>>>>>>>>>>>> correctly match an
>>>>>>>>>>>>>>> infinite behavior pattern such that the input is
>>>>>>>>>>>>>>> correctly proved to
>>>>>>>>>>>>>>> never reach its own final state or N is the number of
>>>>>>>>>>>>>>> simulated steps
>>>>>>>>>>>>>>> required for the input to reach its own final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Hb simulates <Ha^><Ha^>
>>>>>>>>>>>>> Like I said I will not tolerate endless strawman errors.
>>>>>>>>>>>>
>>>>>>>>>>>> Translation: "I will not tolerate any solid arguments that
>>>>>>>>>>>> conclusively prove I am wrong."
>>>>>>>>>>>>
>>>>>>>>>>>> If Hb accepting <Ha^><Ha^> is wrong
>>>>>>>>>>> It would be that it violated the specification thus no more
>>>>>>>>>>> than a
>>>>>>>>>>> strawman error.
>>>>>>>>>>
>>>>>>>>>> It does not violate the specification. The simulating halt
>>>>>>>>>> decider Hb simulates enough steps of its input <Ha^><Ha^> to
>>>>>>>>>> correctly determine that its input reaches its final state of
>>>>>>>>>> <Ha^.qn> therefore it is correct to accept it. This means that
>>>>>>>>>> Ha and therefore embedded_Ha did *not* simulate enough steps
>>>>>>>>>> of <Ha^><Ha^> and gets the wrong answer.
>>>>>>>>> THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS:
>>>>>>>>> When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>> correctly
>>>>>>>>> determine that this input cannot possibly reach its own final
>>>>>>>>> state of
>>>>>>>>> ⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
>>>>>>>>
>>>>>>>> embedded_Ha does *not* simulate enough steps of its input
>>>>>>>> <Ha^><Ha^> .
>>>>>>> Then it violates the spec and is merely a dishonest attempt at the
>>>>>>> strawman error.
>>>>>>
>>>>>> How does it violate the spec?
>>>>> embedded_H DOES SIMULATE ENOUGH STEPS.
>>>>> embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE
>>>>> SPEC.
>>>>
>>> HHH always simulates its input until it has proof that its simulated
>>> input never reaches its own final state or its simulated input reaches
>>> its own final state.
>>>
>>> Try and find an input that HHH does not decide correctly, everything
>>> else is merely a deceitful attempt to get away with the strawman error.
>>
>> Assuming HHH is Ha
>
> We absolutely do not assume that.
> We only assume that HHH has the proeperties shown above.

// NO INFINITE LOOP
// NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.

Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being
simulated with identical input.

--
Copyright 2022 Pete Olcott

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