On 3/28/2022 4:44 PM, Dennis Bush wrote:
> On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:
>> On 3/28/2022 4:05 PM, Dennis Bush wrote:
>>> On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote:
>>>> On 3/28/2022 11:48 AM, Dennis Bush wrote:
>>>>> On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote:
>>>>>> On 3/28/2022 11:31 AM, Dennis Bush wrote:
>>>>>>> On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote:
>>>>>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:
>>>>>>>>> On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:
>>>>>>>>>>> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> I don't even look at it because it is merely a terrible attempt at
>>>>>>>>>>>>>>>>>> trying to get away with the strawman error.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>>>>>>>>>>>>>>>> Frederick Brooks - ACM Awards Turing Award (1999)
>>>>>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessential
>>>>>>>>>>>>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Keeping analysis down to it minimal essence makes some otherwise
>>>>>>>>>>>>>>>> impossibly complex analysis feasible.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>>>>>>>>>>>>>>>> what Linz bases his conclusion on.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could never reach its final
>>>>>>>>>>>>>>>> state in any finite number of steps of correct simulation by embedded_H
>>>>>>>>>>>>>>>> then its rejection of this input is necessarily correct.
>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I agree that I am only talking about embedded_H and Ha3 is not
>>>>>>>>>>>>>> embedded_H. I am also not talking about H because Linz does not use H as
>>>>>>>>>>>>>> the basis of his conclusion. We must stay focused on the simplest
>>>>>>>>>>>>>> possible essence.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes you are talking about H (or more accurately Ha).
>>>>>>>>>>>> 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 Ĥ because:
>>>>>>>>>>
>>>>>>>>>>>> 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's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
>>>>>>>>>> A halt decider computes the mapping of its inputs to its own accept or
>>>>>>>>>> reject state on the basis of the actual behavior specified by its input.
>>>>>>>>>>
>>>>>>>>>> embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
>>>>>>>>>> simulated input will never reach its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>
>>>>>>>>> Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
>>>>>>>>>
>>>>>>>> You stipulated that <N><5> only has five iterations.
>>>>>>>> Ha3 is merely halt decider intentionally designed to get the wrong
>>>>>>>> answer. I really don't have time to spent on screwy ideas like this.
>>>>>>>
>>>>>>> By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
>>>>>>> any finite number of steps of correct simulation by Ha3.
>>>>>> You designed Ha3 to make sure that it cuts off simulation prematurely.
>>>>>> If you insist on playing these head games this will be the last response
>>>>>> I will provide.
>>>>>
>>>>> So in other words Ha3 is wrong because it didn't simulate long enough?
>>>>>
>>>> When we ask: Is there any finite number of steps that embedded_H can
>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input reaches its
>>>> own final state? An answer of: "no" means that embedded_H can correctly
>>>> reject its input.
>>>>
>>>> Changing the question to any other variation such as Ha3 applied to
>>>> <N><5> is merely the deceitful attempt of trying to get away with the
>>>> strawman error.
>>>
>>> It is not deceitful. It's a test of your logic. You say that the criteria for determining if Ha (because embedded_H is embedded_Ha if it aborts, and Ha is the same as embedded_Ha if it was built properly) applied to <Ha^><Ha^> is correct to reject is that it cannot simulate its input to its own final state in a finite number of steps. That's your test for whether a simulating halt decider is correct.
>>>
>>> So by that same logic, since Ha3 cannot simulate its input <N><5> to its own final state in any finite number of steps, it is correct to reject it.
>>
>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
>> does not include incorrectly cutting off the simulation.
>
> In that case, because Hb applied to <Ha^><Ha^> accepts its input, Ha applied to <Ha^><Ha^> incorrectly cuts off the simulation.

On 3/28/2022 7:33 PM, Dennis Bush wrote:
> On Monday, March 28, 2022 at 6:12:09 PM UTC-4, olcott wrote:
>> On 3/28/2022 5:07 PM, Dennis Bush wrote:
>>> On Monday, March 28, 2022 at 6:01:26 PM UTC-4, olcott wrote:
>>>> On 3/28/2022 4:44 PM, Dennis Bush wrote:
>>>>> On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:
>>>>>> On 3/28/2022 4:05 PM, Dennis Bush wrote:
>>>>>>> On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote:
>>>>>>>> On 3/28/2022 11:48 AM, Dennis Bush wrote:
>>>>>>>>> On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/28/2022 11:31 AM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> I don't even look at it because it is merely a terrible attempt at
>>>>>>>>>>>>>>>>>>>>>> trying to get away with the strawman error.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>>>>>>>>>>>>>>>>>>>> Frederick Brooks - ACM Awards Turing Award (1999)
>>>>>>>>>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessential
>>>>>>>>>>>>>>>>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Keeping analysis down to it minimal essence makes some otherwise
>>>>>>>>>>>>>>>>>>>> impossibly complex analysis feasible.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>>>>>>>>>>>>>>>>>>>> what Linz bases his conclusion on.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could never reach its final
>>>>>>>>>>>>>>>>>>>> state in any finite number of steps of correct simulation by embedded_H
>>>>>>>>>>>>>>>>>>>> then its rejection of this input is necessarily correct.
>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I agree that I am only talking about embedded_H and Ha3 is not
>>>>>>>>>>>>>>>>>> embedded_H. I am also not talking about H because Linz does not use H as
>>>>>>>>>>>>>>>>>> the basis of his conclusion. We must stay focused on the simplest
>>>>>>>>>>>>>>>>>> possible essence.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes you are talking about H (or more accurately Ha).
>>>>>>>>>>>>>>>> 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 Ĥ because:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
>>>>>>>>>>>>>> A halt decider computes the mapping of its inputs to its own accept or
>>>>>>>>>>>>>> reject state on the basis of the actual behavior specified by its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
>>>>>>>>>>>>>> simulated input will never reach its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
>>>>>>>>>>>>>
>>>>>>>>>>>> You stipulated that <N><5> only has five iterations.
>>>>>>>>>>>> Ha3 is merely halt decider intentionally designed to get the wrong
>>>>>>>>>>>> answer. I really don't have time to spent on screwy ideas like this.
>>>>>>>>>>>
>>>>>>>>>>> By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
>>>>>>>>>>> any finite number of steps of correct simulation by Ha3.
>>>>>>>>>> You designed Ha3 to make sure that it cuts off simulation prematurely.
>>>>>>>>>> If you insist on playing these head games this will be the last response
>>>>>>>>>> I will provide.
>>>>>>>>>
>>>>>>>>> So in other words Ha3 is wrong because it didn't simulate long enough?
>>>>>>>>>
>>>>>>>> When we ask: Is there any finite number of steps that embedded_H can
>>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input reaches its
>>>>>>>> own final state? An answer of: "no" means that embedded_H can correctly
>>>>>>>> reject its input.
>>>>>>>>
>>>>>>>> Changing the question to any other variation such as Ha3 applied to
>>>>>>>> <N><5> is merely the deceitful attempt of trying to get away with the
>>>>>>>> strawman error.
>>>>>>>
>>>>>>> It is not deceitful. It's a test of your logic. You say that the criteria for determining if Ha (because embedded_H is embedded_Ha if it aborts, and Ha is the same as embedded_Ha if it was built properly) applied to <Ha^><Ha^> is correct to reject is that it cannot simulate its input to its own final state in a finite number of steps. That's your test for whether a simulating halt decider is correct.
>>>>>>>
>>>>>>> So by that same logic, since Ha3 cannot simulate its input <N><5> to its own final state in any finite number of steps, it is correct to reject it.
>>>>>>
>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> does not include incorrectly cutting off the simulation.
>>>>>
>>>>> In that case, because Hb applied to <Ha^><Ha^> accepts its input, Ha applied to <Ha^><Ha^> incorrectly cuts off the simulation.
>>>> This is why I disallow changing the subject away from the copy of Linz H
>>>> embedded in Linz Ĥ. There is an infinite set of permutations of
>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ that are incorrect. We could keep talking
>>>> in circles endlessly forever preventing closure if I tolerated these
>>>> deceitful attempts of the strawman error.
>>>
>>> So in other words, you can't explain away Hb applied to <Ha^><Ha^> reporting halting as correct, so you try to change the subject. Since you can't refute it, that mean Linz is validated. Q.E.D.
>>>
>>> So what are you doing to do with yourself now that your proof has been invalidated?
>>>
>> My proof has not been invalidated your strawman error.
>>
>> The only reason why you derive these strawman errors is that there are
>> no errors in my exact words and you know it.
>
> If Hb accepting <Ha^><Ha^> is directly counter to your desired result. If it is wrong you would be able to explain why. Your failure to do so is an admission that your reasoning gives incorrect results and that you have no case.
>
> This all stems from the fact that your H is not correctly answering the question of whether H^ applied to <H^> halts as required by the proof. Don't tell us how many dogs are in your living room when we ask how many cats are in your kitchen.
>

On 3/28/2022 8:15 PM, Python wrote:
> Peter Olcott wrote:
>> On 3/28/2022 7:15 PM, Richard Damon wrote:
> ...
>>> No, people rebuttals are pointing out a TRUTH to you.
>>>
>>> Your problem is you have confused yourself by accepting a FALSE
>>> premise. Your 'Test' for Halting is NOT a valid test.
>>>
>>> FAIL.
>>
>> All you have is dogma, you have no correct reasoning as a rebuttal.
>
> Not at all, he has arguments.
>

The only argument that seems plausible is ultimately incorrect:

Linz got this wrong too: there is never a case where any decider gives a
rat's ass about the computation that contains itself.

A halt decider (because it is a decider) must report on the behavior
specified by its finite string input. As long as it correctly does that
then nothing else can possibly matter.

--
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/28/2022 8:30 PM, Dennis Bush wrote:
> On Monday, March 28, 2022 at 9:05:23 PM UTC-4, olcott wrote:
>> On 3/28/2022 7:33 PM, Dennis Bush wrote:
>>> On Monday, March 28, 2022 at 6:12:09 PM UTC-4, olcott wrote:
>>>> On 3/28/2022 5:07 PM, Dennis Bush wrote:
>>>>> On Monday, March 28, 2022 at 6:01:26 PM UTC-4, olcott wrote:
>>>>>> On 3/28/2022 4:44 PM, Dennis Bush wrote:
>>>>>>> On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:
>>>>>>>> On 3/28/2022 4:05 PM, Dennis Bush wrote:
>>>>>>>>> On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote:
>>>>>>>>>> On 3/28/2022 11:48 AM, Dennis Bush wrote:
>>>>>>>>>>> On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 3/28/2022 11:31 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> I don't even look at it because it is merely a terrible attempt at
>>>>>>>>>>>>>>>>>>>>>>>> trying to get away with the strawman error.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
>>>>>>>>>>>>>>>>>>>>>> Frederick Brooks - ACM Awards Turing Award (1999)
>>>>>>>>>>>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessential
>>>>>>>>>>>>>>>>>>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Keeping analysis down to it minimal essence makes some otherwise
>>>>>>>>>>>>>>>>>>>>>> impossibly complex analysis feasible.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
>>>>>>>>>>>>>>>>>>>>>> what Linz bases his conclusion on.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could never reach its final
>>>>>>>>>>>>>>>>>>>>>> state in any finite number of steps of correct simulation by embedded_H
>>>>>>>>>>>>>>>>>>>>>> then its rejection of this input is necessarily correct.
>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I agree that I am only talking about embedded_H and Ha3 is not
>>>>>>>>>>>>>>>>>>>> embedded_H. I am also not talking about H because Linz does not use H as
>>>>>>>>>>>>>>>>>>>> the basis of his conclusion. We must stay focused on the simplest
>>>>>>>>>>>>>>>>>>>> possible essence.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes you are talking about H (or more accurately Ha).
>>>>>>>>>>>>>>>>>> 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 Ĥ because:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
>>>>>>>>>>>>>>>> A halt decider computes the mapping of its inputs to its own accept or
>>>>>>>>>>>>>>>> reject state on the basis of the actual behavior specified by its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
>>>>>>>>>>>>>>>> simulated input will never reach its own final state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You stipulated that <N><5> only has five iterations.
>>>>>>>>>>>>>> Ha3 is merely halt decider intentionally designed to get the wrong
>>>>>>>>>>>>>> answer. I really don't have time to spent on screwy ideas like this.
>>>>>>>>>>>>>
>>>>>>>>>>>>> By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
>>>>>>>>>>>>> any finite number of steps of correct simulation by Ha3.
>>>>>>>>>>>> You designed Ha3 to make sure that it cuts off simulation prematurely.
>>>>>>>>>>>> If you insist on playing these head games this will be the last response
>>>>>>>>>>>> I will provide.
>>>>>>>>>>>
>>>>>>>>>>> So in other words Ha3 is wrong because it didn't simulate long enough?
>>>>>>>>>>>
>>>>>>>>>> When we ask: Is there any finite number of steps that embedded_H can
>>>>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input reaches its
>>>>>>>>>> own final state? An answer of: "no" means that embedded_H can correctly
>>>>>>>>>> reject its input.
>>>>>>>>>>
>>>>>>>>>> Changing the question to any other variation such as Ha3 applied to
>>>>>>>>>> <N><5> is merely the deceitful attempt of trying to get away with the
>>>>>>>>>> strawman error.
>>>>>>>>>
>>>>>>>>> It is not deceitful. It's a test of your logic. You say that the criteria for determining if Ha (because embedded_H is embedded_Ha if it aborts, and Ha is the same as embedded_Ha if it was built properly) applied to <Ha^><Ha^> is correct to reject is that it cannot simulate its input to its own final state in a finite number of steps. That's your test for whether a simulating halt decider is correct.
>>>>>>>>>
>>>>>>>>> So by that same logic, since Ha3 cannot simulate its input <N><5> to its own final state in any finite number of steps, it is correct to reject it.
>>>>>>>>
>>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> does not include incorrectly cutting off the simulation.
>>>>>>>
>>>>>>> In that case, because Hb applied to <Ha^><Ha^> accepts its input, Ha applied to <Ha^><Ha^> incorrectly cuts off the simulation.
>>>>>> This is why I disallow changing the subject away from the copy of Linz H
>>>>>> embedded in Linz Ĥ. There is an infinite set of permutations of
>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ that are incorrect. We could keep talking
>>>>>> in circles endlessly forever preventing closure if I tolerated these
>>>>>> deceitful attempts of the strawman error.
>>>>>
>>>>> So in other words, you can't explain away Hb applied to <Ha^><Ha^> reporting halting as correct, so you try to change the subject. Since you can't refute it, that mean Linz is validated. Q.E.D.
>>>>>
>>>>> So what are you doing to do with yourself now that your proof has been invalidated?
>>>>>
>>>> My proof has not been invalidated your strawman error.
>>>>
>>>> The only reason why you derive these strawman errors is that there are
>>>> no errors in my exact words and you know it.
>>>
>>> If Hb accepting <Ha^><Ha^> is directly counter to your desired result. If it is wrong you would be able to explain why. Your failure to do so is an admission that your reasoning gives incorrect results and that you have no case.
>>>
>>> This all stems from the fact that your H is not correctly answering the question of whether H^ applied to <H^> halts as required by the proof. Don't tell us how many dogs are in your living room when we ask how many cats are in your kitchen.
>>>
>> Not at all. (Linz got this wrong too) There is never a case where any
>> decider gives a rat's ass about the computation that contains itself.
>>
>
> There is no confusion. The definition is what it is. It is perfectly acceptable for H to take <H> <<H^><H^>> as an input.
>
>
>> A halt decider (because it is a decider) must report on the behavior
>> specified by its finite string input. As long as it correctly does that
>> then nothing else can possibly matter.
>
> And the behavior specified by <H^><H^> is *by definition* H^ applied to <H^>.

On 3/28/2022 10:39 PM, olcott wrote:
> On 3/28/2022 10:38 PM, Dennis Bush wrote:
>> On Monday, March 28, 2022 at 11:30:14 PM UTC-4, olcott wrote:
>>> On 3/28/2022 10:10 PM, Dennis Bush wrote:
>>>> On Monday, March 28, 2022 at 10:45:03 PM UTC-4, olcott wrote:
>>>>> On 3/28/2022 8:30 PM, Dennis Bush wrote:
>>>>>> On Monday, March 28, 2022 at 9:05:23 PM UTC-4, olcott wrote:
>>>>>>> On 3/28/2022 7:33 PM, Dennis Bush wrote:
>>>>>>>> On Monday, March 28, 2022 at 6:12:09 PM UTC-4, olcott wrote:
>>>>>>>>> On 3/28/2022 5:07 PM, Dennis Bush wrote:
>>>>>>>>>> On Monday, March 28, 2022 at 6:01:26 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 3/28/2022 4:44 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 3/28/2022 4:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 3/28/2022 11:48 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 3/28/2022 11:31 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 11:18:07 PM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't even look at it because it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely a terrible attempt at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying to get away with the strawman error.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words, you can't explain it because
>>>>>>>>>>>>>>>>>>>>>>>>>>>> it demonstrates quite clearly that you're
>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Frederick Brooks - ACM Awards Turing Award
>>>>>>>>>>>>>>>>>>>>>>>>>>> (1999)
>>>>>>>>>>>>>>>>>>>>>>>>>>> I have always focused on Brooks advice of
>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminating inessential
>>>>>>>>>>>>>>>>>>>>>>>>>>> complexity
>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/No_Silver_Bullet
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Keeping analysis down to it minimal essence
>>>>>>>>>>>>>>>>>>>>>>>>>>> makes some otherwise
>>>>>>>>>>>>>>>>>>>>>>>>>>> impossibly complex analysis feasible.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> I only focus on the embedded copy of the Linz
>>>>>>>>>>>>>>>>>>>>>>>>>>> H at Ĥ.qx because this is
>>>>>>>>>>>>>>>>>>>>>>>>>>> what Linz bases his conclusion on.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>>>>>>> TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
>>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>> could never reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>> state in any finite number of steps of
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation by embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>> then its rejection of this input is
>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V4)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So you agree that Ha3 is correct reject the
>>>>>>>>>>>>>>>>>>>>>>>>>> input <N><5>? Because if the above is true,
>>>>>>>>>>>>>>>>>>>>>>>>>> then the same is true for H (since embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> is a copy of H) and therefore for any
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider, so this is also true:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I agree that I am only talking about embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> and Ha3 is not
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H. I am also not talking about H
>>>>>>>>>>>>>>>>>>>>>>>>> because Linz does not use H as
>>>>>>>>>>>>>>>>>>>>>>>>> the basis of his conclusion. We must stay
>>>>>>>>>>>>>>>>>>>>>>>>> focused on the simplest
>>>>>>>>>>>>>>>>>>>>>>>>> possible essence.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Yes you are talking about H (or more accurately
>>>>>>>>>>>>>>>>>>>>>>>> Ha).
>>>>>>>>>>>>>>>>>>>>>>> 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 Ĥ because:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 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's a convoluted way of saying that H is unable
>>>>>>>>>>>>>>>>>>>>>> to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
>>>>>>>>>>>>>>>>>>>>> A halt decider computes the mapping of its inputs
>>>>>>>>>>>>>>>>>>>>> to its own accept or
>>>>>>>>>>>>>>>>>>>>> reject state on the basis of the actual behavior
>>>>>>>>>>>>>>>>>>>>> specified by its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it
>>>>>>>>>>>>>>>>>>>>> sees that this
>>>>>>>>>>>>>>>>>>>>> simulated input will never reach its own final
>>>>>>>>>>>>>>>>>>>>> state ⟨Ĥ.qn⟩.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Similarly, Ha3 does correctly simulate <N><5> until
>>>>>>>>>>>>>>>>>>>> it sees that this simulated input will never reach
>>>>>>>>>>>>>>>>>>>> its own final state <N>.qy. Because the simulated
>>>>>>>>>>>>>>>>>>>> input never reaches its final state of <N>.qy, Ha3
>>>>>>>>>>>>>>>>>>>> is correct to reject it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You stipulated that <N><5> only has five iterations.
>>>>>>>>>>>>>>>>>>> Ha3 is merely halt decider intentionally designed to
>>>>>>>>>>>>>>>>>>> get the wrong
>>>>>>>>>>>>>>>>>>> answer. I really don't have time to spent on screwy
>>>>>>>>>>>>>>>>>>> ideas like this.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> By your own logic, Ha3 is correct to reject <N><5>.
>>>>>>>>>>>>>>>>>> The simulated input to Ha3 could never reach its final
>>>>>>>>>>>>>>>>>> state in
>>>>>>>>>>>>>>>>>> any finite number of steps of correct simulation by Ha3.
>>>>>>>>>>>>>>>>> You designed Ha3 to make sure that it cuts off
>>>>>>>>>>>>>>>>> simulation prematurely.
>>>>>>>>>>>>>>>>> If you insist on playing these head games this will be
>>>>>>>>>>>>>>>>> the last response
>>>>>>>>>>>>>>>>> I will provide.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So in other words Ha3 is wrong because it didn't
>>>>>>>>>>>>>>>> simulate long enough?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When we ask: Is there any finite number of steps that
>>>>>>>>>>>>>>> embedded_H can
>>>>>>>>>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input
>>>>>>>>>>>>>>> reaches its
>>>>>>>>>>>>>>> own final state? An answer of: "no" means that embedded_H
>>>>>>>>>>>>>>> can correctly
>>>>>>>>>>>>>>> reject its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Changing the question to any other variation such as Ha3
>>>>>>>>>>>>>>> applied to
>>>>>>>>>>>>>>> <N><5> is merely the deceitful attempt of trying to get
>>>>>>>>>>>>>>> away with the
>>>>>>>>>>>>>>> strawman error.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is not deceitful. It's a test of your logic. You say
>>>>>>>>>>>>>> that the criteria for determining if Ha (because
>>>>>>>>>>>>>> embedded_H is embedded_Ha if it aborts, and Ha is the same
>>>>>>>>>>>>>> as embedded_Ha if it was built properly) applied to
>>>>>>>>>>>>>> <Ha^><Ha^> is correct to reject is that it cannot simulate
>>>>>>>>>>>>>> its input to its own final state in a finite number of
>>>>>>>>>>>>>> steps. That's your test for whether a simulating halt
>>>>>>>>>>>>>> decider is correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So by that same logic, since Ha3 cannot simulate its input
>>>>>>>>>>>>>> <N><5> to its own final state in any finite number of
>>>>>>>>>>>>>> steps, it is correct to reject it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> does not include incorrectly cutting off the simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> In that case, because Hb applied to <Ha^><Ha^> accepts its
>>>>>>>>>>>> input, Ha applied to <Ha^><Ha^> incorrectly cuts off the
>>>>>>>>>>>> simulation.
>>>>>>>>>>> This is why I disallow changing the subject away from the
>>>>>>>>>>> copy of Linz H
>>>>>>>>>>> embedded in Linz Ĥ. There is an infinite set of permutations of
>>>>>>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ that are incorrect. We could
>>>>>>>>>>> keep talking
>>>>>>>>>>> in circles endlessly forever preventing closure if I
>>>>>>>>>>> tolerated these
>>>>>>>>>>> deceitful attempts of the strawman error.
>>>>>>>>>>
>>>>>>>>>> So in other words, you can't explain away Hb applied to
>>>>>>>>>> <Ha^><Ha^> reporting halting as correct, so you try to change
>>>>>>>>>> the subject. Since you can't refute it, that mean Linz is
>>>>>>>>>> validated. Q.E.D.
>>>>>>>>>>
>>>>>>>>>> So what are you doing to do with yourself now that your proof
>>>>>>>>>> has been invalidated?
>>>>>>>>>>
>>>>>>>>> My proof has not been invalidated your strawman error.
>>>>>>>>>
>>>>>>>>> The only reason why you derive these strawman errors is that
>>>>>>>>> there are
>>>>>>>>> no errors in my exact words and you know it.
>>>>>>>>
>>>>>>>> If Hb accepting <Ha^><Ha^> is directly counter to your desired
>>>>>>>> result. If it is wrong you would be able to explain why. Your
>>>>>>>> failure to do so is an admission that your reasoning gives
>>>>>>>> incorrect results and that you have no case.
>>>>>>>>
>>>>>>>> This all stems from the fact that your H is not correctly
>>>>>>>> answering the question of whether H^ applied to <H^> halts as
>>>>>>>> required by the proof. Don't tell us how many dogs are in your
>>>>>>>> living room when we ask how many cats are in your kitchen.
>>>>>>>>
>>>>>>> Not at all. (Linz got this wrong too) There is never a case where
>>>>>>> any
>>>>>>> decider gives a rat's ass about the computation that contains
>>>>>>> itself.
>>>>>>>
>>>>>>
>>>>>> There is no confusion. The definition is what it is. It is
>>>>>> perfectly acceptable for H to take <H> <<H^><H^>> as an input.
>>>>>>
>>>>>>
>>>>>>> A halt decider (because it is a decider) must report on the behavior
>>>>>>> specified by its finite string input. As long as it correctly
>>>>>>> does that
>>>>>>> then nothing else can possibly matter.
>>>>>>
>>>>>> And the behavior specified by <H^><H^> is *by definition* H^
>>>>>> applied to <H^>.
>>>>> Except that it is not. The behavior of a correct simulation of a
>>>>> Turing
>>>>> machine description is the ULTIMATE measure of the behavior that it
>>>>> specifies:
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>
>>>>> Then these steps would keep repeating:
>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>>> ⟨Ĥ4⟩...
>>>>> Unless and until embedded_H aborts its simulation, then every nested
>>>>> simulation immediately stops with none these simulated inputs ever
>>>>> reaching their own final state of ⟨Ĥ.qn⟩ (thus halting).
>>>>
>>>> Let me fix that for you:
>>>>
>>>> When Ĥn is applied to ⟨Ĥn⟩
>>> I am not going to dredge through your change of notational conventions I
>>> have chemotherapy all day tomorrow.
>>
>> I merely changed all references to H and H^ to Hn and Hn^ since that's
>> the only case with infinite recursion.  To reiterate:
>>
>
> I probably won't be anble to look at it. I only have two more minutes I
> can spend on this until 6:00 PM tomorrow.
>
>> When Ĥn is applied to ⟨Ĥn⟩
>> Ĥn copies its input ⟨Ĥn0⟩ to ⟨Ĥn1⟩ then embedded_Hn simulates ⟨Ĥn0⟩ ⟨Ĥn1⟩
>>
>> Then these steps would keep repeating:
>> Ĥn0 copies its input ⟨Ĥn1⟩ to ⟨Ĥn2⟩ then embedded_Hn0 simulates ⟨Ĥn1⟩
>> ⟨Ĥn2⟩
>> Ĥn1 copies its input ⟨Ĥn2⟩ to ⟨Ĥn3⟩ then embedded_Hn1 simulates ⟨Ĥn2⟩
>> ⟨Ĥn3⟩
>> Ĥn2 copies its input ⟨Ĥn3⟩ to ⟨Ĥn4⟩ then embedded_Hn2 simulates ⟨Ĥn3⟩
>> ⟨Ĥn4⟩...
>> Unless and until embedded_Hn aborts its simulation, then every nested
>> simulation immediately stops with none these simulated inputs ever
>> reaching their own final state of ⟨Ĥn.qn⟩ (thus halting).
>>
>> So embedded_Hn, and equivalently Hn, would be correct to report
>> non-halting. But Hn doesn't abort, so it can't.

On 3/29/2022 5:42 PM, Richard Damon wrote:
> On 3/29/22 8:33 AM, olcott wrote:
>
>> Talking about H ⟨Ĥ⟩ ⟨Ĥ⟩ diverges from the Linz proof thus is off topic.
>
>
> The only way that discussing the behavior of H <H^> <H^> woud b e off
> topic is if embedded_H isn't a copy of this H.
>

I will answer Ben and Dennis tomorrow when I have more time to make a
very thorough analysis to their objections.

Because it is stipulated that the Linz H has has its accept state ruined
by the appended infinite loop we know that a finite string compare of
their machine descriptions would not be identical. H is off topic. An
exact copy of H that has had its final accept state ruined is on topic
and is named embedded_H.

> That means that you aren't actually talking about the Linz Proof.
>
> THANK YOU for your confession.
>
>
>>
>> The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied
>> to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> FLAT OUT LIE.
>

I will tell you what I will do. I will give you the benefit of the doubt
on everything that I called a lie if you do the same for me.

THIS KEY OBJECTION INCORRECTLY SEEMS TO HAVE A CORRECT BASIS
As far as your belief that the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ outside of Ĥ must
have identical behavior to the simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ inside of Ĥ you can
carefully study my forthcoming reply to Ben and Dennis.

This is the only objection that incorrectly seems to have great merit.
That it fooled everyone including Linz means that it is very difficult
to understand that it is actually is an error.

I replied to your reply first only because I could do it quickly. I gave
you the high level overview of my forthcoming reply to Ben and Dennis.

--
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/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 for this reason:

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.

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

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

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
> So if you believe that embedded_H is correct to reject ⟨Ĥ⟩⟨Ĥ⟩, you *must* also believe that H3a is correct to reject <N><5>.

That is a very stupid thing to say.

>
>>
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer

--
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/30/2022 6:43 AM, Richard Damon wrote:
>
> On 3/29/22 11:32 PM, 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 for this reason:
>>
>> 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.
>>
>>
> But that is a falsehood.
>

No

> IF H^ applied to <H^ > Halts for ANY reason, it Halts.
>
Yes

> All simulations of a given machine MUST match the behavior of the
> machine itself,

The simulation of the finite string pair ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H is
specified by the actual behavior of this actual finite string input.

That you continue to believe that it is specified by a non-finite string
non-input conclusively proves that you consistently refuse to accept the
definition of deciders that only map finite string inputs to their own
accept or reject state.

> or BY DEFINITION, they are NOT a CORRECT Simulation, and
> al copies of a given Turing Mchine when given the same input must behave
> the same.
>

A simulating halt decider must terminate the simulation of any input
that would never otherwise halt because itself is required to halt.

As long as the simulation of the input ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H could never
reach is own final state of ⟨Ĥ.qn⟩ it is necessarily correct for
embedded_H to reject this input.

You perpetually confuse the transition from ⟨Ĥ⟩ to ⟨Ĥ.qn⟩ with the
transition from embedded_H to Ĥ.qn and just don't seem to have the
intellectual capacity to tell the difference. Maybe Dennis has enough
smarts to get this.

> This has been pointed out to you mny times, and you refuse to show an
> actual counter example to prove your claim.
>
> THis shows you are just a hypocritical pathological liar who doesn't
> understand a thing about the field.
>

Everything that I say can be easily confirmed as necessarily correct
entirely on the basis of the meaning of its words.

I rescind my prior accusations that you have lied. If Peter Linz could
not understand these things then it is more plausible that my reviewers
also simply do not understand the key nuances that I am providing.

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

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

The halt determiner that I will always be referring to always rejects
every simulated input that it correctly determines would never reach any
final state of this simulated input.

Every other input it simply remains in pure UTM mode until the input
reaches its own final state it then accepts this input.

Every other permutation from the above specification is merely the
dishonest attempt to try and get away with the strawman error and
absolutely will not be tolerated.

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

If you can show an example that perfectly conforms to the specification
and gets the wrong answer then and only then would it be relevant.

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.

This is like saying then when you know that you see a cat in your living
room then you know that this cat is not a dog.

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

This is like saying then when you know that you see a cat in your living
room then you know that this cat is not a dog.

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

This is why all of the screwy dishonest attempts at the strawman error
are not only very obviously dishonest they also waste my limited time.

CAN YOU PLEASE QUIT BEING SO FREAKING STUPID ?

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

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

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,

On 3/30/2022 7:09 PM, Richard Damon wrote:
> On 3/30/22 4:57 PM, olcott wrote:
>> On 3/30/2022 3:53 PM, Ben Bacarisse wrote:
>>> Dennis Bush <dbush.mobile@gmail.com> writes:
>>>
>>>> On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
>>>>> 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 / embedded_Ha, Ha rejects the input <Ha^><Ha^>
>>>> based on what it believe to be an infinite simulation.  Hb simulates
>>>> the input <Ha^><Ha^> for longer than Ha, where it sees that the
>>>> simulated input reaches its own final state. Hb then accepts this
>>>> input, therefore Ha rejecting the input <Ha^><Ha^> is wrong.
>>>
>>> PO is not good at notation.  He can see that your argument is correct,
>> Not at all. I can can no longer afford to tolerate the endless cycle
>> of strawman arguments. If I require my notation and my definitions
>> then the strawman error cannot possibly occur.
>>
>
> Then you have DOOMED yourself as your notation has inherent flaws.
>
> Your Choice.

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.

--
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/30/2022 7:53 PM, Richard Damon wrote:
> On 3/30/22 8:36 PM, olcott wrote:
>> On 3/30/2022 7:09 PM, Richard Damon wrote:
>>> On 3/30/22 4:57 PM, olcott wrote:
>>>> On 3/30/2022 3:53 PM, Ben Bacarisse wrote:
>>>>> Dennis Bush <dbush.mobile@gmail.com> writes:
>>>>>
>>>>>> On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
>>>>>>> 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 / embedded_Ha, Ha rejects the input <Ha^><Ha^>
>>>>>> based on what it believe to be an infinite simulation.  Hb simulates
>>>>>> the input <Ha^><Ha^> for longer than Ha, where it sees that the
>>>>>> simulated input reaches its own final state. Hb then accepts this
>>>>>> input, therefore Ha rejecting the input <Ha^><Ha^> is wrong.
>>>>>
>>>>> PO is not good at notation.  He can see that your argument is correct,
>>>> Not at all. I can can no longer afford to tolerate the endless cycle
>>>> of strawman arguments. If I require my notation and my definitions
>>>> then the strawman error cannot possibly occur.
>>>>
>>>
>>> Then you have DOOMED yourself as your notation has inherent flaws.
>>>
>>> Your Choice.
>>
>> 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.
>>
>
> Right, and for the simulation of <H^> <H^> that takes an infinite time,
> so HHH fails to meet the requrements of a Halt Decider.
>
> REFUTED.
>
> PROVE OTHERWISE.
>
> FAIL.

As soon as embedded_H sees an identical copy of a Turing Machine
description being called a second time with identical input it has
matched its infinite behavior pattern:

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then

embedded_H aborts the entire simulation chain just before embedded_H1 is
called with ⟨Ĥ2⟩ ⟨Ĥ3⟩

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

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.

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.

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.

On 3/31/2022 7:05 AM, Richard Damon wrote:
>
> On 3/30/22 10:51 PM, 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.
>
> And actual behavior is define by H <M> w needs to answer on the behavior
> of M applied to w.
>
So you either disagree with: