On 3/31/2022 8:53 AM, Dennis Bush wrote:
> On Thursday, March 31, 2022 at 9:44:26 AM UTC-4, olcott wrote:
>> On 3/31/2022 6:51 AM, Dennis Bush wrote:
>>> On Wednesday, March 30, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>> On 3/30/2022 9:59 PM, Dennis Bush wrote:
>>>>> On Wednesday, March 30, 2022 at 10:52:11 PM UTC-4, olcott wrote:
>>>>>> On 3/30/2022 9:40 PM, Dennis Bush wrote:
>>>>>>> On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote:
>>>>>>>> On 3/30/2022 9:16 PM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/30/2022 8:59 PM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
>>>>>>>>>>>>>
>>>>>>>>>>>>> We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
>>>>>>>>>>>> So great Hb simulates for some k steps more than infinity.
>>>>>>>>>>>
>>>>>>>>>>> Not k more than infinity, but k more than the n steps that Ha simulates.
>>>>>>>>>> and you just said that Ha simulates to infinity because Ha is merely
>>>>>>>>>> another name for H. It is pretty ridiculously stupid to create a new
>>>>>>>>>> name for identical behavior.
>>>>>>>>>
>>>>>>>>> And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only able to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
>>>>>>>> All of those permutations are moot. We don't need to look at any of them
>>>>>>>> that get the wrong answer we only need to examine the one that gets the
>>>>>>>> right answer and then see how Ĥ plugs in to this one.
>>>>>>>
>>>>>>> So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
>>>>>>>
>>>>>>>> HHH always simulates its input until it has complete proof that this
>>>>>>>> simulated input will never reach its final state or this simulated input
>>>>>>>> reaches its final state.
>>>>>>>>
>>>>>>>> If the template of HHH cannot be refuted then that makes it irrefutable.
>>>>>>>
>>>>>>> I'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>
>>>>>> Linz and everyone here believes that deciders must base their decision
>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the actual
>>>>>> behavior specified by the actual finite string actual input.
>>>>>>
>>>>>> The definition of decider proves all of them wrong:
>>>>>> A decider maps its inputs to a final accept or reject state.
>>>>>>
>>>>>> A halt decider maps its inputs to a final accept or reject state on the
>>>>>> basis of the actual behavior actually specified by its input.
>>>>>>
>>>>>> The actual behavior actually specified by the input is measured by
>>>>>> whether or not the input could possibly reach its own final state when
>>>>>> correctly simulated by the simulating halt decider.
>>>>>
>>>>> So let's apply that criteria to the turing machine N and the simulating halt deciders Ha3 and Ha7.
>>>> It is ridiculously stupid to make breaking changes to a possibly correct
>>>> halt decider as the basis for determining whether or not this original
>>>> halt decider is correct.
>>>
>>> All I did was use your definition of what a halt decider does and what the input to a halt decider specifies and applied it to a different set of halt deciders and inputs. The conclusions:
>>>
>>> ---
>>> The behavior specified by the input <N><5> to Ha3 is measured by whether the input could possibly reach its own final state when correctly simulated by Ha3.
>> Testing to see how much one broken halt decider is broken.
>>> Since the correct pure simulation of 3 steps the input never reaches its final state of <N.qy>, Ha3 is correct to reject it.
>> IT IS NOT CORRECT TO ACCEPT IT IS INCORRECT FOR IT TO BE INTENTIONALLY
>> BROKEN.
>>
>> A broken halt decider that is broken too much for a specific input gets
>> the wrong answer.
>>
>> Here is another similar example: int Sum(int N, int M) { return 5 };
>> Sum(3,5) ---> 5; // according to you 5 is the correct answer.
>>> This does not contradict that N applied to <5> halts because it is a non-finite string non-input.
>>>
>>> The input <N><5> to Ha7 does reach its final state of <N.qy> so Ha7 is correct to accept it. This does not contradict that the input <N><5> to Ha3 is rejected because the input to Ha3 is not the actual input to Ha7 and therefore specifies a different sequence of configurations.
>>> ---
>> Same idea as using the above int Sum(int N, int M) { return 5 };
>> Sum(2,3)--->5
>>
>> A broken halt decider that is not broken too much for a specific input
>> gets the right answer.
>>> Are a direct consequence of these definitions. If you think the above is bogus, the only way for that to be possible is if your definition of "the actual behavior specified by the input" doesn't make sense, and that the behavior of the input <M><I> to a halt decider is (as specified by Linz) M applied to <I>.
>>>
>> The actual behavior actually specified by the input is measured by
>> whether or not the input could possibly reach its own final state
>> when correctly simulated by the simulating halt decider.
>>
>> when correctly simulated by the simulating halt decider.
>> when correctly simulated by the simulating halt decider.
>> when correctly simulated by the simulating halt decider.
>> Incorrectly simulated by cutting off the simulation too soon does not count.
>>> So either you stand by your definitions and accept the conclusion above that follows from it, or you accept that your alternate definition doesn't make sense and that neither Linz nor anyone else was "confused".
>> when correctly simulated by the simulating halt decider. Incorrectly
>> simulated by cutting off the simulation too soon does not count.
>>
>> Your examples simply failed to meet the required spec thus are not valid
>> counter-examples at all.
>
> So your criteria that a simulating halt decider is incorrect is that it cuts off the simulation too soon?
>
> Then let's apply that to Ha.
>
> Ha rejects <Ha^><Ha^>. But does it cut off its simulation too soon?

On 3/31/2022 9:32 AM, Dennis Bush wrote:
> On Thursday, March 31, 2022 at 10:11:43 AM UTC-4, olcott wrote:
>> On 3/31/2022 8:53 AM, Dennis Bush wrote:
>>> On Thursday, March 31, 2022 at 9:44:26 AM UTC-4, olcott wrote:
>>>> On 3/31/2022 6:51 AM, Dennis Bush wrote:
>>>>> On Wednesday, March 30, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>>>> On 3/30/2022 9:59 PM, Dennis Bush wrote:
>>>>>>> On Wednesday, March 30, 2022 at 10:52:11 PM UTC-4, olcott wrote:
>>>>>>>> On 3/30/2022 9:40 PM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/30/2022 9:16 PM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/30/2022 8:59 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
>>>>>>>>>>>>>> So great Hb simulates for some k steps more than infinity.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not k more than infinity, but k more than the n steps that Ha simulates.
>>>>>>>>>>>> and you just said that Ha simulates to infinity because Ha is merely
>>>>>>>>>>>> another name for H. It is pretty ridiculously stupid to create a new
>>>>>>>>>>>> name for identical behavior.
>>>>>>>>>>>
>>>>>>>>>>> And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only able to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
>>>>>>>>>> All of those permutations are moot. We don't need to look at any of them
>>>>>>>>>> that get the wrong answer we only need to examine the one that gets the
>>>>>>>>>> right answer and then see how Ĥ plugs in to this one.
>>>>>>>>>
>>>>>>>>> So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
>>>>>>>>>
>>>>>>>>>> HHH always simulates its input until it has complete proof that this
>>>>>>>>>> simulated input will never reach its final state or this simulated input
>>>>>>>>>> reaches its final state.
>>>>>>>>>>
>>>>>>>>>> If the template of HHH cannot be refuted then that makes it irrefutable.
>>>>>>>>>
>>>>>>>>> I'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>>>
>>>>>>>> Linz and everyone here believes that deciders must base their decision
>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the actual
>>>>>>>> behavior specified by the actual finite string actual input.
>>>>>>>>
>>>>>>>> The definition of decider proves all of them wrong:
>>>>>>>> A decider maps its inputs to a final accept or reject state.
>>>>>>>>
>>>>>>>> A halt decider maps its inputs to a final accept or reject state on the
>>>>>>>> basis of the actual behavior actually specified by its input.
>>>>>>>>
>>>>>>>> The actual behavior actually specified by the input is measured by
>>>>>>>> whether or not the input could possibly reach its own final state when
>>>>>>>> correctly simulated by the simulating halt decider.
>>>>>>>
>>>>>>> So let's apply that criteria to the turing machine N and the simulating halt deciders Ha3 and Ha7.
>>>>>> It is ridiculously stupid to make breaking changes to a possibly correct
>>>>>> halt decider as the basis for determining whether or not this original
>>>>>> halt decider is correct.
>>>>>
>>>>> All I did was use your definition of what a halt decider does and what the input to a halt decider specifies and applied it to a different set of halt deciders and inputs. The conclusions:
>>>>>
>>>>> ---
>>>>> The behavior specified by the input <N><5> to Ha3 is measured by whether the input could possibly reach its own final state when correctly simulated by Ha3.
>>>> Testing to see how much one broken halt decider is broken.
>>>>> Since the correct pure simulation of 3 steps the input never reaches its final state of <N.qy>, Ha3 is correct to reject it.
>>>> IT IS NOT CORRECT TO ACCEPT IT IS INCORRECT FOR IT TO BE INTENTIONALLY
>>>> BROKEN.
>>>>
>>>> A broken halt decider that is broken too much for a specific input gets
>>>> the wrong answer.
>>>>
>>>> Here is another similar example: int Sum(int N, int M) { return 5 };
>>>> Sum(3,5) ---> 5; // according to you 5 is the correct answer.
>>>>> This does not contradict that N applied to <5> halts because it is a non-finite string non-input.
>>>>>
>>>>> The input <N><5> to Ha7 does reach its final state of <N.qy> so Ha7 is correct to accept it. This does not contradict that the input <N><5> to Ha3 is rejected because the input to Ha3 is not the actual input to Ha7 and therefore specifies a different sequence of configurations.
>>>>> ---
>>>> Same idea as using the above int Sum(int N, int M) { return 5 };
>>>> Sum(2,3)--->5
>>>>
>>>> A broken halt decider that is not broken too much for a specific input
>>>> gets the right answer.
>>>>> Are a direct consequence of these definitions. If you think the above is bogus, the only way for that to be possible is if your definition of "the actual behavior specified by the input" doesn't make sense, and that the behavior of the input <M><I> to a halt decider is (as specified by Linz) M applied to <I>.
>>>>>
>>>> The actual behavior actually specified by the input is measured by
>>>> whether or not the input could possibly reach its own final state
>>>> when correctly simulated by the simulating halt decider.
>>>>
>>>> when correctly simulated by the simulating halt decider.
>>>> when correctly simulated by the simulating halt decider.
>>>> when correctly simulated by the simulating halt decider.
>>>> Incorrectly simulated by cutting off the simulation too soon does not count.
>>>>> So either you stand by your definitions and accept the conclusion above that follows from it, or you accept that your alternate definition doesn't make sense and that neither Linz nor anyone else was "confused".
>>>> when correctly simulated by the simulating halt decider. Incorrectly
>>>> simulated by cutting off the simulation too soon does not count.
>>>>
>>>> Your examples simply failed to meet the required spec thus are not valid
>>>> counter-examples at all.
>>>
>>> So your criteria that a simulating halt decider is incorrect is that it cuts off the simulation too soon?
>>>
>>> Then let's apply that to Ha.
>>>
>>> Ha rejects <Ha^><Ha^>. But does it cut off its simulation too soon?
>> WTF? Do you agree that smashing you car's windshield with a sledge
>> hammer is not the proper way to start the engine of your car?
>
> So that's all you're left with? Bad analogies?
>
> Because of the way you've defined what the input to a halt decider represents and what a halt decider does, you have inconsistent logic.
>
> Any logic you use to show that Ha is correct to reject <Ha^><Ha^> can also be used to show that Ha3 is correct to reject <N><5>, and any logic you use to show that Ha3 is not correct to reject <N><5> can be used to show that that Ha is not correct to reject <Ha^><Ha^>.
>
> So it looks like you're stuck between a rock and a hard place.
>
>>> If Ha3 can be shown to be incorrect by giving the input to another halt decider that simulates for more steps, we can do the same for Ha.
>>>
>> No more bullshit examples please. They are nothing more than head games.
>
> The fact that you think valid logic is a "bullshit example" or "head game" just shows how little logic you actually understand.
>
> Bottom line: a halt decider H given input <M><I> is required to report if M applied to <I> halts.

On 3/31/2022 10:31 AM, Dennis Bush wrote:
> On Thursday, March 31, 2022 at 10:48:09 AM UTC-4, olcott wrote:
>> On 3/31/2022 9:32 AM, Dennis Bush wrote:
>>> On Thursday, March 31, 2022 at 10:11:43 AM UTC-4, olcott wrote:

>>> Bottom line: a halt decider H given input <M><I> is required to report if M applied to <I> halts.
>> The correct simulation of <M><I> by the simulating halt decider at the
>> point in the execution trace where the simulating halt decider actually
>> is does demonstrate the actual behavior specified by <M><I> at this
>> point in the execution trace.
>>
>> It is merely a very persistent false assumption that a correct
>> simulation of <M><I> at some other different point in the execution
>> trace must derive identical behavior.
>> Using an alternate definition doesn't work as doing so leads to the above.
>>>
>>> Q.E.D.
>> These three points are the basis of my correct analysis.
>> (1) Linz: computation that halts … the Turing machine will halt whenever
>> it enters a final state. (Linz:1990:234)
>
> The *turning machine*, not a partial simulation of a turing machine.
>
>>
>> (2) That a correct simulation of a Turing machine description that would
>> never reach its final state is computationally equivalent to the direct
>> execution of this same Turing machine never reaching its final state.
>
> The direct execution of the turing machine Ha^ applied to <Ha^> reaches a final state, therefore the correct simulation of that turing machine would reach a final state.
>
> Hb applied to <Ha^><Ha^> reaches a final state of its input and is therefore a correct simulation. Ha applied to <Ha^><Ha^> does not reach a final state its input and is therefore not a correct simulation as demonstrated by Hb.
>
>>
>> (3) That analyzing the behavior of a correct partial simulation of some
>> of the steps of a Turing machine description can accurately predict that
>> a full simulation would never reach its final state.
>
> It *can*, but not in the case of Ha applied to <Ha^><Ha^> as demonstrated by Hb applied to <Ha^><Ha^>.
>
> As I said before :
>
> Any logic you use to show that Ha is correct to reject <Ha^><Ha^> can also be used to show that Ha3 is correct to reject <N><5>, and any logic you use to show that Ha3 is not correct to reject <N><5> can be used to show that that Ha is not correct to reject <Ha^><Ha^>.

THE PART THAT YOU IGNORED
The correct simulation of <M><I> by the simulating halt decider at the
point in the execution trace where the simulating halt decider actually
is does demonstrate the actual behavior specified by <M><I> at this
point in the execution trace.

It is merely a very persistent false assumption that a correct
simulation of <M><I> at some other different point in the execution
trace must derive identical behavior.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 10:45 AM, Dennis Bush wrote:
> On Thursday, March 31, 2022 at 11:35:11 AM UTC-4, olcott wrote:
>> On 3/31/2022 10:31 AM, Dennis Bush wrote:
>>> On Thursday, March 31, 2022 at 10:48:09 AM UTC-4, olcott wrote:
>>>> On 3/31/2022 9:32 AM, Dennis Bush wrote:
>>>>> On Thursday, March 31, 2022 at 10:11:43 AM UTC-4, olcott wrote:
>>
>>>>> Bottom line: a halt decider H given input <M><I> is required to report if M applied to <I> halts.
>>>> The correct simulation of <M><I> by the simulating halt decider at the
>>>> point in the execution trace where the simulating halt decider actually
>>>> is does demonstrate the actual behavior specified by <M><I> at this
>>>> point in the execution trace.
>>>>
>>>> It is merely a very persistent false assumption that a correct
>>>> simulation of <M><I> at some other different point in the execution
>>>> trace must derive identical behavior.
>>>> Using an alternate definition doesn't work as doing so leads to the above.
>>>>>
>>>>> Q.E.D.
>>>> These three points are the basis of my correct analysis.
>>>> (1) Linz: computation that halts … the Turing machine will halt whenever
>>>> it enters a final state. (Linz:1990:234)
>>>
>>> The *turning machine*, not a partial simulation of a turing machine.
>>>
>>>>
>>>> (2) That a correct simulation of a Turing machine description that would
>>>> never reach its final state is computationally equivalent to the direct
>>>> execution of this same Turing machine never reaching its final state.
>>>
>>> The direct execution of the turing machine Ha^ applied to <Ha^> reaches a final state, therefore the correct simulation of that turing machine would reach a final state.
>>>
>>> Hb applied to <Ha^><Ha^> reaches a final state of its input and is therefore a correct simulation. Ha applied to <Ha^><Ha^> does not reach a final state its input and is therefore not a correct simulation as demonstrated by Hb.
>>>
>>>>
>>>> (3) That analyzing the behavior of a correct partial simulation of some
>>>> of the steps of a Turing machine description can accurately predict that
>>>> a full simulation would never reach its final state.
>>>
>>> It *can*, but not in the case of Ha applied to <Ha^><Ha^> as demonstrated by Hb applied to <Ha^><Ha^>.
>>>
>>> As I said before :
>>>
>>> Any logic you use to show that Ha is correct to reject <Ha^><Ha^> can also be used to show that Ha3 is correct to reject <N><5>, and any logic you use to show that Ha3 is not correct to reject <N><5> can be used to show that that Ha is not correct to reject <Ha^><Ha^>.
>> THE PART THAT YOU IGNORED
>> The correct simulation of <M><I> by the simulating halt decider at the
>> point in the execution trace where the simulating halt decider actually
>> is does demonstrate the actual behavior specified by <M><I> at this
>> point in the execution trace.
>>
>> It is merely a very persistent false assumption that a correct
>> simulation of <M><I> at some other different point in the execution
>> trace must derive identical behavior.
>
> A fundamental property of turning machines is that they always give the same output for a given input, otherwise it's not a turing machine.

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.

DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR:
This makes the sequence of configurations of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
outside of Ĥ different than the the sequence of configurations of the
simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of configurations
will have different behavior.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>
>> Linz and everyone here believes that deciders must base their decision
>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>> actual behavior specified by the actual finite string actual input.
>
> Here's that question you would not answer without equivocating, even
> after my asking it more than 12 times in a row. André also asked many,
> many times and got no answer.
>
> What string must be passed to H so that H can tell us whether or not Ĥ
> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
> could tell us whether a particular TM does or does not halt when given
> some particular input? Isn't that what the theorem is about? (The
> answer is, of course, yes.)
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.

The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.

DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.

DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.

UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 11:50 AM, Richard Damon wrote:
>
> On 3/31/22 12:29 PM, olcott wrote:
>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>
>>>> Linz and everyone here believes that deciders must base their decision
>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>> actual behavior specified by the actual finite string actual input.
>>>
>>> Here's that question you would not answer without equivocating, even
>>> after my asking it more than 12 times in a row.  André also asked many,
>>> many times and got no answer.
>>>
>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>> applied to ⟨Ĥ⟩ halts?  Do you reject even the idea that a halt decider
>>> could tell us whether a particular TM does or does not halt when given
>>> some particular input?  Isn't that what the theorem is about?  (The
>>> answer is, of course, yes.)
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>
>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>
>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>> infinite recursion that only terminates normally because of its
>> one-way dependency relationship on embedded_H aborting the second
>> invocation of this otherwise infinite recursion.
>>
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>
>> UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
>>    embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
>>    embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
>>    embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
>>    embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>>
>
> Nope, you made a BIG mistake
>
> UTM simulatio of <H^> <H^> also begins with the H^ copies its input
> <H^0> to <H^1>
>
> Your second would be UTM simulation of <_embedded_H> <H^> <H^>
>
> Which isn't the question.
>
> You seem to forget that Turing Machine DO execute on their own.
>
>
> Yes, embedded_H applied to <H^> <H^> is a different machine from H^
> applied to <H^>, that is a given.
>
> The PROBLEM you have is that embedded_H <H^> <H^> needs to answer based
> on what H^ applied to <H^> will do, or equivalently what UTM applied to
> <H^> <H^> will do, and that is ALWAYS the same and the 'outer' level of
> that is NEVER aborted, and if embedded_H goes to Qn, the both of those
> will also go to H^.Qn and HALT< showing the ACTUAL BEHAVIOR of the
> machine reprented by the input, and thus the CORRECT answer, is HALTING.

If neither the outer level nor the inner level simulation aborts then
the simulation never stops.

If either the outer level or the inner level must abort to prevent
infinite simulation then it correctly rejects its input.

If the outer level of simulation does not abort then this is
computationally equivalent to direct execution.

If the outer level of simulation does not abort and the inner level does
abort then the only reason that the outer level halts is that the second
invocation of an otherwise infinite recursion was aborted thus
terminating what would have otherwise been infinite recursion.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 12:45 PM, Richard Damon wrote:
> On 3/31/22 1:22 PM, olcott wrote:
>> On 3/31/2022 11:50 AM, Richard Damon wrote:
>>>
>>> On 3/31/22 12:29 PM, olcott wrote:
>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>
>>>>>> Linz and everyone here believes that deciders must base their
>>>>>> decision
>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>> actual behavior specified by the actual finite string actual input.
>>>>>
>>>>> Here's that question you would not answer without equivocating, even
>>>>> after my asking it more than 12 times in a row.  André also asked
>>>>> many,
>>>>> many times and got no answer.
>>>>>
>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>> applied to ⟨Ĥ⟩ halts?  Do you reject even the idea that a halt decider
>>>>> could tell us whether a particular TM does or does not halt when given
>>>>> some particular input?  Isn't that what the theorem is about?  (The
>>>>> answer is, of course, yes.)
>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>
>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>> computationally equivalent to the direct execution of Ĥ applied to
>>>> ⟨Ĥ⟩ yet not the same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>
>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>
>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>> infinite recursion that only terminates normally because of its
>>>> one-way dependency relationship on embedded_H aborting the second
>>>> invocation of this otherwise infinite recursion.
>>>>
>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>
>>>> UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
>>>>    embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
>>>>    embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
>>>>    embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
>>>>    embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>>
>>>
>>> Nope, you made a BIG mistake
>>>
>>> UTM simulatio of <H^> <H^> also begins with the H^ copies its input
>>> <H^0> to <H^1>
>>>
>>> Your second would be UTM simulation of <_embedded_H> <H^> <H^>
>>>
>>> Which isn't the question.
>>>
>>> You seem to forget that Turing Machine DO execute on their own.
>>>
>>>
>>> Yes, embedded_H applied to <H^> <H^> is a different machine from H^
>>> applied to <H^>, that is a given.
>>>
>>> The PROBLEM you have is that embedded_H <H^> <H^> needs to answer
>>> based on what H^ applied to <H^> will do, or equivalently what UTM
>>> applied to <H^> <H^> will do, and that is ALWAYS the same and the
>>> 'outer' level of that is NEVER aborted, and if embedded_H goes to Qn,
>>> the both of those will also go to H^.Qn and HALT< showing the ACTUAL
>>> BEHAVIOR of the machine reprented by the input, and thus the CORRECT
>>> answer, is HALTING.
>>
>> If neither the outer level nor the inner level simulation aborts then
>> the simulation never stops.
>
> Right. But the H / embedded_H fails to answer.
>

Right so that scenario must be rejected because the halt decider must
itself halt.

>>
>> If either the outer level or the inner level must abort to prevent
>> infinite simulation then it correctly rejects its input.
>>
>
> THE OUTER LEVEL CAN'T abort, because it was defined to be a UTM, which
> never aborts.

If the outer-level is stipulated to be a UTM then it cannot abort.

> If the inner one aborts, because it is the simulating, the outer one
> Halts, and shows the input to be HALTING and thus the decider to be
> WRONG, and NOT correct.
>

These are the permutations that I am examining:
UTM UTM -> never halts
SHD UTM -> SHD correctly rejects
UTM SHD -> SHD correctly rejects
SHD SHD -> SHD correctly rejects

> FAIL.
>
>> If the outer level of simulation does not abort then this is
>> computationally equivalent to direct execution.
>
> Right.
>
>>
>> If the outer level of simulation does not abort and the inner level
>> does abort then the only reason that the outer level halts is that the
>> second invocation of an otherwise infinite recursion was aborted thus
>> terminating what would have otherwise been infinite recursion.
>>
>>
>
> WRONG. Halting is Halting, It doesn't look at 'reason'.
>
> FAIL.

Sure it does. If there is conditional branch on one path and no
conditional branch on the other path then the behavior will vary between
paths.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 1:14 PM, Richard Damon wrote:
> On 3/31/22 1:57 PM, olcott wrote:
>> On 3/31/2022 12:45 PM, Richard Damon wrote:
>>> On 3/31/22 1:22 PM, olcott wrote:
>>>> On 3/31/2022 11:50 AM, Richard Damon wrote:
>>>>>
>>>>> On 3/31/22 12:29 PM, olcott wrote:
>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>>>
>>>>>>>> Linz and everyone here believes that deciders must base their
>>>>>>>> decision
>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>>>> actual behavior specified by the actual finite string actual input.
>>>>>>>
>>>>>>> Here's that question you would not answer without equivocating, even
>>>>>>> after my asking it more than 12 times in a row.  André also asked
>>>>>>> many,
>>>>>>> many times and got no answer.
>>>>>>>
>>>>>>> What string must be passed to H so that H can tell us whether or
>>>>>>> not Ĥ
>>>>>>> applied to ⟨Ĥ⟩ halts?  Do you reject even the idea that a halt
>>>>>>> decider
>>>>>>> could tell us whether a particular TM does or does not halt when
>>>>>>> given
>>>>>>> some particular input?  Isn't that what the theorem is about?  (The
>>>>>>> answer is, of course, yes.)
>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>
>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>>>> computationally equivalent to the direct execution of Ĥ applied to
>>>>>> ⟨Ĥ⟩ yet not the same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>
>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>
>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>>>> infinite recursion that only terminates normally because of its
>>>>>> one-way dependency relationship on embedded_H aborting the second
>>>>>> invocation of this otherwise infinite recursion.
>>>>>>
>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>
>>>>>> UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
>>>>>>    embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
>>>>>>    embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>
>>>>>> UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
>>>>>>    embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
>>>>>>    embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>
>>>>>>
>>>>>
>>>>> Nope, you made a BIG mistake
>>>>>
>>>>> UTM simulatio of <H^> <H^> also begins with the H^ copies its input
>>>>> <H^0> to <H^1>
>>>>>
>>>>> Your second would be UTM simulation of <_embedded_H> <H^> <H^>
>>>>>
>>>>> Which isn't the question.
>>>>>
>>>>> You seem to forget that Turing Machine DO execute on their own.
>>>>>
>>>>>
>>>>> Yes, embedded_H applied to <H^> <H^> is a different machine from H^
>>>>> applied to <H^>, that is a given.
>>>>>
>>>>> The PROBLEM you have is that embedded_H <H^> <H^> needs to answer
>>>>> based on what H^ applied to <H^> will do, or equivalently what UTM
>>>>> applied to <H^> <H^> will do, and that is ALWAYS the same and the
>>>>> 'outer' level of that is NEVER aborted, and if embedded_H goes to
>>>>> Qn, the both of those will also go to H^.Qn and HALT< showing the
>>>>> ACTUAL BEHAVIOR of the machine reprented by the input, and thus the
>>>>> CORRECT answer, is HALTING.
>>>>
>>>> If neither the outer level nor the inner level simulation aborts
>>>> then the simulation never stops.
>>>
>>> Right. But the H / embedded_H fails to answer.
>>>
>>
>> Right so that scenario must be rejected because the halt decider must
>> itself halt.
>>
>
> Not so much 'rejected' as shows that design of a Halt Decider doesn't work.
>
>>>>
>>>> If either the outer level or the inner level must abort to prevent
>>>> infinite simulation then it correctly rejects its input.
>>>>
>>>
>>> THE OUTER LEVEL CAN'T abort, because it was defined to be a UTM,
>>> which never aborts.
>>
>> If the outer-level is stipulated to be a UTM then it cannot abort.
>>
>>> If the inner one aborts, because it is the simulating, the outer one
>>> Halts, and shows the input to be HALTING and thus the decider to be
>>> WRONG, and NOT correct.
>>>
>>
>> These are the permutations that I am examining:
>> UTM  UTM -> never halts
>> SHD  UTM -> SHD correctly rejects
>> UTM  SHD -> SHD correctly rejects
>> SHD  SHD -> SHD correctly rejects
>>
>
> No, you are just babbling, they are NOT correct.
>
> The ONLY case that actually matters is UTM SHD, as in UTM <H^> <H^>
> which then inside the simulation of H^, we see the SHD of H.
>
> The second item is NEVER a UTM, as you just agreed that H can't be just
> a UTM (or if it is, it just proves the SHD that is a UTM fails). You
> NEVER 'replace' the SHD with a UTM to look at the behavior of the input,
> that is just an incorrect simulation.
>
> Since UTM <H^> <H^> halts, the ONLY correct answer for SHD <H^> <H^> is
> halting (Qy) which is Not what it does.
>
> FAIL
>
>>
>>> FAIL.
>>>
>>>> If the outer level of simulation does not abort then this is
>>>> computationally equivalent to direct execution.
>>>
>>> Right.
>>>
>>>>
>>>> If the outer level of simulation does not abort and the inner level
>>>> does abort then the only reason that the outer level halts is that
>>>> the second invocation of an otherwise infinite recursion was aborted
>>>> thus terminating what would have otherwise been infinite recursion.
>>>>
>>>>
>>>
>>> WRONG. Halting is Halting, It doesn't look at 'reason'.
>>>
>>> FAIL.
>>
>> Sure it does. If there is conditional branch on one path and no
>> conditional branch on the other path then the behavior will vary
>> between paths.
>>
>
> You are just being silly.
>
> You are talking about two copies of the exact same thing.
>
> One can't have a condition the other doesn't have. That just shows you
> are totally ignorant about what you are talking about.

The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.

The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.

That there is conditional branch on one path and no conditional branch
on the other path makes the behavior vary between paths.

That there is conditional branch on one path and no conditional branch
on the other path makes the behavior vary between paths.

That there is conditional branch on one path and no conditional branch
on the other path makes the behavior vary between paths.

Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H. The
simulated ⟨Ĥ⟩ ⟨Ĥ⟩ cannot reach the point of this dependency.

On 3/31/2022 3:15 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>> infinite recursion that only terminates normally because of its
>> one-way dependency relationship on embedded_H aborting the second
>> invocation of this otherwise infinite recursion.
>
> This is the old "it only halts because" ruse...
>
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR:
>> This makes the sequence of configurations of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>> outside of Ĥ different than the the sequence of configurations of the
>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of
>> configurations will have different behavior.
>
> But this is magic PO-machines again. I thought you had decided that was
> a non-starter?
>

DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.

That there is conditional branch on one path and no conditional branch
on the other path makes the behavior vary between paths.

Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H.
The simulated ⟨Ĥ⟩ ⟨Ĥ⟩ cannot reach the point of this dependency.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 7:09 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/31/2022 3:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>> infinite recursion that only terminates normally because of its
>>>> one-way dependency relationship on embedded_H aborting the second
>>>> invocation of this otherwise infinite recursion.
>>> This is the old "it only halts because" ruse...
>>>
>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR:
>>>> This makes the sequence of configurations of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> outside of Ĥ different than the the sequence of configurations of the
>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of
>>>> configurations will have different behavior.
>>>
>>> But this is magic PO-machines again. I thought you had decided that was
>>> a non-starter?
>>
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>
>> That there is conditional branch on one path and no conditional branch
>> on the other path makes the behavior vary between paths.
>>
>> Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H.
>
> Yes, you are clear that
>
> Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>
> but please complete the following line for me:
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.q?
>

Not until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 7:09 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/31/2022 3:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>> infinite recursion that only terminates normally because of its
>>>> one-way dependency relationship on embedded_H aborting the second
>>>> invocation of this otherwise infinite recursion.
>>> This is the old "it only halts because" ruse...
>>>
>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR:
>>>> This makes the sequence of configurations of the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> outside of Ĥ different than the the sequence of configurations of the
>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of
>>>> configurations will have different behavior.
>>>
>>> But this is magic PO-machines again. I thought you had decided that was
>>> a non-starter?
>>
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>
>> That there is conditional branch on one path and no conditional branch
>> on the other path makes the behavior vary between paths.
>>
>> Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H.
>
> Yes, you are clear that
>
> Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>
> but please complete the following line for me:
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.q?
>

Not until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis
that the correctly simulated input to embedded_H would never reach its
own final state.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>
>>>> Linz and everyone here believes that deciders must base their decision
>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>> actual behavior specified by the actual finite string actual input.
>>> Here's that question you would not answer without equivocating, even
>>> after my asking it more than 12 times in a row. André also asked many,
>>> many times and got no answer.
>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
>>> could tell us whether a particular TM does or does not halt when given
>>> some particular input? Isn't that what the theorem is about? (The
>>> answer is, of course, yes.)
>
>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>
>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>
> Failure to answer number one (or 13 if you count my previous attempts).
> Here's the question in case you missed it:
>
> What string must be passed to H so that H can tell us whether or not Ĥ
> applied to ⟨Ĥ⟩ halts?

I worked out many of the details of this, and can see why you believe it
is an important point, I will not begin to discuss this

until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis that
the correctly simulated input to embedded_H would never reach its own
final state in any finite number of simulated steps.

--
Copyright 2022 Pete Olcott

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

On 3/31/2022 8:57 PM, Richard Damon wrote:
> On 3/31/22 9:40 PM, olcott wrote:
>> On 3/31/2022 8:37 PM, Richard Damon wrote:
>>> On 3/31/22 9:18 PM, olcott wrote:
>>>> On 3/31/2022 7:09 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/31/2022 3:15 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>>>>>> infinite recursion that only terminates normally because of its
>>>>>>>> one-way dependency relationship on embedded_H aborting the second
>>>>>>>> invocation of this otherwise infinite recursion.
>>>>>>> This is the old "it only halts because" ruse...
>>>>>>>
>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR:
>>>>>>>> This makes the sequence of configurations of the simulation of
>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> outside of Ĥ different than the the sequence of configurations
>>>>>>>> of the
>>>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of
>>>>>>>> configurations will have different behavior.
>>>>>>>
>>>>>>> But this is magic PO-machines again.  I thought you had decided
>>>>>>> that was
>>>>>>> a non-starter?
>>>>>>
>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>
>>>>>> That there is conditional branch on one path and no conditional
>>>>>> branch
>>>>>> on the other path makes the behavior vary between paths.
>>>>>>
>>>>>> Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H.
>>>>>
>>>>> Yes, you are clear that
>>>>>
>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>
>>>>> but please complete the following line for me:
>>>>>
>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.q?
>>>>>
>>>>
>>>> Not until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis
>>>> that the correctly simulated input to embedded_H would never reach
>>>> its own final state.
>>>>
>>>
>>> Since that isn't True, you are asking for a lot.
>>
>> It is true on the basis that I provided and every other basis is
>> incorrect.
>>
>
> Nope, the DEFINITION is correct, because it is the DEFINITION.

The way that you are construing that definition contradicts its computer
science component parts:

CORRECT DEFINITION OF HALT DECIDING CRITERIA

(1) All deciders compute the mapping of their input finite strings to an
accept or reject state.

(2) The direct execution of a Turing machine is computationally
equivalent to the UTM simulation of its Turing machine description.

(3) Halt deciders compute the mapping of their input finite strings to
an accept or reject state on the basis of the actual behavior specified
by their input.

(4) The actual behavior specified by the input is measured by the
behavior of a UTM simulation of this input at the same point in the
execution trace as the simulating halt decider. (defined in (2) above)

(5) Linz: computation that halts … the Turing machine will halt whenever
it enters a final state. (Linz:1990:234)

(6) A correct simulation of a Turing machine description that would
never reach its final state is computationally equivalent to the direct
execution of this same Turing machine never reaching its final state and
thus specifies a non-halting sequence of configurations.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 6:36 AM, Dennis Bush wrote:
> On Thursday, March 31, 2022 at 11:47:35 PM UTC-4, olcott wrote:
>> On 3/31/2022 10:16 PM, Dennis Bush wrote:
>>> On Thursday, March 31, 2022 at 11:10:00 PM UTC-4, olcott wrote:
>>>> On 3/31/2022 9:34 PM, Dennis Bush wrote:
>>>>> On Thursday, March 31, 2022 at 10:30:04 PM UTC-4, olcott wrote:
>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>> On Thursday, March 31, 2022 at 9:52:15 PM UTC-4, olcott wrote:
>>>>>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>>>>>>>
>>>>>>>>>>>> Linz and everyone here believes that deciders must base their decision
>>>>>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>>>>>>>> actual behavior specified by the actual finite string actual input.
>>>>>>>>>>> Here's that question you would not answer without equivocating, even
>>>>>>>>>>> after my asking it more than 12 times in a row. André also asked many,
>>>>>>>>>>> many times and got no answer.
>>>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
>>>>>>>>>>> could tell us whether a particular TM does or does not halt when given
>>>>>>>>>>> some particular input? Isn't that what the theorem is about? (The
>>>>>>>>>>> answer is, of course, yes.)
>>>>>>>>>
>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>>>>>
>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>>>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>>>>>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>>>>
>>>>>>>>> Failure to answer number one (or 13 if you count my previous attempts).
>>>>>>>>> Here's the question in case you missed it:
>>>>>>>>>
>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>> I worked out many of the details of this, and can see why you believe it
>>>>>>>> is an important point, I will not begin to discuss this
>>>>>>>> until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis that
>>>>>>>> the correctly simulated input to embedded_H would never reach its own
>>>>>>>> final state in any finite number of simulated steps.
>>>>>>>
>>>>>>> embedded_Ha, and therefore Ha, is not correct to reject <Ha^><Ha^> because it quits its simulation after n steps which is too soon. When this same input is given to simulating halt decider Hb which simulates for n+k steps, the input does reach its final state after n+k steps and Hb accepts <Ha^><Ha^>. Therefore Ha, and subsequently embedded_Ha, does *not* correctly simulate its input.
>>>>>> I will simply say that I am ignoring another strawman error.
>>>>>
>>>>> Just saying "strawman" isn't good enough.
>>>> I am only talking about Ĥ applied ⟨Ĥ⟩ and its associated semantics any
>>>> change in notation or semantics is off topic.
>>>>
>>>> I am sure that you can make a million halt deciders that don't work they
>>>> are all strawman.
>>>
>>> So you can't explain why Hb is wrong, and have therefore implicitly admitted it is correct.
>>>
>>> So what are you doing to do now that your proof has been refuted?
>> That you can make up some screwy thing that doesn't work says nothing
>> about my proof. If you were talking about my proof then you have to use
>> my notation, my semantics and find an error in that.
>
> How exactly is it that Hb "doesn't work"?
>
> When you talk about H / embedded_H that "correctly" reports non-halting for H^, you're talking about an H that aborts it's simulation. That's Ha / embedded_Ha and Ha^ is built from that. What I said still stands. So state why Hb is wrong or admit failure.
>

On 3/31/2022 9:23 PM, Dennis Bush wrote:
> embedded_Ha, and therefore Ha, is not correct to reject <Ha^><Ha^>
because it quits its simulation after n steps which is too soon. When
this same input is given to simulating halt decider Hb which simulates
for n+k steps, the input does reach its final state after n+k steps and
Hb accepts <Ha^><Ha^>. Therefore Ha, and subsequently embedded_Ha, does
*not* correctly simulate its input.

It is like I talk about driving my car to show that my car can be driven
so you drive a car into a tree to show that a car cannot be driven.

Here are the simplified notational conventions and semantics:
(Any attempt to diverge from the specified semantics will be construed
as the strawman error and marked as ignored)

We will just call the halt decider H:
H ⟨p⟩ ⟨i⟩ ⊢* H.qy iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final state
H ⟨p⟩ ⟨i⟩ ⊢* H.qn iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach its
final state

Simplified Ĥ directly calls H --- infinite loop has been removed.
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 5:10 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>
>>>>>> Linz and everyone here believes that deciders must base their decision
>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>> actual behavior specified by the actual finite string actual input.
>>>>> Here's that question you would not answer without equivocating, even
>>>>> after my asking it more than 12 times in a row. André also asked many,
>>>>> many times and got no answer.
>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
>>>>> could tell us whether a particular TM does or does not halt when given
>>>>> some particular input? Isn't that what the theorem is about? (The
>>>>> answer is, of course, yes.)
>>>
>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>
>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>
>>> Failure to answer number one (or 13 if you count my previous attempts).
>>>
>>> Here's the question in case you missed it:
>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>> applied to ⟨Ĥ⟩ halts?
>>
>> I worked out many of the details of this, and can see why you believe
>> it is an important point, I will not begin to discuss this until after
>> you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis that the
>> correctly simulated input to embedded_H would never reach its own
>> final state in any finite number of simulated steps.
>
> Failure to answer number two (well, 14). It's a simple question and
> it's central what the halting problem is, but it's also central to why
> you are wrong, which is why you know you must avoid answering it.
>

CORRECT DEFINITION OF HALT DECIDING CRITERIA

(1) All deciders compute the mapping of their input finite strings to an
accept or reject state.

(2) The direct execution of a Turing machine is computationally
equivalent to the UTM simulation of its Turing machine description.

(3) Halt deciders compute the mapping of their input finite strings to
an accept or reject state on the basis of the actual behavior specified
by their input.

(4) The actual behavior specified by the input is measured by the
behavior of a UTM simulation of this input at the same point in the
execution trace as the simulating halt decider. (defined in (2) above)

(5) Linz: computation that halts … the Turing machine will halt whenever
it enters a final state. (Linz:1990:234)

(6) A correct simulation of a Turing machine description that would
never reach its final state is computationally equivalent to the direct
execution of this same Turing machine never reaching its final state and
thus specifies a non-halting sequence of configurations.

The above CORRECT DEFINITION OF HALT DECIDING CRITERIA

Along with these simplified notation conventions

H ⟨p⟩ ⟨i⟩ ⊢* H.qy iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final state
H ⟨p⟩ ⟨i⟩ ⊢* H.qn iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach its
final state

Simplified Ĥ directly calls H --- infinite loop has been removed.
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

Proves that Ĥ ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn is correct.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 7:40 AM, Richard Damon wrote:
> On 4/1/22 8:24 AM, olcott wrote:
>> On 4/1/2022 5:10 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>>>
>>>>>>>> Linz and everyone here believes that deciders must base their
>>>>>>>> decision
>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>>>> actual behavior specified by the actual finite string actual input.
>>>>>>> Here's that question you would not answer without equivocating, even
>>>>>>> after my asking it more than 12 times in a row.  André also asked
>>>>>>> many,
>>>>>>> many times and got no answer.
>>>>>>> What string must be passed to H so that H can tell us whether or
>>>>>>> not Ĥ
>>>>>>> applied to ⟨Ĥ⟩ halts?  Do you reject even the idea that a halt
>>>>>>> decider
>>>>>>> could tell us whether a particular TM does or does not halt when
>>>>>>> given
>>>>>>> some particular input?  Isn't that what the theorem is about?  (The
>>>>>>> answer is, of course, yes.)
>>>>>
>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>
>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>>>> computationally
>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>
>>>>> Failure to answer number one (or 13 if you count my previous
>>>>> attempts).
>>>>>
>>>>> Here's the question in case you missed it:
>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>> applied to ⟨Ĥ⟩ halts?
>>>>
>>>> I worked out many of the details of this, and can see why you believe
>>>> it is an important point, I will not begin to discuss this until after
>>>> you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis that the
>>>> correctly simulated input to embedded_H would never reach its own
>>>> final state in any finite number of simulated steps.
>>>
>>> Failure to answer number two (well, 14).  It's a simple question and
>>> it's central what the halting problem is, but it's also central to why
>>> you are wrong, which is why you know you must avoid answering it.
>>>
>>
>> CORRECT DEFINITION OF HALT DECIDING CRITERIA
>>
>> (1) All deciders compute the mapping of their input finite strings to
>> an accept or reject state.
>>
>> (2) The direct execution of a Turing machine is computationally
>> equivalent to the UTM simulation of its Turing machine description.
>>
>> (3) Halt deciders compute the mapping of their input finite strings to
>> an accept or reject state on the basis of the actual behavior
>> specified by their input.
>>
>> (4) The actual behavior specified by the input is measured by the
>> behavior of a UTM simulation of this input at the same point in the
>> execution trace as the simulating halt decider. (defined in (2) above)
>
> Meaningless statement, as the UTM simulation of an input will ALWAYS be
> the same, regardless of 'point in the execution trace'
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
UTM ⟨Ĥ⟩ ⟨Ĥ⟩ derives a different result than

Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
Ĥ ⟨Ĥ⟩

>>
>> (5) Linz: computation that halts … the Turing machine will halt
>> whenever it enters a final state. (Linz:1990:234)
>>
>> (6) A correct simulation of a Turing machine description that would
>> never reach its final state is computationally equivalent to the
>> direct execution of this same Turing machine never reaching its final
>> state and thus specifies a non-halting sequence of configurations.
>>
>> The above CORRECT DEFINITION OF HALT DECIDING CRITERIA
>>
>> Along with these simplified notation conventions
>>
>> H ⟨p⟩ ⟨i⟩ ⊢* H.qy   iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final state
> (7) Mark for below
>> H ⟨p⟩ ⟨i⟩ ⊢* H.qn   iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach its
>> final state
>>
>> Simplified Ĥ directly calls H --- infinite loop has been removed.
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>
>> Proves that Ĥ ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn is correct.
>>
>
> No, it doesn't. By (7) H applied to <H^> <H^> -> H.Qn is correct only if
> UTM simulation of <H^< <H^> would never reach its final state.

You are applying the UTM at the wrong point in the execution trace as
shown above. H remains in pure UTM mode until it has proof that its
simulated input will never reach its final state.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 7:48 AM, Richard Damon wrote:
> On 3/31/22 11:06 PM, olcott wrote:
>> On 3/31/2022 8:57 PM, Richard Damon wrote:
>>> On 3/31/22 9:40 PM, olcott wrote:
>>>> On 3/31/2022 8:37 PM, Richard Damon wrote:
>>>>> On 3/31/22 9:18 PM, olcott wrote:
>>>>>> On 3/31/2022 7:09 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/31/2022 3:15 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
>>>>>>>>>> infinite recursion that only terminates normally because of its
>>>>>>>>>> one-way dependency relationship on embedded_H aborting the second
>>>>>>>>>> invocation of this otherwise infinite recursion.
>>>>>>>>> This is the old "it only halts because" ruse...
>>>>>>>>>
>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT
>>>>>>>>>> BEHAVIOR:
>>>>>>>>>> This makes the sequence of configurations of the simulation of
>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> outside of Ĥ different than the the sequence of configurations
>>>>>>>>>> of the
>>>>>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of
>>>>>>>>>> configurations will have different behavior.
>>>>>>>>>
>>>>>>>>> But this is magic PO-machines again.  I thought you had decided
>>>>>>>>> that was
>>>>>>>>> a non-starter?
>>>>>>>>
>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>>>
>>>>>>>> That there is conditional branch on one path and no conditional
>>>>>>>> branch
>>>>>>>> on the other path makes the behavior vary between paths.
>>>>>>>>
>>>>>>>> Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H.
>>>>>>>
>>>>>>> Yes, you are clear that
>>>>>>>
>>>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>
>>>>>>> but please complete the following line for me:
>>>>>>>
>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.q?
>>>>>>>
>>>>>>
>>>>>> Not until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the
>>>>>> basis that the correctly simulated input to embedded_H would never
>>>>>> reach its own final state.
>>>>>>
>>>>>
>>>>> Since that isn't True, you are asking for a lot.
>>>>
>>>> It is true on the basis that I provided and every other basis is
>>>> incorrect.
>>>>
>>>
>>> Nope, the DEFINITION is correct, because it is the DEFINITION.
>>
>> The way that you are construing that definition contradicts its
>> computer science component parts:
>>
>> CORRECT DEFINITION OF HALT DECIDING CRITERIA
>>
>> (1) All deciders compute the mapping of their input finite strings to
>> an accept or reject state.
>
>
> Right, so H needs to map <H^> <H^> to Qy or Qn.

YES

>
>>
>> (2) The direct execution of a Turing machine is computationally
>> equivalent to the UTM simulation of its Turing machine description.
>
> Right.
>

YES

>>
>> (3) Halt deciders compute the mapping of their input finite strings to
>> an accept or reject state on the basis of the actual behavior
>> specified by their input.
>
> Right.

YES

>>
>> (4) The actual behavior specified by the input is measured by the
>> behavior of a UTM simulation of this input at the same point in the
>> execution trace as the simulating halt decider. (defined in (2) above)
>
> Nonsense statement since the UTM simulation of a string is ALWAYS the
> same regardless of 'point in the execution trace'
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
UTM ⟨Ĥ⟩ ⟨Ĥ⟩ derives a different result than

Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
Ĥ ⟨Ĥ⟩

>
>>
>> (5) Linz: computation that halts … the Turing machine will halt
>> whenever it enters a final state. (Linz:1990:234)
>
> Right, the TURING Machine, that is H^ applied to <H^> is the measure
>

WRONG

>>
>> (6) A correct simulation of a Turing machine description that would
>> never reach its final state is computationally equivalent to the
>> direct execution of this same Turing machine never reaching its final
>> state and thus specifies a non-halting sequence of configurations.
>>
>
> Right, if the direct execution would never halt, then the UTM simulation
> would never halt.
>

If the UTM simulation by H in pure UTM mode would never halt then H
correctly rejects.

>
> You seemed to have forgetten to prove something.

Until mutual agreement occurs on the above points no additional
elaboration will be discussed.

There must be mutual agreement on all of the key things that I currently
have correctly as a mandatory prerequisite to future dialogue.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 7:52 AM, Richard Damon wrote:
> On 4/1/22 8:08 AM, olcott wrote:
>> On 4/1/2022 6:36 AM, Dennis Bush wrote:
>>> On Thursday, March 31, 2022 at 11:47:35 PM UTC-4, olcott wrote:
>>>> On 3/31/2022 10:16 PM, Dennis Bush wrote:
>>>>> On Thursday, March 31, 2022 at 11:10:00 PM UTC-4, olcott wrote:
>>>>>> On 3/31/2022 9:34 PM, Dennis Bush wrote:
>>>>>>> On Thursday, March 31, 2022 at 10:30:04 PM UTC-4, olcott wrote:
>>>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, March 31, 2022 at 9:52:15 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE
>>>>>>>>>>>>>> REJECTED:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Linz and everyone here believes that deciders must base
>>>>>>>>>>>>>> their decision
>>>>>>>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> over-ruling the
>>>>>>>>>>>>>> actual behavior specified by the actual finite string
>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>> Here's that question you would not answer without
>>>>>>>>>>>>> equivocating, even
>>>>>>>>>>>>> after my asking it more than 12 times in a row. André also
>>>>>>>>>>>>> asked many,
>>>>>>>>>>>>> many times and got no answer.
>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a
>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>> could tell us whether a particular TM does or does not halt
>>>>>>>>>>>>> when given
>>>>>>>>>>>>> some particular input? Isn't that what the theorem is
>>>>>>>>>>>>> about? (The
>>>>>>>>>>>>> answer is, of course, yes.)
>>>>>>>>>>>
>>>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT
>>>>>>>>>>>> BEHAVIOR.
>>>>>>>>>>>>
>>>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>>>>>>>>>> computationally
>>>>>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet
>>>>>>>>>>>> not the
>>>>>>>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>>>>>>
>>>>>>>>>>> Failure to answer number one (or 13 if you count my previous
>>>>>>>>>>> attempts).
>>>>>>>>>>> Here's the question in case you missed it:
>>>>>>>>>>>
>>>>>>>>>>> What string must be passed to H so that H can tell us whether
>>>>>>>>>>> or not Ĥ
>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>> I worked out many of the details of this, and can see why you
>>>>>>>>>> believe it
>>>>>>>>>> is an important point, I will not begin to discuss this
>>>>>>>>>> until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the
>>>>>>>>>> basis that
>>>>>>>>>> the correctly simulated input to embedded_H would never reach
>>>>>>>>>> its own
>>>>>>>>>> final state in any finite number of simulated steps.
>>>>>>>>>
>>>>>>>>> embedded_Ha, and therefore Ha, is not correct to reject
>>>>>>>>> <Ha^><Ha^> because it quits its simulation after n steps which
>>>>>>>>> is too soon. When this same input is given to simulating halt
>>>>>>>>> decider Hb which simulates for n+k steps, the input does reach
>>>>>>>>> its final state after n+k steps and Hb accepts <Ha^><Ha^>.
>>>>>>>>> Therefore Ha, and subsequently embedded_Ha, does *not*
>>>>>>>>> correctly simulate its input.
>>>>>>>> I will simply say that I am ignoring another strawman error.
>>>>>>>
>>>>>>> Just saying "strawman" isn't good enough.
>>>>>> I am only talking about Ĥ applied ⟨Ĥ⟩ and its associated semantics
>>>>>> any
>>>>>> change in notation or semantics is off topic.
>>>>>>
>>>>>> I am sure that you can make a million halt deciders that don't
>>>>>> work they
>>>>>> are all strawman.
>>>>>
>>>>> So you can't explain why Hb is wrong, and have therefore implicitly
>>>>> admitted it is correct.
>>>>>
>>>>> So what are you doing to do now that your proof has been refuted?
>>>> That you can make up some screwy thing that doesn't work says nothing
>>>> about my proof. If you were talking about my proof then you have to use
>>>> my notation, my semantics and find an error in that.
>>>
>>> How exactly is it that Hb "doesn't work"?
>>>
>>> When you talk about H / embedded_H that "correctly" reports
>>> non-halting for H^, you're talking about an H that aborts it's
>>> simulation.  That's Ha / embedded_Ha and Ha^ is built from that.
>>> What I said still stands.  So state why Hb is wrong or admit failure.
>>>
>>
>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>  > embedded_Ha, and therefore Ha, is not correct to reject <Ha^><Ha^>
>> because it quits its simulation after n steps which is too soon.  When
>> this same input is given to simulating halt decider Hb which simulates
>> for n+k steps, the input does reach its final state after n+k steps
>> and Hb accepts <Ha^><Ha^>.  Therefore Ha, and subsequently
>> embedded_Ha, does *not* correctly simulate its input.
>>
>> It is like I talk about driving my car to show that my car can be
>> driven so you drive a car into a tree to show that a car cannot be
>> driven.
>>
>> Here are the simplified notational conventions and semantics:
>> (Any attempt to diverge from the specified semantics will be construed
>> as the strawman error and marked as ignored)
>>
>> We will just call the halt decider H:
>> H ⟨p⟩ ⟨i⟩ ⊢* H.qy   iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final state
>> H ⟨p⟩ ⟨i⟩ ⊢* H.qn   iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach its
>> final state
>>
>> Simplified Ĥ directly calls H --- infinite loop has been removed.
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>
>
> THe problem with your 'simplified' H^ is that a smart H could just
> answer by going to Qy and be correct, but since yours doesn't, that
> isn't a fatal flaw to your argument.
>
> H -> Qn is PROVED incorrect, as BY THE DEFINITION H <p> <i> -> H.Qn only
> if UTM simulaton of <p> <i> will never halt, but we show that since UTM
> simulation of <H^> <H^> is the same as H^ applied to <H^> and that goes
> to H.Qn and HALTS, so does the UTM Simulation.
>

On 4/1/2022 8:52 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/1/2022 5:10 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>>>
>>>>>>>> Linz and everyone here believes that deciders must base their decision
>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>>>> actual behavior specified by the actual finite string actual input.
>>>>>>> Here's that question you would not answer without equivocating, even
>>>>>>> after my asking it more than 12 times in a row. André also asked many,
>>>>>>> many times and got no answer.
>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
>>>>>>> could tell us whether a particular TM does or does not halt when given
>>>>>>> some particular input? Isn't that what the theorem is about? (The
>>>>>>> answer is, of course, yes.)
>>>>>
>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>
>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>
>>>>> Failure to answer number one (or 13 if you count my previous attempts).
>>>>>
>>>>> Here's the question in case you missed it:
>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>> applied to ⟨Ĥ⟩ halts?
>>>>
>>>> I worked out many of the details of this, and can see why you believe
>>>> it is an important point, I will not begin to discuss this until after
>>>> you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis that the
>>>> correctly simulated input to embedded_H would never reach its own
>>>> final state in any finite number of simulated steps.
>>>
>>> Failure to answer number two (well, 14). It's a simple question and
>>> it's central what the halting problem is, but it's also central to why
>>> you are wrong, which is why you know you must avoid answering it.
>>>
>>
>> CORRECT DEFINITION OF HALT DECIDING CRITERIA
>
> ...
>
> Failure to answer number three (15 including previous attempts). We all
> know why you are avoiding it. Here it is again:
>
> What string must be passed to H so that H can tell us whether or not Ĥ
> applied to ⟨Ĥ⟩ halts?
>

I will not tolerate any additional steps in the dialogue until we attain
mutual agreement on the current steps.

My reviewers must pay the cost of an honest dialogue for any dialogue to
continue.

A one-way dialogue that only receives denigration and no points of
mutual agreement is not worth the cost of my limited time.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 8:59 AM, Richard Damon wrote:
> On 4/1/22 9:20 AM, olcott wrote:
>> On 4/1/2022 7:48 AM, Richard Damon wrote:
>>> On 3/31/22 11:06 PM, olcott wrote:
>>>> On 3/31/2022 8:57 PM, Richard Damon wrote:
>>>>> On 3/31/22 9:40 PM, olcott wrote:
>>>>>> On 3/31/2022 8:37 PM, Richard Damon wrote:
>>>>>>> On 3/31/22 9:18 PM, olcott wrote:
>>>>>>>> On 3/31/2022 7:09 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/31/2022 3:15 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> The directly executed Ĥ applied to ⟨Ĥ⟩ is the first
>>>>>>>>>>>> invocation of
>>>>>>>>>>>> infinite recursion that only terminates normally because of its
>>>>>>>>>>>> one-way dependency relationship on embedded_H aborting the
>>>>>>>>>>>> second
>>>>>>>>>>>> invocation of this otherwise infinite recursion.
>>>>>>>>>>> This is the old "it only halts because" ruse...
>>>>>>>>>>>
>>>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT
>>>>>>>>>>>> BEHAVIOR:
>>>>>>>>>>>> This makes the sequence of configurations of the simulation
>>>>>>>>>>>> of ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> outside of Ĥ different than the the sequence of
>>>>>>>>>>>> configurations of the
>>>>>>>>>>>> simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ. Different sequences of
>>>>>>>>>>>> configurations will have different behavior.
>>>>>>>>>>>
>>>>>>>>>>> But this is magic PO-machines again.  I thought you had
>>>>>>>>>>> decided that was
>>>>>>>>>>> a non-starter?
>>>>>>>>>>
>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT
>>>>>>>>>> BEHAVIOR.
>>>>>>>>>>
>>>>>>>>>> That there is conditional branch on one path and no
>>>>>>>>>> conditional branch
>>>>>>>>>> on the other path makes the behavior vary between paths.
>>>>>>>>>>
>>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ depends on the decision made by embedded_H.
>>>>>>>>>
>>>>>>>>> Yes, you are clear that
>>>>>>>>>
>>>>>>>>>    Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>
>>>>>>>>> but please complete the following line for me:
>>>>>>>>>
>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.q?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Not until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the
>>>>>>>> basis that the correctly simulated input to embedded_H would
>>>>>>>> never reach its own final state.
>>>>>>>>
>>>>>>>
>>>>>>> Since that isn't True, you are asking for a lot.
>>>>>>
>>>>>> It is true on the basis that I provided and every other basis is
>>>>>> incorrect.
>>>>>>
>>>>>
>>>>> Nope, the DEFINITION is correct, because it is the DEFINITION.
>>>>
>>>> The way that you are construing that definition contradicts its
>>>> computer science component parts:
>>>>
>>>> CORRECT DEFINITION OF HALT DECIDING CRITERIA
>>>>
>>>> (1) All deciders compute the mapping of their input finite strings
>>>> to an accept or reject state.
>>>
>>>
>>> Right, so H needs to map <H^> <H^> to Qy or Qn.
>>
>> YES
>>
>>>
>>>>
>>>> (2) The direct execution of a Turing machine is computationally
>>>> equivalent to the UTM simulation of its Turing machine description.
>>>
>>> Right.
>>>
>>
>> YES
>>
>>>>
>>>> (3) Halt deciders compute the mapping of their input finite strings
>>>> to an accept or reject state on the basis of the actual behavior
>>>> specified by their input.
>>>
>>> Right.
>>
>> YES
>>
>>>>
>>>> (4) The actual behavior specified by the input is measured by the
>>>> behavior of a UTM simulation of this input at the same point in the
>>>> execution trace as the simulating halt decider. (defined in (2) above)
>>>
>>> Nonsense statement since the UTM simulation of a string is ALWAYS the
>>> same regardless of 'point in the execution trace'
>>>
>>
>> Ĥ.q0 ⟨Ĥ⟩  ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩  ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>> UTM ⟨Ĥ⟩ ⟨Ĥ⟩ derives a different result than >
>> Ĥ.q0 ⟨Ĥ⟩  ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>> Ĥ.q0 ⟨Ĥ⟩  ⊢* UTM ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>> Ĥ ⟨Ĥ⟩
>>
>
> You don't seem to understand what you are saying, and are thus just
> making a Strawman.
>
> NOTHING said to repleace H with a UTM.
>

When I explain it other ways you simply just don't get it.

> That would only be a correct operation if H actually WAS the
> computational equivalent of a UTM, and we have previously proven that if
> H is that, it fails to answer.

Every H remains in pure UTM mode until the outermost H has complete
proof that its simulated input could never reach its own final state
while every H remains in pure UTM mode.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 9:03 AM, Richard Damon wrote:
> On 4/1/22 9:25 AM, olcott wrote:
>> On 4/1/2022 7:52 AM, Richard Damon wrote:
>>> On 4/1/22 8:08 AM, olcott wrote:
>>>> On 4/1/2022 6:36 AM, Dennis Bush wrote:
>>>>> On Thursday, March 31, 2022 at 11:47:35 PM UTC-4, olcott wrote:
>>>>>> On 3/31/2022 10:16 PM, Dennis Bush wrote:
>>>>>>> On Thursday, March 31, 2022 at 11:10:00 PM UTC-4, olcott wrote:
>>>>>>>> On 3/31/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, March 31, 2022 at 10:30:04 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, March 31, 2022 at 9:52:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE
>>>>>>>>>>>>>>>> REJECTED:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Linz and everyone here believes that deciders must base
>>>>>>>>>>>>>>>> their decision
>>>>>>>>>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> over-ruling the
>>>>>>>>>>>>>>>> actual behavior specified by the actual finite string
>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>> Here's that question you would not answer without
>>>>>>>>>>>>>>> equivocating, even
>>>>>>>>>>>>>>> after my asking it more than 12 times in a row. André
>>>>>>>>>>>>>>> also asked many,
>>>>>>>>>>>>>>> many times and got no answer.
>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a
>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>> could tell us whether a particular TM does or does not
>>>>>>>>>>>>>>> halt when given
>>>>>>>>>>>>>>> some particular input? Isn't that what the theorem is
>>>>>>>>>>>>>>> about? (The
>>>>>>>>>>>>>>> answer is, of course, yes.)
>>>>>>>>>>>>>
>>>>>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT
>>>>>>>>>>>>>> BEHAVIOR.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>>>>>>>>>>>> computationally
>>>>>>>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet
>>>>>>>>>>>>>> not the
>>>>>>>>>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Failure to answer number one (or 13 if you count my
>>>>>>>>>>>>> previous attempts).
>>>>>>>>>>>>> Here's the question in case you missed it:
>>>>>>>>>>>>>
>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>>>> I worked out many of the details of this, and can see why
>>>>>>>>>>>> you believe it
>>>>>>>>>>>> is an important point, I will not begin to discuss this
>>>>>>>>>>>> until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the
>>>>>>>>>>>> basis that
>>>>>>>>>>>> the correctly simulated input to embedded_H would never
>>>>>>>>>>>> reach its own
>>>>>>>>>>>> final state in any finite number of simulated steps.
>>>>>>>>>>>
>>>>>>>>>>> embedded_Ha, and therefore Ha, is not correct to reject
>>>>>>>>>>> <Ha^><Ha^> because it quits its simulation after n steps
>>>>>>>>>>> which is too soon. When this same input is given to
>>>>>>>>>>> simulating halt decider Hb which simulates for n+k steps, the
>>>>>>>>>>> input does reach its final state after n+k steps and Hb
>>>>>>>>>>> accepts <Ha^><Ha^>. Therefore Ha, and subsequently
>>>>>>>>>>> embedded_Ha, does *not* correctly simulate its input.
>>>>>>>>>> I will simply say that I am ignoring another strawman error.
>>>>>>>>>
>>>>>>>>> Just saying "strawman" isn't good enough.
>>>>>>>> I am only talking about Ĥ applied ⟨Ĥ⟩ and its associated
>>>>>>>> semantics any
>>>>>>>> change in notation or semantics is off topic.
>>>>>>>>
>>>>>>>> I am sure that you can make a million halt deciders that don't
>>>>>>>> work they
>>>>>>>> are all strawman.
>>>>>>>
>>>>>>> So you can't explain why Hb is wrong, and have therefore
>>>>>>> implicitly admitted it is correct.
>>>>>>>
>>>>>>> So what are you doing to do now that your proof has been refuted?
>>>>>> That you can make up some screwy thing that doesn't work says nothing
>>>>>> about my proof. If you were talking about my proof then you have
>>>>>> to use
>>>>>> my notation, my semantics and find an error in that.
>>>>>
>>>>> How exactly is it that Hb "doesn't work"?
>>>>>
>>>>> When you talk about H / embedded_H that "correctly" reports
>>>>> non-halting for H^, you're talking about an H that aborts it's
>>>>> simulation.  That's Ha / embedded_Ha and Ha^ is built from that.
>>>>> What I said still stands.  So state why Hb is wrong or admit failure.
>>>>>
>>>>
>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>  > embedded_Ha, and therefore Ha, is not correct to reject
>>>> <Ha^><Ha^> because it quits its simulation after n steps which is
>>>> too soon. When this same input is given to simulating halt decider
>>>> Hb which simulates for n+k steps, the input does reach its final
>>>> state after n+k steps and Hb accepts <Ha^><Ha^>.  Therefore Ha, and
>>>> subsequently embedded_Ha, does *not* correctly simulate its input.
>>>>
>>>> It is like I talk about driving my car to show that my car can be
>>>> driven so you drive a car into a tree to show that a car cannot be
>>>> driven.
>>>>
>>>> Here are the simplified notational conventions and semantics:
>>>> (Any attempt to diverge from the specified semantics will be
>>>> construed as the strawman error and marked as ignored)
>>>>
>>>> We will just call the halt decider H:
>>>> H ⟨p⟩ ⟨i⟩ ⊢* H.qy   iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final state
>>>> H ⟨p⟩ ⟨i⟩ ⊢* H.qn   iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach its
>>>> final state
>>>>
>>>> Simplified Ĥ directly calls H --- infinite loop has been removed.
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>
>>>
>>> THe problem with your 'simplified' H^ is that a smart H could just
>>> answer by going to Qy and be correct, but since yours doesn't, that
>>> isn't a fatal flaw to your argument.
>>>
>>> H -> Qn is PROVED incorrect, as BY THE DEFINITION H <p> <i> -> H.Qn
>>> only if UTM simulaton of <p> <i> will never halt, but we show that
>>> since UTM simulation of <H^> <H^> is the same as H^ applied to <H^>
>>> and that goes to H.Qn and HALTS, so does the UTM Simulation.
>>>
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> // while every H remains in pure UTM mode
>> Then these steps would keep repeating:
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>
>>
>
> No such thing as 'UTM Mode', a machine either is or is not a UTM.

On 4/1/2022 9:30 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 4/1/2022 8:52 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 4/1/2022 5:10 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
>>>>>>>>>>
>>>>>>>>>> Linz and everyone here believes that deciders must base their decision
>>>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
>>>>>>>>>> actual behavior specified by the actual finite string actual input.
>>>>>>>>> Here's that question you would not answer without equivocating, even
>>>>>>>>> after my asking it more than 12 times in a row. André also asked many,
>>>>>>>>> many times and got no answer.
>>>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
>>>>>>>>> could tell us whether a particular TM does or does not halt when given
>>>>>>>>> some particular input? Isn't that what the theorem is about? (The
>>>>>>>>> answer is, of course, yes.)
>>>>>>>
>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
>>>>>>>>
>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
>>>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>>
>>>>>>> Failure to answer number one (or 13 if you count my previous attempts).
>>>>>>>
>>>>>>> Here's the question in case you missed it:
>>>>>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>
>>>>>> I worked out many of the details of this, and can see why you believe
>>>>>> it is an important point, I will not begin to discuss this until after
>>>>>> you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the basis that the
>>>>>> correctly simulated input to embedded_H would never reach its own
>>>>>> final state in any finite number of simulated steps.
>>>>>
>>>>> Failure to answer number two (well, 14). It's a simple question and
>>>>> it's central what the halting problem is, but it's also central to why
>>>>> you are wrong, which is why you know you must avoid answering it.
>>>>>
>>>>
>>>> CORRECT DEFINITION OF HALT DECIDING CRITERIA
>>> ...
>>> Failure to answer number three (15 including previous attempts). We all
>>> know why you are avoiding it. Here it is again:
>>> What string must be passed to H so that H can tell us whether or not Ĥ
>>> applied to ⟨Ĥ⟩ halts?
>>
>> I will not tolerate any additional steps in the dialogue until we
>> attain mutual agreement on the current steps.
>
> Failure to answer number four (16 including previous attempts). Here it
> is again:
>
> What string must be passed to H so that H can tell us whether or not Ĥ
> applied to ⟨Ĥ⟩ halts?
>
>> My reviewers must pay the cost of an honest dialogue for any dialogue
>> to continue.
>
> This is pretty much the best possible outcome for me. No crank has ever
> admitted that their Big Idea is wrong,

I never admitted that my idea is wrong. I merely will not tolerate a
one-way dialogue that only provides denigration and never achieves any
mutual agreement.

> so the best one can hope for is
> to show that they won't answer a crucial question. The closest I will
> ever get to you admitting you are wrong is your refusal to say what
> string must be passed to H so that H can tell us whether or not Ĥ
> applied to ⟨Ĥ⟩ halts. The answer is central to what the halting problem
> is, and it's central to why you are wrong.
>
>> A one-way dialogue that only receives denigration and no points of
>> mutual agreement is not worth the cost of my limited time.
>
> No, it's still two-way. I ask the obvious question that everyone knows
> you can't answer, and you reply by refusing to answer it. Of course,

My answer to that question is currently incomplete.
None the less I will not move on to that question in any dialogue until
we have a full inventory of what we mutually agree on.

This must include mutual agreement of all of the points that I recently
presented.

I will probably proceed with the answer to that question privately. I
did complete enough of it to see why you believe that it is important.

> you can make it one-way by not replying, but I dare not hope for such
> joyous outcome. It would mean everyone just needs to ask this one
> question and all the sub threads would end. That's not going to happen
> because you are having too much fun -- at least I hope you are having
> fun.
>

Mutual agreement is required on all of the following points.
I will adjust the words as needed to achieve mutual agreement.

CORRECT DEFINITION OF HALT DECIDING CRITERIA

(1) All deciders compute the mapping of their input finite strings to an
accept or reject state.

(2) The direct execution of a Turing machine is computationally
equivalent to the UTM simulation of its Turing machine description.

(3) Halt deciders compute the mapping of their input finite strings to
an accept or reject state on the basis of the actual behavior specified
by their input.

(4) The actual behavior specified by the input is measured by the
behavior of a UTM simulation of this input at the same point in the
execution trace as the simulating halt decider. (defined in (2) above)

Simplified Ĥ directly calls H --- infinite loop has been removed.
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn

In other words every H remains in pure UTM mode until the outermost H
has complete proof that its simulated input would never reach its own
final state.

A simulating halt decider is in UTM mode while the behavior of its input
remains computationally equivalent to the behavior of this same input
when simulated by a UTM.

(5) Linz: computation that halts … the Turing machine will halt whenever
it enters a final state. (Linz:1990:234)

(6) A correct simulation of a Turing machine description that would
never reach its final state is computationally equivalent to the direct
execution of this same Turing machine never reaching its final state and
thus specifies a non-halting sequence of configurations.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 9:28 AM, Richard Damon wrote:
> On 4/1/22 10:11 AM, olcott wrote:
>> On 4/1/2022 9:03 AM, Richard Damon wrote:
>>> On 4/1/22 9:25 AM, olcott wrote:
>>>> On 4/1/2022 7:52 AM, Richard Damon wrote:
>>>>> On 4/1/22 8:08 AM, olcott wrote:
>>>>>> On 4/1/2022 6:36 AM, Dennis Bush wrote:
>>>>>>> On Thursday, March 31, 2022 at 11:47:35 PM UTC-4, olcott wrote:
>>>>>>>> On 3/31/2022 10:16 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, March 31, 2022 at 11:10:00 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/31/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, March 31, 2022 at 10:30:04 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, March 31, 2022 at 9:52:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO
>>>>>>>>>>>>>>>>>> BE REJECTED:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Linz and everyone here believes that deciders must
>>>>>>>>>>>>>>>>>> base their decision
>>>>>>>>>>>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> over-ruling the
>>>>>>>>>>>>>>>>>> actual behavior specified by the actual finite string
>>>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>>> Here's that question you would not answer without
>>>>>>>>>>>>>>>>> equivocating, even
>>>>>>>>>>>>>>>>> after my asking it more than 12 times in a row. André
>>>>>>>>>>>>>>>>> also asked many,
>>>>>>>>>>>>>>>>> many times and got no answer.
>>>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that
>>>>>>>>>>>>>>>>> a halt decider
>>>>>>>>>>>>>>>>> could tell us whether a particular TM does or does not
>>>>>>>>>>>>>>>>> halt when given
>>>>>>>>>>>>>>>>> some particular input? Isn't that what the theorem is
>>>>>>>>>>>>>>>>> about? (The
>>>>>>>>>>>>>>>>> answer is, of course, yes.)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE
>>>>>>>>>>>>>>>> DIFFERENT BEHAVIOR.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>>>>>>>>>>>>>> computationally
>>>>>>>>>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> yet not the
>>>>>>>>>>>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Failure to answer number one (or 13 if you count my
>>>>>>>>>>>>>>> previous attempts).
>>>>>>>>>>>>>>> Here's the question in case you missed it:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>>>>>> I worked out many of the details of this, and can see why
>>>>>>>>>>>>>> you believe it
>>>>>>>>>>>>>> is an important point, I will not begin to discuss this
>>>>>>>>>>>>>> until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on the
>>>>>>>>>>>>>> basis that
>>>>>>>>>>>>>> the correctly simulated input to embedded_H would never
>>>>>>>>>>>>>> reach its own
>>>>>>>>>>>>>> final state in any finite number of simulated steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> embedded_Ha, and therefore Ha, is not correct to reject
>>>>>>>>>>>>> <Ha^><Ha^> because it quits its simulation after n steps
>>>>>>>>>>>>> which is too soon. When this same input is given to
>>>>>>>>>>>>> simulating halt decider Hb which simulates for n+k steps,
>>>>>>>>>>>>> the input does reach its final state after n+k steps and Hb
>>>>>>>>>>>>> accepts <Ha^><Ha^>. Therefore Ha, and subsequently
>>>>>>>>>>>>> embedded_Ha, does *not* correctly simulate its input.
>>>>>>>>>>>> I will simply say that I am ignoring another strawman error.
>>>>>>>>>>>
>>>>>>>>>>> Just saying "strawman" isn't good enough.
>>>>>>>>>> I am only talking about Ĥ applied ⟨Ĥ⟩ and its associated
>>>>>>>>>> semantics any
>>>>>>>>>> change in notation or semantics is off topic.
>>>>>>>>>>
>>>>>>>>>> I am sure that you can make a million halt deciders that don't
>>>>>>>>>> work they
>>>>>>>>>> are all strawman.
>>>>>>>>>
>>>>>>>>> So you can't explain why Hb is wrong, and have therefore
>>>>>>>>> implicitly admitted it is correct.
>>>>>>>>>
>>>>>>>>> So what are you doing to do now that your proof has been refuted?
>>>>>>>> That you can make up some screwy thing that doesn't work says
>>>>>>>> nothing
>>>>>>>> about my proof. If you were talking about my proof then you have
>>>>>>>> to use
>>>>>>>> my notation, my semantics and find an error in that.
>>>>>>>
>>>>>>> How exactly is it that Hb "doesn't work"?
>>>>>>>
>>>>>>> When you talk about H / embedded_H that "correctly" reports
>>>>>>> non-halting for H^, you're talking about an H that aborts it's
>>>>>>> simulation.  That's Ha / embedded_Ha and Ha^ is built from that.
>>>>>>> What I said still stands.  So state why Hb is wrong or admit
>>>>>>> failure.
>>>>>>>
>>>>>>
>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>  > embedded_Ha, and therefore Ha, is not correct to reject
>>>>>> <Ha^><Ha^> because it quits its simulation after n steps which is
>>>>>> too soon. When this same input is given to simulating halt decider
>>>>>> Hb which simulates for n+k steps, the input does reach its final
>>>>>> state after n+k steps and Hb accepts <Ha^><Ha^>.  Therefore Ha,
>>>>>> and subsequently embedded_Ha, does *not* correctly simulate its
>>>>>> input.
>>>>>>
>>>>>> It is like I talk about driving my car to show that my car can be
>>>>>> driven so you drive a car into a tree to show that a car cannot be
>>>>>> driven.
>>>>>>
>>>>>> Here are the simplified notational conventions and semantics:
>>>>>> (Any attempt to diverge from the specified semantics will be
>>>>>> construed as the strawman error and marked as ignored)
>>>>>>
>>>>>> We will just call the halt decider H:
>>>>>> H ⟨p⟩ ⟨i⟩ ⊢* H.qy   iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final state
>>>>>> H ⟨p⟩ ⟨i⟩ ⊢* H.qn   iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach
>>>>>> its final state
>>>>>>
>>>>>> Simplified Ĥ directly calls H --- infinite loop has been removed.
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>
>>>>>
>>>>> THe problem with your 'simplified' H^ is that a smart H could just
>>>>> answer by going to Qy and be correct, but since yours doesn't, that
>>>>> isn't a fatal flaw to your argument.
>>>>>
>>>>> H -> Qn is PROVED incorrect, as BY THE DEFINITION H <p> <i> -> H.Qn
>>>>> only if UTM simulaton of <p> <i> will never halt, but we show that
>>>>> since UTM simulation of <H^> <H^> is the same as H^ applied to <H^>
>>>>> and that goes to H.Qn and HALTS, so does the UTM Simulation.
>>>>>
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> // while every H remains in pure UTM mode
>>>> Then these steps would keep repeating:
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>
>>>>
>>>
>>> No such thing as 'UTM Mode', a machine either is or is not a UTM.
>>
>> A simulating halt decider is in UTM mode while the behavior of its
>> input remains computationally equivalent to the behavior of this same
>> input when simulated by a UTM.
>>
>>
>
> Nope, just shows you don't understand what a UTM is.

On 4/1/2022 10:26 AM, Richard Damon wrote:
>
> No such things as 'UTM mode', a machine either IS or IS NOT a UTM.
>
>>
>> A simulating halt decider is in UTM mode while the behavior of its
>> input remains computationally equivalent to the behavior of this same
>> input when simulated by a UTM.
>
> GARBAGE. If it is the equivelent behavior of its input, it does not
> answer in time for a non-halting input. PERIOD.
>

We know that the behavior of the simulated input is equivalent to the
behavior of this input simulated by a UTM for every simulated step while
the SHD is in UTM mode.

--
Copyright 2022 Pete Olcott

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

On 4/1/2022 10:35 AM, Richard Damon wrote:
> On 4/1/22 11:20 AM, olcott wrote:
>> On 4/1/2022 9:28 AM, Richard Damon wrote:
>>> On 4/1/22 10:11 AM, olcott wrote:
>>>> On 4/1/2022 9:03 AM, Richard Damon wrote:
>>>>> On 4/1/22 9:25 AM, olcott wrote:
>>>>>> On 4/1/2022 7:52 AM, Richard Damon wrote:
>>>>>>> On 4/1/22 8:08 AM, olcott wrote:
>>>>>>>> On 4/1/2022 6:36 AM, Dennis Bush wrote:
>>>>>>>>> On Thursday, March 31, 2022 at 11:47:35 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/31/2022 10:16 PM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, March 31, 2022 at 11:10:00 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/31/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, March 31, 2022 at 10:30:04 PM UTC-4, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Thursday, March 31, 2022 at 9:52:15 PM UTC-4, olcott
>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>> On 3/31/2022 3:27 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO
>>>>>>>>>>>>>>>>>>>> BE REJECTED:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Linz and everyone here believes that deciders must
>>>>>>>>>>>>>>>>>>>> base their decision
>>>>>>>>>>>>>>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> over-ruling the
>>>>>>>>>>>>>>>>>>>> actual behavior specified by the actual finite
>>>>>>>>>>>>>>>>>>>> string actual input.
>>>>>>>>>>>>>>>>>>> Here's that question you would not answer without
>>>>>>>>>>>>>>>>>>> equivocating, even
>>>>>>>>>>>>>>>>>>> after my asking it more than 12 times in a row. André
>>>>>>>>>>>>>>>>>>> also asked many,
>>>>>>>>>>>>>>>>>>> many times and got no answer.
>>>>>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea
>>>>>>>>>>>>>>>>>>> that a halt decider
>>>>>>>>>>>>>>>>>>> could tell us whether a particular TM does or does
>>>>>>>>>>>>>>>>>>> not halt when given
>>>>>>>>>>>>>>>>>>> some particular input? Isn't that what the theorem is
>>>>>>>>>>>>>>>>>>> about? (The
>>>>>>>>>>>>>>>>>>> answer is, of course, yes.)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE
>>>>>>>>>>>>>>>>>> DIFFERENT BEHAVIOR.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
>>>>>>>>>>>>>>>>>> computationally
>>>>>>>>>>>>>>>>>> equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> yet not the
>>>>>>>>>>>>>>>>>> same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Failure to answer number one (or 13 if you count my
>>>>>>>>>>>>>>>>> previous attempts).
>>>>>>>>>>>>>>>>> Here's the question in case you missed it:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What string must be passed to H so that H can tell us
>>>>>>>>>>>>>>>>> whether or not Ĥ
>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩ halts?
>>>>>>>>>>>>>>>> I worked out many of the details of this, and can see
>>>>>>>>>>>>>>>> why you believe it
>>>>>>>>>>>>>>>> is an important point, I will not begin to discuss this
>>>>>>>>>>>>>>>> until after you agree that Ĥ ⟨Ĥ⟩ ⊦* Ĥ.qn is correct on
>>>>>>>>>>>>>>>> the basis that
>>>>>>>>>>>>>>>> the correctly simulated input to embedded_H would never
>>>>>>>>>>>>>>>> reach its own
>>>>>>>>>>>>>>>> final state in any finite number of simulated steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> embedded_Ha, and therefore Ha, is not correct to reject
>>>>>>>>>>>>>>> <Ha^><Ha^> because it quits its simulation after n steps
>>>>>>>>>>>>>>> which is too soon. When this same input is given to
>>>>>>>>>>>>>>> simulating halt decider Hb which simulates for n+k steps,
>>>>>>>>>>>>>>> the input does reach its final state after n+k steps and
>>>>>>>>>>>>>>> Hb accepts <Ha^><Ha^>. Therefore Ha, and subsequently
>>>>>>>>>>>>>>> embedded_Ha, does *not* correctly simulate its input.
>>>>>>>>>>>>>> I will simply say that I am ignoring another strawman error.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Just saying "strawman" isn't good enough.
>>>>>>>>>>>> I am only talking about Ĥ applied ⟨Ĥ⟩ and its associated
>>>>>>>>>>>> semantics any
>>>>>>>>>>>> change in notation or semantics is off topic.
>>>>>>>>>>>>
>>>>>>>>>>>> I am sure that you can make a million halt deciders that
>>>>>>>>>>>> don't work they
>>>>>>>>>>>> are all strawman.
>>>>>>>>>>>
>>>>>>>>>>> So you can't explain why Hb is wrong, and have therefore
>>>>>>>>>>> implicitly admitted it is correct.
>>>>>>>>>>>
>>>>>>>>>>> So what are you doing to do now that your proof has been
>>>>>>>>>>> refuted?
>>>>>>>>>> That you can make up some screwy thing that doesn't work says
>>>>>>>>>> nothing
>>>>>>>>>> about my proof. If you were talking about my proof then you
>>>>>>>>>> have to use
>>>>>>>>>> my notation, my semantics and find an error in that.
>>>>>>>>>
>>>>>>>>> How exactly is it that Hb "doesn't work"?
>>>>>>>>>
>>>>>>>>> When you talk about H / embedded_H that "correctly" reports
>>>>>>>>> non-halting for H^, you're talking about an H that aborts it's
>>>>>>>>> simulation.  That's Ha / embedded_Ha and Ha^ is built from
>>>>>>>>> that. What I said still stands.  So state why Hb is wrong or
>>>>>>>>> admit failure.
>>>>>>>>>
>>>>>>>>
>>>>>>>> On 3/31/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>  > embedded_Ha, and therefore Ha, is not correct to reject
>>>>>>>> <Ha^><Ha^> because it quits its simulation after n steps which
>>>>>>>> is too soon. When this same input is given to simulating halt
>>>>>>>> decider Hb which simulates for n+k steps, the input does reach
>>>>>>>> its final state after n+k steps and Hb accepts <Ha^><Ha^>.
>>>>>>>> Therefore Ha, and subsequently embedded_Ha, does *not* correctly
>>>>>>>> simulate its input.
>>>>>>>>
>>>>>>>> It is like I talk about driving my car to show that my car can
>>>>>>>> be driven so you drive a car into a tree to show that a car
>>>>>>>> cannot be driven.
>>>>>>>>
>>>>>>>> Here are the simplified notational conventions and semantics:
>>>>>>>> (Any attempt to diverge from the specified semantics will be
>>>>>>>> construed as the strawman error and marked as ignored)
>>>>>>>>
>>>>>>>> We will just call the halt decider H:
>>>>>>>> H ⟨p⟩ ⟨i⟩ ⊢* H.qy   iff UTM simulated ⟨p⟩ ⟨i⟩ reaches its final
>>>>>>>> state
>>>>>>>> H ⟨p⟩ ⟨i⟩ ⊢* H.qn   iff UTM simulated ⟨p⟩ ⟨i⟩ would never reach
>>>>>>>> its final state
>>>>>>>>
>>>>>>>> Simplified Ĥ directly calls H --- infinite loop has been removed.
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn
>>>>>>>>
>>>>>>>
>>>>>>> THe problem with your 'simplified' H^ is that a smart H could
>>>>>>> just answer by going to Qy and be correct, but since yours
>>>>>>> doesn't, that isn't a fatal flaw to your argument.
>>>>>>>
>>>>>>> H -> Qn is PROVED incorrect, as BY THE DEFINITION H <p> <i> ->
>>>>>>> H.Qn only if UTM simulaton of <p> <i> will never halt, but we
>>>>>>> show that since UTM simulation of <H^> <H^> is the same as H^
>>>>>>> applied to <H^> and that goes to H.Qn and HALTS, so does the UTM
>>>>>>> Simulation.
>>>>>>>
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>>
>>>>>> // while every H remains in pure UTM mode
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>
>>>>>>
>>>>>
>>>>> No such thing as 'UTM Mode', a machine either is or is not a UTM.
>>>>
>>>> A simulating halt decider is in UTM mode while the behavior of its
>>>> input remains computationally equivalent to the behavior of this
>>>> same input when simulated by a UTM.
>>>>
>>>>
>>>
>>> Nope, just shows you don't understand what a UTM is.
>>
>> Any Turing machine can have the full capability of a UTM within it
>> that it can use to simulate the Turing Machine description of any
>> halting computation to completion. It can also simulate one single
>> state transition at a time as a sequence of simulated steps.
>>
>> Although it is not a UTM the behavior of the simulated input while the
>> simulating halt decider is in UTM mode is equivalent to its behavior
>> when simulated by an actual UTM.
>>
>
> Yes, it can use UTM code modified to perform some action.
>
> The final machine is NOT a UTM unless it meets the actual definiton of a
> UTM.
>
> Just like you can take a 'street-legal' car, and modify it for some
> purpose, and it may no longer be 'street-legal'
>
> If H no longer meets the definition of a UTM, then it isn't a UTM, even
> if it used UTM like code to make its decision.
>
> Since H LEAVES UTM mode,