On 3/11/24 3:10 AM, Mikko wrote:
> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>
>> YOU don't get to define H^, Linz does, and when you changed your
>> computation environment, you need to go to the SEMANTIC definition of
>> H^, not the syntactic derived for Turing Machines.
>
> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
> machine that the Olcott machine H gets wrong.
>

Then Olcott would claim that I am changing the subject, and talking
about a different machine since it has a different name.

After all, the name is important to him.

On 3/11/24 7:38 AM, olcott wrote:
> On 3/11/2024 5:12 AM, Mikko wrote:
>> On 2024-03-10 14:59:13 +0000, olcott said:
>>
>>> On 3/10/2024 7:49 AM, Mikko wrote:
>>>> On 2024-03-09 18:22:53 +0000, Richard Damon said:
>>>>
>>>>> On 3/9/24 9:39 AM, olcott wrote:
>>>>>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>>>>>> On 3/9/24 8:41 AM, olcott wrote:
>>>>>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>>>>>>>>>>> description is, that H can't tell that it is part of an H^
>>>>>>>>>>>>> computation that is simulating an H^ computation.
>>>>>>>>>>>>
>>>>>>>>>>>> That subject must be postponed until after the Olcott
>>>>>>>>>>>> refutation
>>>>>>>>>>>> of the exact Linz proof is either fully accepted by three
>>>>>>>>>>>> people
>>>>>>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>>>>>>> corrected.
>>>>>>>>>>>
>>>>>>>>>>> It's accepted that the Linz proof doen't work on Olcott
>>>>>>>>>>> machines because the Linz proof is designed for Turing
>>>>>>>>>>> machines. But you can't refute the Linz-immibis proof
>>>>>>>>>>> designed for Olcott machines, where H is lied to about its
>>>>>>>>>>> own description.
>>>>>>>>>>
>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or
>>>>>>>>>> fail to halt
>>>>>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly
>>>>>>>>> the same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>>>>>
>>>>>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>>>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.
>>>>>>>
>>>>>>> How?
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>
>>>>> Comment are SPECIFICATION, not actual behavior until existance of a
>>>>> conforming H is proven
>>>>
>>>> To me they do not look like a specification but a false statement of
>>>> the actual behaviour (for some non-conforming H).
>>>>
>>>
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy  // Ĥ applied to ⟨Ĥ⟩ halts
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn  // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Unlike anyone else has ever done my simulating termination
>>> analyzers can always detect when their input will cause
>>> themselves to never terminate. I have demonstrated this
>>> for the Halting Problem's pathological input:
>>>
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> The earliest point when Turing machine H can detect the repeating
>>> state of Ĥ ⟨Ĥ⟩ is when Ĥ first reaches (c) where it would begin
>>> simulating a copy of itself with a copy of its input.
>>
>> Nice to see that you don't disagree with my opinion about the
>> apparent meahings.
>>
>
> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
> (He has neither reviewed nor agreed to anything else in this paper)
> (a) If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted then
> (b) H can abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
>
> That goes directly against this definition
> H(D,D) must report on the behavior of D(D).
> H ⟨Ĥ⟩ ⟨Ĥ⟩ must report on the behavior of Ĥ ⟨Ĥ⟩.
>
> The conventional definitions require the deciders to report
> on different behavior than the behavior they actually see.
>

Right, because it isn't a subjective question but on OBJECTIVE question.

You can't actually SEE the behavior that question asks about, but you
can do things, like simulation, that lets you determine things that
inform you of the criteria.

Pure simulation alone is not a viable method, as part of the property,
that of being non-halting, can't be determined infinte time with ust
simulation (you need to somehow be able to prove that it won't stop).

In part, that is the whole purpose of using a decider for a semantic, to
determine a property without having to actually RUN the machine and
observe it.

On 3/11/2024 11:21 AM, Richard Damon wrote:
> On 3/11/24 3:10 AM, Mikko wrote:
>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>
>>> YOU don't get to define H^, Linz does, and when you changed your
>>> computation environment, you need to go to the SEMANTIC definition of
>>> H^, not the syntactic derived for Turing Machines.
>>
>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>> machine that the Olcott machine H gets wrong.
>>
>
> Then Olcott would claim that I am changing the subject, and talking
> about a different machine since it has a different name.
>
> After all, the name is important to him.

H1(D,D) gets the right answer.
A Linz based H1 would simply wait three complete execution traces
and get the right answer.

I don't know of any other way that any Turing machine based
simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
input.

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

On 3/11/2024 11:31 AM, Richard Damon wrote:
> On 3/11/24 7:38 AM, olcott wrote:
>> On 3/11/2024 5:12 AM, Mikko wrote:
>>> On 2024-03-10 14:59:13 +0000, olcott said:
>>>
>>>> On 3/10/2024 7:49 AM, Mikko wrote:
>>>>> On 2024-03-09 18:22:53 +0000, Richard Damon said:
>>>>>
>>>>>> On 3/9/24 9:39 AM, olcott wrote:
>>>>>>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>>>>>>> On 3/9/24 8:41 AM, olcott wrote:
>>>>>>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>>>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what
>>>>>>>>>>>>>> its description is, that H can't tell that it is part of
>>>>>>>>>>>>>> an H^ computation that is simulating an H^ computation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That subject must be postponed until after the Olcott
>>>>>>>>>>>>> refutation
>>>>>>>>>>>>> of the exact Linz proof is either fully accepted by three
>>>>>>>>>>>>> people
>>>>>>>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>>>>>>>> corrected.
>>>>>>>>>>>>
>>>>>>>>>>>> It's accepted that the Linz proof doen't work on Olcott
>>>>>>>>>>>> machines because the Linz proof is designed for Turing
>>>>>>>>>>>> machines. But you can't refute the Linz-immibis proof
>>>>>>>>>>>> designed for Olcott machines, where H is lied to about its
>>>>>>>>>>>> own description.
>>>>>>>>>>>
>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or
>>>>>>>>>>> fail to halt
>>>>>>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly
>>>>>>>>>> the same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>>>>>>
>>>>>>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>>>>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its
>>>>>>>>> input.
>>>>>>>>
>>>>>>>> How?
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>
>>>>>> Comment are SPECIFICATION, not actual behavior until existance of
>>>>>> a conforming H is proven
>>>>>
>>>>> To me they do not look like a specification but a false statement of
>>>>> the actual behaviour (for some non-conforming H).
>>>>>
>>>>
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy  // Ĥ applied to ⟨Ĥ⟩ halts
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn  // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Unlike anyone else has ever done my simulating termination
>>>> analyzers can always detect when their input will cause
>>>> themselves to never terminate. I have demonstrated this
>>>> for the Halting Problem's pathological input:
>>>>
>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> The earliest point when Turing machine H can detect the repeating
>>>> state of Ĥ ⟨Ĥ⟩ is when Ĥ first reaches (c) where it would begin
>>>> simulating a copy of itself with a copy of its input.
>>>
>>> Nice to see that you don't disagree with my opinion about the
>>> apparent meahings.
>>>
>>
>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>> (He has neither reviewed nor agreed to anything else in this paper)
>> (a) If simulating halt decider H correctly simulates its input D until
>> H correctly determines that its simulated D would never stop running
>> unless aborted then
>> (b) H can abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>>
>> That goes directly against this definition
>> H(D,D) must report on the behavior of D(D).
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ must report on the behavior of Ĥ ⟨Ĥ⟩.
>>
>> The conventional definitions require the deciders to report
>> on different behavior than the behavior they actually see.
>>
>
> Right, because it isn't a subjective question but on OBJECTIVE question.
>
> You can't actually SEE the behavior that question asks about, but you
> can do things, like simulation, that lets you determine things that
> inform you of the criteria.
>
> Pure simulation alone is not a viable method, as part of the property,
> that of being non-halting, can't be determined infinte time with ust
> simulation (you need to somehow be able to prove that it won't stop).
>
> In part, that is the whole purpose of using a decider for a semantic, to
> determine a property without having to actually RUN the machine and
> observe it.

A specification is objective if the specified behavior does
not depend on the agent that performs it, and subjective if
it does. The Church-Turing Thesis applies to objective
specifications, not to subjective ones. (Hehner:2017)

*Objective and Subjective Specifications*
https://www.cs.toronto.edu/~hehner/OSS.pdf

Because H(D,D) must abort the simulation of its input and H1(D,D)
need not abort the simulation of its input this proves that the
halting problem specification is subjective(Hehner).

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

On 3/11/24 9:14 AM, olcott wrote:
> On 3/11/2024 10:16 AM, Mikko wrote:
>> On 2024-03-11 14:38:58 +0000, olcott said:
>>
>>> On 3/11/2024 5:12 AM, Mikko wrote:
>>>> On 2024-03-10 14:59:13 +0000, olcott said:
>>>>
>>>>> On 3/10/2024 7:49 AM, Mikko wrote:
>>>>>> On 2024-03-09 18:22:53 +0000, Richard Damon said:
>>>>>>
>>>>>>> On 3/9/24 9:39 AM, olcott wrote:
>>>>>>>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 8:41 AM, olcott wrote:
>>>>>>>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>>>>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what
>>>>>>>>>>>>>>> its description is, that H can't tell that it is part of
>>>>>>>>>>>>>>> an H^ computation that is simulating an H^ computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That subject must be postponed until after the Olcott
>>>>>>>>>>>>>> refutation
>>>>>>>>>>>>>> of the exact Linz proof is either fully accepted by three
>>>>>>>>>>>>>> people
>>>>>>>>>>>>>> or actual errors or gaps are found that cannot be
>>>>>>>>>>>>>> addressed or
>>>>>>>>>>>>>> corrected.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It's accepted that the Linz proof doen't work on Olcott
>>>>>>>>>>>>> machines because the Linz proof is designed for Turing
>>>>>>>>>>>>> machines. But you can't refute the Linz-immibis proof
>>>>>>>>>>>>> designed for Olcott machines, where H is lied to about its
>>>>>>>>>>>>> own description.
>>>>>>>>>>>>
>>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or
>>>>>>>>>>>> fail to halt
>>>>>>>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for
>>>>>>>>>>> exactly the same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>>>>>>>
>>>>>>>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>>>>>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its
>>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> How?
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>
>>>>>>> Comment are SPECIFICATION, not actual behavior until existance of
>>>>>>> a conforming H is proven
>>>>>>
>>>>>> To me they do not look like a specification but a false statement of
>>>>>> the actual behaviour (for some non-conforming H).
>>>>>>
>>>>>
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy  // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn  // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Unlike anyone else has ever done my simulating termination
>>>>> analyzers can always detect when their input will cause
>>>>> themselves to never terminate. I have demonstrated this
>>>>> for the Halting Problem's pathological input:
>>>>>
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> The earliest point when Turing machine H can detect the repeating
>>>>> state of Ĥ ⟨Ĥ⟩ is when Ĥ first reaches (c) where it would begin
>>>>> simulating a copy of itself with a copy of its input.
>>>>
>>>> Nice to see that you don't disagree with my opinion about the
>>>> apparent meahings.
>>>>
>>>
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never stop
>>> running unless aborted then
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> That goes directly against this definition
>>> H(D,D) must report on the behavior of D(D).
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ must report on the behavior of Ĥ ⟨Ĥ⟩.
>>>
>>> The conventional definitions require the deciders to report
>>> on different behavior than the behavior they actually see.
>>
>> If they don't actually see the behaviour they are reqquired to report on
>> the deciders are defective, not the requirements.
>>
>
> A specification is objective if the specified behavior does not
> depend on the agent that performs it, and subjective if it does.
> The Church-Turing Thesis applies to objective specifications,
> not to subjective ones.
>
> *Objective and Subjective Specifications*
> https://www.cs.toronto.edu/~hehner/OSS.pdf
>
> Because H(D,D) must abort the simulation of its input and H1(D,D)
> need not abort the simulation of its input this proves that the
> halting problem specification is subjective(Hehner).
>

The fact that H1 doesn't NEED to abort its simulation, says H didn't
either, but it does.

Change H o not abort its processing, but keep the input the same, as
defined in the problem, and H can get the answer. Remember, the input
FULLY DEFINES the computation being decided on and giving it to
different deciders doesn't change it.

Of course, H CAN'T Change who it is, so that is just a mission of fantasy.

Your problem is you have changed the definition of the problem, either
due to you ignorance (except the error has been pointed out so many
times you can't call it an honest mistake) or as an intentional act of
deception.

H^ does NOT use the decider that is deciding on it (and thus the changed
H) but always and only the original machine that it was built to foil.

You seem to not understand the fundamental property of programming in
Computation Theory that if you change the program, you have a new
program, not the same program changed.

On 3/11/24 9:34 AM, olcott wrote:
> On 3/11/2024 11:31 AM, Richard Damon wrote:
>> On 3/11/24 7:38 AM, olcott wrote:
>>> On 3/11/2024 5:12 AM, Mikko wrote:
>>>> On 2024-03-10 14:59:13 +0000, olcott said:
>>>>
>>>>> On 3/10/2024 7:49 AM, Mikko wrote:
>>>>>> On 2024-03-09 18:22:53 +0000, Richard Damon said:
>>>>>>
>>>>>>> On 3/9/24 9:39 AM, olcott wrote:
>>>>>>>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 8:41 AM, olcott wrote:
>>>>>>>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>>>>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what
>>>>>>>>>>>>>>> its description is, that H can't tell that it is part of
>>>>>>>>>>>>>>> an H^ computation that is simulating an H^ computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That subject must be postponed until after the Olcott
>>>>>>>>>>>>>> refutation
>>>>>>>>>>>>>> of the exact Linz proof is either fully accepted by three
>>>>>>>>>>>>>> people
>>>>>>>>>>>>>> or actual errors or gaps are found that cannot be
>>>>>>>>>>>>>> addressed or
>>>>>>>>>>>>>> corrected.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It's accepted that the Linz proof doen't work on Olcott
>>>>>>>>>>>>> machines because the Linz proof is designed for Turing
>>>>>>>>>>>>> machines. But you can't refute the Linz-immibis proof
>>>>>>>>>>>>> designed for Olcott machines, where H is lied to about its
>>>>>>>>>>>>> own description.
>>>>>>>>>>>>
>>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or
>>>>>>>>>>>> fail to halt
>>>>>>>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for
>>>>>>>>>>> exactly the same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>>>>>>>
>>>>>>>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>>>>>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its
>>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>> How?
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>
>>>>>>> Comment are SPECIFICATION, not actual behavior until existance of
>>>>>>> a conforming H is proven
>>>>>>
>>>>>> To me they do not look like a specification but a false statement of
>>>>>> the actual behaviour (for some non-conforming H).
>>>>>>
>>>>>
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy  // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn  // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Unlike anyone else has ever done my simulating termination
>>>>> analyzers can always detect when their input will cause
>>>>> themselves to never terminate. I have demonstrated this
>>>>> for the Halting Problem's pathological input:
>>>>>
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> The earliest point when Turing machine H can detect the repeating
>>>>> state of Ĥ ⟨Ĥ⟩ is when Ĥ first reaches (c) where it would begin
>>>>> simulating a copy of itself with a copy of its input.
>>>>
>>>> Nice to see that you don't disagree with my opinion about the
>>>> apparent meahings.
>>>>
>>>
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) If simulating halt decider H correctly simulates its input D
>>> until H correctly determines that its simulated D would never stop
>>> running unless aborted then
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> That goes directly against this definition
>>> H(D,D) must report on the behavior of D(D).
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ must report on the behavior of Ĥ ⟨Ĥ⟩.
>>>
>>> The conventional definitions require the deciders to report
>>> on different behavior than the behavior they actually see.
>>>
>>
>> Right, because it isn't a subjective question but on OBJECTIVE question.
>>
>> You can't actually SEE the behavior that question asks about, but you
>> can do things, like simulation, that lets you determine things that
>> inform you of the criteria.
>>
>> Pure simulation alone is not a viable method, as part of the property,
>> that of being non-halting, can't be determined infinte time with ust
>> simulation (you need to somehow be able to prove that it won't stop).
>>
>> In part, that is the whole purpose of using a decider for a semantic,
>> to determine a property without having to actually RUN the machine and
>> observe it.
>
>   A specification is objective if the specified behavior does
>   not depend on the agent that performs it, and subjective if
>   it does. The Church-Turing Thesis applies to objective
>   specifications, not to subjective ones. (Hehner:2017)
>
> *Objective and Subjective Specifications*
> https://www.cs.toronto.edu/~hehner/OSS.pdf
>
> Because H(D,D) must abort the simulation of its input and H1(D,D)
> need not abort the simulation of its input this proves that the
> halting problem specification is subjective(Hehner).
>
>

The fact that H1 doesn't NEED to abort its simulation, says H didn't
either, but it does.

Change H o not abort its processing, but keep the input the same, as
defined in the problem, and H can get the answer. Remember, the input
FULLY DEFINES the computation being decided on and giving it to
different deciders doesn't change it.

Of course, H CAN'T Change who it is, so that is just a mission of fantasy.

Your problem is you have changed the definition of the problem, either
due to you ignorance (except the error has been pointed out so many
times you can't call it an honest mistake) or as an intentional act of
deception.

H^ does NOT use the decider that is deciding on it (and thus the changed
H) but always and only the original machine that it was built to foil.

You seem to not understand the fundamental property of programming in
Computation Theory that if you change the program, you have a new
program, not the same program changed.

On 3/11/24 9:32 AM, olcott wrote:
> On 3/11/2024 11:21 AM, Richard Damon wrote:
>> On 3/11/24 3:10 AM, Mikko wrote:
>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>
>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>> computation environment, you need to go to the SEMANTIC definition
>>>> of H^, not the syntactic derived for Turing Machines.
>>>
>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>> machine that the Olcott machine H gets wrong.
>>>
>>
>> Then Olcott would claim that I am changing the subject, and talking
>> about a different machine since it has a different name.
>>
>> After all, the name is important to him.
>
> H1(D,D) gets the right answer.
> A Linz based H1 would simply wait three complete execution traces
> and get the right answer.
>
> I don't know of any other way that any Turing machine based
> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
> input.
>

Right, you don't know how it could get the right answer, but claims it will.

Thus, you ADMIT that you are just making up your facts.

If H1 waits "three complete execuiton traces to try to get the "right
answer", then H1^ will also wait 3 complete execution cycles to decide
on its "right" answer, so H1(H1^, H1^), by its programming will see that
H1^ is still working on getting its right answer, and then stop and
guess wrong.

You just don't understand that the ^ machine looks at the actual
behavior that the decider that is designed to foil will think that it
has, and do the opposite, proving that decider wrong.

Thus, that machine can not get the right answer for this question.

Since we CAN build this input for every possible decider, no deciders
get all their inputs correctly.

Thus showing that Halt Deciding can not be done with a computation.

PERIOD.

You have spent decades claiming the opposite, which is like trying to
claim that the color Red is actually the Color Blue.

On 3/11/2024 3:05 PM, Richard Damon wrote:
> On 3/11/24 9:32 AM, olcott wrote:
>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>
>>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>>> computation environment, you need to go to the SEMANTIC definition
>>>>> of H^, not the syntactic derived for Turing Machines.
>>>>
>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>>> machine that the Olcott machine H gets wrong.
>>>>
>>>
>>> Then Olcott would claim that I am changing the subject, and talking
>>> about a different machine since it has a different name.
>>>
>>> After all, the name is important to him.
>>
>> H1(D,D) gets the right answer.
>> A Linz based H1 would simply wait three complete execution traces
>> and get the right answer.
>>
>> I don't know of any other way that any Turing machine based
>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>> input.
>>
>
> Right, you don't know how it could get the right answer, but claims it
> will.

I did not say that.

>
> Thus, you ADMIT that you are just making up your facts.
>
> If H1 waits "three complete execuiton traces to try to get the "right
> answer", then H1^ will also wait 3 complete execution cycles to decide
> on its "right" answer, so H1(H1^, H1^), by its programming will see that
> H1^ is still working on getting its right answer, and then stop and
> guess wrong.

If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.

>
> You just don't understand that the ^ machine looks at the actual
> behavior that the decider that is designed to foil will think that it
> has, and do the opposite, proving that decider wrong.
>

D cannot do that for H1(D,D) and Linz Ĥ cannot do that for
H1 adapted from Linz H to wait three cycles before deciding.

> Thus, that machine can not get the right answer for this question.
>
> Since we CAN build this input for every possible decider, no deciders
> get all their inputs correctly.
>
Under the current incoherent definition of the problem.

> Thus showing that Halt Deciding can not be done with a computation.
>
> PERIOD.
>
Immbis says that this is the same thing as not being able
to compute the square-root of an actual banana.

> You have spent decades claiming the opposite, which is like trying to
> claim that the color Red is actually the Color Blue.

There <is> an error in the foundation of True(x)
that hardly anyone besides has ever noticed.

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

On 3/11/24 1:19 PM, olcott wrote:
> On 3/11/2024 3:05 PM, Richard Damon wrote:
>> On 3/11/24 9:32 AM, olcott wrote:
>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>
>>>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>>>> computation environment, you need to go to the SEMANTIC definition
>>>>>> of H^, not the syntactic derived for Turing Machines.
>>>>>
>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>>>> machine that the Olcott machine H gets wrong.
>>>>>
>>>>
>>>> Then Olcott would claim that I am changing the subject, and talking
>>>> about a different machine since it has a different name.
>>>>
>>>> After all, the name is important to him.
>>>
>>> H1(D,D) gets the right answer.
>>> A Linz based H1 would simply wait three complete execution traces
>>> and get the right answer.
>>>
>>> I don't know of any other way that any Turing machine based
>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> input.
>>>
>>
>> Right, you don't know how it could get the right answer, but claims it
>> will.
>
> I did not say that.

YOu effectctiely did.

>
>>
>> Thus, you ADMIT that you are just making up your facts.
>>
>> If H1 waits "three complete execuiton traces to try to get the "right
>> answer", then H1^ will also wait 3 complete execution cycles to decide
>> on its "right" answer, so H1(H1^, H1^), by its programming will see
>> that H1^ is still working on getting its right answer, and then stop
>> and guess wrong.
>
> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.

Nooe, H^.H1 waits just as long as H1 does.

You don't seem to understand that.

BECAUSE YOU ARE IGNORANT.

>
>>
>> You just don't understand that the ^ machine looks at the actual
>> behavior that the decider that is designed to foil will think that it
>> has, and do the opposite, proving that decider wrong.
>>
>
> D cannot do that for H1(D,D) and Linz Ĥ cannot do that for
> H1 adapted from Linz H to wait three cycles before deciding.

Why not?

I guess your world is not Turing Complete.

But that must just be "Greek to you"

>
>> Thus, that machine can not get the right answer for this question.
>>
>> Since we CAN build this input for every possible decider, no deciders
>> get all their inputs correctly.
>>
> Under the current incoherent definition of the problem.

Nope, under the definition of Computations and Turing Machine,

I guess you just don't understand the first principles of Computation.

>
>> Thus showing that Halt Deciding can not be done with a computation.
>>
>> PERIOD.
>>
> Immbis says that this is the same thing as not being able
> to compute the square-root of an actual banana.

Nope,

>
>> You have spent decades claiming the opposite, which is like trying to
>> claim that the color Red is actually the Color Blue.
>
> There <is> an error in the foundation of True(x)
> that hardly anyone besides has ever noticed.
>

Then actually DO something about it!!

(If you can, which I doubt)

You are just proving yourself a HYPOCRITE for using logic systems you
say are broken.

And a LIAR for saying you are working in them when you are trying to use
them with changed definitions from the system, and not even
understanding what the definitions are, so making up your own.

On 3/11/2024 6:19 PM, Richard Damon wrote:
> On 3/11/24 1:19 PM, olcott wrote:
>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>> On 3/11/24 9:32 AM, olcott wrote:
>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>
>>>>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>>>>> computation environment, you need to go to the SEMANTIC
>>>>>>> definition of H^, not the syntactic derived for Turing Machines.
>>>>>>
>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>
>>>>>
>>>>> Then Olcott would claim that I am changing the subject, and talking
>>>>> about a different machine since it has a different name.
>>>>>
>>>>> After all, the name is important to him.
>>>>
>>>> H1(D,D) gets the right answer.
>>>> A Linz based H1 would simply wait three complete execution traces
>>>> and get the right answer.
>>>>
>>>> I don't know of any other way that any Turing machine based
>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> input.
>>>>
>>>
>>> Right, you don't know how it could get the right answer, but claims
>>> it will.
>>
>> I did not say that.
>
> YOu effectctiely did.
>
>>
>>>
>>> Thus, you ADMIT that you are just making up your facts.
>>>
>>> If H1 waits "three complete execuiton traces to try to get the "right
>>> answer", then H1^ will also wait 3 complete execution cycles to
>>> decide on its "right" answer, so H1(H1^, H1^), by its programming
>>> will see that H1^ is still working on getting its right answer, and
>>> then stop and guess wrong.
>>
>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>
> Nooe, H^.H1 waits just as long as H1 does.
>

It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.

Your failure to pay attention is causing me to lose
interest in carefully reviewing what you say.

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

On 3/11/24 4:25 PM, olcott wrote:
> On 3/11/2024 6:19 PM, Richard Damon wrote:
>> On 3/11/24 1:19 PM, olcott wrote:
>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>
>>>>>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>>>>>> computation environment, you need to go to the SEMANTIC
>>>>>>>> definition of H^, not the syntactic derived for Turing Machines.
>>>>>>>
>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for
>>>>>>> the
>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>
>>>>>>
>>>>>> Then Olcott would claim that I am changing the subject, and
>>>>>> talking about a different machine since it has a different name.
>>>>>>
>>>>>> After all, the name is important to him.
>>>>>
>>>>> H1(D,D) gets the right answer.
>>>>> A Linz based H1 would simply wait three complete execution traces
>>>>> and get the right answer.
>>>>>
>>>>> I don't know of any other way that any Turing machine based
>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> input.
>>>>>
>>>>
>>>> Right, you don't know how it could get the right answer, but claims
>>>> it will.
>>>
>>> I did not say that.
>>
>> YOu effectctiely did.
>>
>>>
>>>>
>>>> Thus, you ADMIT that you are just making up your facts.
>>>>
>>>> If H1 waits "three complete execuiton traces to try to get the
>>>> "right answer", then H1^ will also wait 3 complete execution cycles
>>>> to decide on its "right" answer, so H1(H1^, H1^), by its programming
>>>> will see that H1^ is still working on getting its right answer, and
>>>> then stop and guess wrong.
>>>
>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>
>> Nooe, H^.H1 waits just as long as H1 does.
>>
>
> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>
> Your failure to pay attention is causing me to lose
> interest in carefully reviewing what you say.
>

It is if H1 is the Machine you are claiming to be the correct Halt
Decide, the Linz H

H^ is built on the H that you claim.

If that H is not H1, you build H1^

You are just showing how badly you need to lie and cheet.

On 3/11/2024 8:48 PM, Richard Damon wrote:
> On 3/11/24 4:25 PM, olcott wrote:
>> On 3/11/2024 6:19 PM, Richard Damon wrote:
>>> On 3/11/24 1:19 PM, olcott wrote:
>>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>>
>>>>>>>>> YOU don't get to define H^, Linz does, and when you changed
>>>>>>>>> your computation environment, you need to go to the SEMANTIC
>>>>>>>>> definition of H^, not the syntactic derived for Turing Machines.
>>>>>>>>
>>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ,
>>>>>>>> for the
>>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>>
>>>>>>>
>>>>>>> Then Olcott would claim that I am changing the subject, and
>>>>>>> talking about a different machine since it has a different name.
>>>>>>>
>>>>>>> After all, the name is important to him.
>>>>>>
>>>>>> H1(D,D) gets the right answer.
>>>>>> A Linz based H1 would simply wait three complete execution traces
>>>>>> and get the right answer.
>>>>>>
>>>>>> I don't know of any other way that any Turing machine based
>>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> input.
>>>>>>
>>>>>
>>>>> Right, you don't know how it could get the right answer, but claims
>>>>> it will.
>>>>
>>>> I did not say that.
>>>
>>> YOu effectctiely did.
>>>
>>>>
>>>>>
>>>>> Thus, you ADMIT that you are just making up your facts.
>>>>>
>>>>> If H1 waits "three complete execuiton traces to try to get the
>>>>> "right answer", then H1^ will also wait 3 complete execution cycles
>>>>> to decide on its "right" answer, so H1(H1^, H1^), by its
>>>>> programming will see that H1^ is still working on getting its right
>>>>> answer, and then stop and guess wrong.
>>>>
>>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>>
>>> Nooe, H^.H1 waits just as long as H1 does.
>>>
>>
>> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
>> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>>
>> Your failure to pay attention is causing me to lose
>> interest in carefully reviewing what you say.
>>
>
> It is if H1 is the Machine you are claiming to be the correct Halt
> Decide, the Linz H
>
> H^ is built on the H that you claim.
>
> If that H is not H1, you build H1^
>
> You are just showing how badly you need to lie and cheet.

I am just saying that the Linz H/Ĥ has a machine like H1 that
decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.

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

On 12/03/24 02:56, olcott wrote:
> I am just saying that the Linz H/Ĥ has a machine like H1 that
> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.

So what? Linz said that there isn't a program that gets ALL inputs correct.

On 3/11/2024 9:18 PM, immibis wrote:
> On 12/03/24 02:56, olcott wrote:
>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>
> So what? Linz said that there isn't a program that gets ALL inputs correct.
>

I just wanted to make sure that you understood what I was saying.
I initially couldn't tell that any decider could get ⟨Ĥ⟩ ⟨Ĥ⟩ correctly.
I didn't initially know how it cold do this.

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

On 3/11/24 6:56 PM, olcott wrote:
> On 3/11/2024 8:48 PM, Richard Damon wrote:
>> On 3/11/24 4:25 PM, olcott wrote:
>>> On 3/11/2024 6:19 PM, Richard Damon wrote:
>>>> On 3/11/24 1:19 PM, olcott wrote:
>>>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>>>
>>>>>>>>>> YOU don't get to define H^, Linz does, and when you changed
>>>>>>>>>> your computation environment, you need to go to the SEMANTIC
>>>>>>>>>> definition of H^, not the syntactic derived for Turing Machines.
>>>>>>>>>
>>>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ,
>>>>>>>>> for the
>>>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Then Olcott would claim that I am changing the subject, and
>>>>>>>> talking about a different machine since it has a different name.
>>>>>>>>
>>>>>>>> After all, the name is important to him.
>>>>>>>
>>>>>>> H1(D,D) gets the right answer.
>>>>>>> A Linz based H1 would simply wait three complete execution traces
>>>>>>> and get the right answer.
>>>>>>>
>>>>>>> I don't know of any other way that any Turing machine based
>>>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> input.
>>>>>>>
>>>>>>
>>>>>> Right, you don't know how it could get the right answer, but
>>>>>> claims it will.
>>>>>
>>>>> I did not say that.
>>>>
>>>> YOu effectctiely did.
>>>>
>>>>>
>>>>>>
>>>>>> Thus, you ADMIT that you are just making up your facts.
>>>>>>
>>>>>> If H1 waits "three complete execuiton traces to try to get the
>>>>>> "right answer", then H1^ will also wait 3 complete execution
>>>>>> cycles to decide on its "right" answer, so H1(H1^, H1^), by its
>>>>>> programming will see that H1^ is still working on getting its
>>>>>> right answer, and then stop and guess wrong.
>>>>>
>>>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>>>
>>>> Nooe, H^.H1 waits just as long as H1 does.
>>>>
>>>
>>> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
>>> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>>>
>>> Your failure to pay attention is causing me to lose
>>> interest in carefully reviewing what you say.
>>>
>>
>> It is if H1 is the Machine you are claiming to be the correct Halt
>> Decide, the Linz H
>>
>> H^ is built on the H that you claim.
>>
>> If that H is not H1, you build H1^
>>
>> You are just showing how badly you need to lie and cheet.
>
> I am just saying that the Linz H/Ĥ has a machine like H1 that
> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>

Ok, but that is irrelevent. Linz never claimed that some other decider
besides H couldn't decide H^ correctly.

So, that is just more Red Herring and distractions.

H1 is NOT H, so doesnt' "FIX" the fact that H failed.

On 3/11/2024 11:07 PM, Richard Damon wrote:
> On 3/11/24 6:56 PM, olcott wrote:
>> On 3/11/2024 8:48 PM, Richard Damon wrote:
>>> On 3/11/24 4:25 PM, olcott wrote:
>>>> On 3/11/2024 6:19 PM, Richard Damon wrote:
>>>>> On 3/11/24 1:19 PM, olcott wrote:
>>>>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>>>>
>>>>>>>>>>> YOU don't get to define H^, Linz does, and when you changed
>>>>>>>>>>> your computation environment, you need to go to the SEMANTIC
>>>>>>>>>>> definition of H^, not the syntactic derived for Turing Machines.
>>>>>>>>>>
>>>>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ,
>>>>>>>>>> for the
>>>>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Then Olcott would claim that I am changing the subject, and
>>>>>>>>> talking about a different machine since it has a different name.
>>>>>>>>>
>>>>>>>>> After all, the name is important to him.
>>>>>>>>
>>>>>>>> H1(D,D) gets the right answer.
>>>>>>>> A Linz based H1 would simply wait three complete execution traces
>>>>>>>> and get the right answer.
>>>>>>>>
>>>>>>>> I don't know of any other way that any Turing machine based
>>>>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> input.
>>>>>>>>
>>>>>>>
>>>>>>> Right, you don't know how it could get the right answer, but
>>>>>>> claims it will.
>>>>>>
>>>>>> I did not say that.
>>>>>
>>>>> YOu effectctiely did.
>>>>>
>>>>>>
>>>>>>>
>>>>>>> Thus, you ADMIT that you are just making up your facts.
>>>>>>>
>>>>>>> If H1 waits "three complete execuiton traces to try to get the
>>>>>>> "right answer", then H1^ will also wait 3 complete execution
>>>>>>> cycles to decide on its "right" answer, so H1(H1^, H1^), by its
>>>>>>> programming will see that H1^ is still working on getting its
>>>>>>> right answer, and then stop and guess wrong.
>>>>>>
>>>>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>>>>
>>>>> Nooe, H^.H1 waits just as long as H1 does.
>>>>>
>>>>
>>>> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
>>>> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>>>>
>>>> Your failure to pay attention is causing me to lose
>>>> interest in carefully reviewing what you say.
>>>>
>>>
>>> It is if H1 is the Machine you are claiming to be the correct Halt
>>> Decide, the Linz H
>>>
>>> H^ is built on the H that you claim.
>>>
>>> If that H is not H1, you build H1^
>>>
>>> You are just showing how badly you need to lie and cheet.
>>
>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>>
>
>
> Ok, but that is irrelevent. Linz never claimed that some other decider
> besides H couldn't decide H^ correctly.
>
> So, that is just more Red Herring and distractions.
>
> H1 is NOT H, so doesnt' "FIX" the fact that H failed.

I just wanted to be understood.

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

On 3/11/24 8:26 PM, olcott wrote:
> On 3/11/2024 9:18 PM, immibis wrote:
>> On 12/03/24 02:56, olcott wrote:
>>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>>
>> So what? Linz said that there isn't a program that gets ALL inputs
>> correct.
>>
>
> I just wanted to make sure that you understood what I was saying.
> I initially couldn't tell that any decider could get ⟨Ĥ⟩ ⟨Ĥ⟩ correctly.
> I didn't initially know how it cold do this.
>

Your just NOW figuring that out?

Now, if this is in the new Olcott machines, where H counts on H^.H
seeing the recursions (which it doesn't) then H1 fails just like H in
waiting forever on a never halting infinite recursion.

But, assuming that somehow you get H to incorrect abort it simulation,
and that method doesn't cause H1 to also abort its simulation, then H1
can get a right answer.

On 2024-03-11 16:32:36 +0000, olcott said:

> On 3/11/2024 11:21 AM, Richard Damon wrote:
>> On 3/11/24 3:10 AM, Mikko wrote:
>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>
>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>> computation environment, you need to go to the SEMANTIC definition of
>>>> H^, not the syntactic derived for Turing Machines.
>>>
>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>> machine that the Olcott machine H gets wrong.
>>>
>>
>> Then Olcott would claim that I am changing the subject, and talking
>> about a different machine since it has a different name.
>>
>> After all, the name is important to him.
>
> H1(D,D) gets the right answer.
> A Linz based H1 would simply wait three complete execution traces
> and get the right answer.
>
> I don't know of any other way that any Turing machine based
> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
> input.

H1(D,D) gets the right answer about D(D) but there is another
computation that it gets wrotng so H1 is not the correct solution.

H2 might get right some computation that H1 gets wrong,
and H3 might get right some computation that H2 gets wrogn,
&c., but there is no decider that gets all computations right.

--
Mikko

On 2024-03-12 04:22:15 +0000, olcott said:

> On 3/11/2024 11:07 PM, Richard Damon wrote:
>> On 3/11/24 6:56 PM, olcott wrote:
>>> On 3/11/2024 8:48 PM, Richard Damon wrote:
>>>> On 3/11/24 4:25 PM, olcott wrote:
>>>>> On 3/11/2024 6:19 PM, Richard Damon wrote:
>>>>>> On 3/11/24 1:19 PM, olcott wrote:
>>>>>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>>>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>>>>>
>>>>>>>>>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>>>>>>>>>> computation environment, you need to go to the SEMANTIC definition of
>>>>>>>>>>>> H^, not the syntactic derived for Turing Machines.
>>>>>>>>>>>
>>>>>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>>>>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then Olcott would claim that I am changing the subject, and talking
>>>>>>>>>> about a different machine since it has a different name.
>>>>>>>>>>
>>>>>>>>>> After all, the name is important to him.
>>>>>>>>>
>>>>>>>>> H1(D,D) gets the right answer.
>>>>>>>>> A Linz based H1 would simply wait three complete execution traces
>>>>>>>>> and get the right answer.
>>>>>>>>>
>>>>>>>>> I don't know of any other way that any Turing machine based
>>>>>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> input.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, you don't know how it could get the right answer, but claims it will.
>>>>>>>
>>>>>>> I did not say that.
>>>>>>
>>>>>> YOu effectctiely did.
>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Thus, you ADMIT that you are just making up your facts.
>>>>>>>>
>>>>>>>> If H1 waits "three complete execuiton traces to try to get the "right
>>>>>>>> answer", then H1^ will also wait 3 complete execution cycles to decide
>>>>>>>> on its "right" answer, so H1(H1^, H1^), by its programming will see
>>>>>>>> that H1^ is still working on getting its right answer, and then stop
>>>>>>>> and guess wrong.
>>>>>>>
>>>>>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>>>>>
>>>>>> Nooe, H^.H1 waits just as long as H1 does.
>>>>>>
>>>>>
>>>>> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
>>>>> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>>>>>
>>>>> Your failure to pay attention is causing me to lose
>>>>> interest in carefully reviewing what you say.
>>>>>
>>>>
>>>> It is if H1 is the Machine you are claiming to be the correct Halt
>>>> Decide, the Linz H
>>>>
>>>> H^ is built on the H that you claim.
>>>>
>>>> If that H is not H1, you build H1^
>>>>
>>>> You are just showing how badly you need to lie and cheet.
>>>
>>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>>>
>>
>>
>> Ok, but that is irrelevent. Linz never claimed that some other decider
>> besides H couldn't decide H^ correctly.
>>
>> So, that is just more Red Herring and distractions.
>>
>> H1 is NOT H, so doesnt' "FIX" the fact that H failed.
>
> I just wanted to be understood.

If you want to be understood you must offer at least some motivation
to at least try to understand you. When people understand that you
try to cheat but fail they hardly expect anything useful or interesting.
Also, you too often repeat what you said, which is taken to indicate
that you have nothing interesting to offer.

--
Mikko

On 2024-03-11 16:14:29 +0000, olcott said:

> On 3/11/2024 10:16 AM, Mikko wrote:
>> On 2024-03-11 14:38:58 +0000, olcott said:
>>
>>> On 3/11/2024 5:12 AM, Mikko wrote:
>>>> On 2024-03-10 14:59:13 +0000, olcott said:
>>>>
>>>>> On 3/10/2024 7:49 AM, Mikko wrote:
>>>>>> On 2024-03-09 18:22:53 +0000, Richard Damon said:
>>>>>>
>>>>>>> On 3/9/24 9:39 AM, olcott wrote:
>>>>>>>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 8:41 AM, olcott wrote:
>>>>>>>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>>>>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what its description
>>>>>>>>>>>>>>> is, that H can't tell that it is part of an H^ computation that is
>>>>>>>>>>>>>>> simulating an H^ computation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That subject must be postponed until after the Olcott refutation
>>>>>>>>>>>>>> of the exact Linz proof is either fully accepted by three people
>>>>>>>>>>>>>> or actual errors or gaps are found that cannot be addressed or
>>>>>>>>>>>>>> corrected.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It's accepted that the Linz proof doen't work on Olcott machines
>>>>>>>>>>>>> because the Linz proof is designed for Turing machines. But you can't
>>>>>>>>>>>>> refute the Linz-immibis proof designed for Olcott machines, where H is
>>>>>>>>>>>>> lied to about its own description.
>>>>>>>>>>>>
>>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
>>>>>>>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the same
>>>>>>>>>>> thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>>>>>>>
>>>>>>>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the simulation of
>>>>>>>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its input.
>>>>>>>>>
>>>>>>>>> How?
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>>
>>>>>>> Comment are SPECIFICATION, not actual behavior until existance of a
>>>>>>> conforming H is proven
>>>>>>
>>>>>> To me they do not look like a specification but a false statement of
>>>>>> the actual behaviour (for some non-conforming H).
>>>>>>
>>>>>
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy  // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn  // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Unlike anyone else has ever done my simulating termination
>>>>> analyzers can always detect when their input will cause
>>>>> themselves to never terminate. I have demonstrated this
>>>>> for the Halting Problem's pathological input:
>>>>>
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> The earliest point when Turing machine H can detect the repeating
>>>>> state of Ĥ ⟨Ĥ⟩ is when Ĥ first reaches (c) where it would begin
>>>>> simulating a copy of itself with a copy of its input.
>>>>
>>>> Nice to see that you don't disagree with my opinion about the
>>>> apparent meahings.
>>>>
>>>
>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>> (He has neither reviewed nor agreed to anything else in this paper)
>>> (a) If simulating halt decider H correctly simulates its input D until
>>> H correctly determines that its simulated D would never stop running
>>> unless aborted then
>>> (b) H can abort its simulation of D and correctly report that D
>>> specifies a non-halting sequence of configurations.
>>>
>>> That goes directly against this definition
>>> H(D,D) must report on the behavior of D(D).
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ must report on the behavior of Ĥ ⟨Ĥ⟩.
>>>
>>> The conventional definitions require the deciders to report
>>> on different behavior than the behavior they actually see.
>>
>> If they don't actually see the behaviour they are reqquired to report on
>> the deciders are defective, not the requirements.
>>
>
> A specification is objective if the specified behavior does not
> depend on the agent that performs it, and subjective if it does.

Only if it doesn't depend on who compares the actual behaviour to
the specification, either.

> The Church-Turing Thesis applies to objective specifications,
> not to subjective ones.

As presented, it applies to both. Whether it really is true about
either kind is unknown.

> Because H(D,D) must abort the simulation of its input and H1(D,D)
> need not abort the simulation of its input this proves that the
> halting problem specification is subjective(Hehner).

Whether H(D,D) must abort its simulation is not part of the
specification of halting decider. Other specifications are
irrelevant. The specification of halting decider is objective:
in order to determine whether the behaviout is correct one
only needs to know:
- Did the candidate decider halt in its accepting state?
- Did the candidate decider halt in its reject state?
- Does the computation asked about halt?
The identity of the candidate decider need not be known.

--
Mikko

On 3/12/2024 3:57 AM, Mikko wrote:
> On 2024-03-11 16:32:36 +0000, olcott said:
>
>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>
>>>>> YOU don't get to define H^, Linz does, and when you changed your
>>>>> computation environment, you need to go to the SEMANTIC definition
>>>>> of H^, not the syntactic derived for Turing Machines.
>>>>
>>>> It might be clearer to use a different symbol, e.g., H⁺ or Ḥ, for the
>>>> machine that the Olcott machine H gets wrong.
>>>>
>>>
>>> Then Olcott would claim that I am changing the subject, and talking
>>> about a different machine since it has a different name.
>>>
>>> After all, the name is important to him.
>>
>> H1(D,D) gets the right answer.
>> A Linz based H1 would simply wait three complete execution traces
>> and get the right answer.
>>
>> I don't know of any other way that any Turing machine based
>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>> input.
>
> H1(D,D) gets the right answer about D(D) but there is another
> computation that it gets wrotng so H1 is not the correct solution.
>
> H2 might get right some computation that H1 gets wrong,
> and H3 might get right some computation that H2 gets wrogn,
> &c., but there is no decider that gets all computations right.
>

Will you halt if you never abort your simulation?
Always gets the right answer for every input.

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

On 3/12/2024 4:08 AM, Mikko wrote:
> On 2024-03-12 04:22:15 +0000, olcott said:
>
>> On 3/11/2024 11:07 PM, Richard Damon wrote:
>>> On 3/11/24 6:56 PM, olcott wrote:
>>>> On 3/11/2024 8:48 PM, Richard Damon wrote:
>>>>> On 3/11/24 4:25 PM, olcott wrote:
>>>>>> On 3/11/2024 6:19 PM, Richard Damon wrote:
>>>>>>> On 3/11/24 1:19 PM, olcott wrote:
>>>>>>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>>>>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>>>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>>>>>>
>>>>>>>>>>>>> YOU don't get to define H^, Linz does, and when you changed
>>>>>>>>>>>>> your computation environment, you need to go to the
>>>>>>>>>>>>> SEMANTIC definition of H^, not the syntactic derived for
>>>>>>>>>>>>> Turing Machines.
>>>>>>>>>>>>
>>>>>>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or
>>>>>>>>>>>> Ḥ, for the
>>>>>>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Then Olcott would claim that I am changing the subject, and
>>>>>>>>>>> talking about a different machine since it has a different name.
>>>>>>>>>>>
>>>>>>>>>>> After all, the name is important to him.
>>>>>>>>>>
>>>>>>>>>> H1(D,D) gets the right answer.
>>>>>>>>>> A Linz based H1 would simply wait three complete execution traces
>>>>>>>>>> and get the right answer.
>>>>>>>>>>
>>>>>>>>>> I don't know of any other way that any Turing machine based
>>>>>>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> input.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, you don't know how it could get the right answer, but
>>>>>>>>> claims it will.
>>>>>>>>
>>>>>>>> I did not say that.
>>>>>>>
>>>>>>> YOu effectctiely did.
>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Thus, you ADMIT that you are just making up your facts.
>>>>>>>>>
>>>>>>>>> If H1 waits "three complete execuiton traces to try to get the
>>>>>>>>> "right answer", then H1^ will also wait 3 complete execution
>>>>>>>>> cycles to decide on its "right" answer, so H1(H1^, H1^), by its
>>>>>>>>> programming will see that H1^ is still working on getting its
>>>>>>>>> right answer, and then stop and guess wrong.
>>>>>>>>
>>>>>>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>>>>>>
>>>>>>> Nooe, H^.H1 waits just as long as H1 does.
>>>>>>>
>>>>>>
>>>>>> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
>>>>>> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>>>>>>
>>>>>> Your failure to pay attention is causing me to lose
>>>>>> interest in carefully reviewing what you say.
>>>>>>
>>>>>
>>>>> It is if H1 is the Machine you are claiming to be the correct Halt
>>>>> Decide, the Linz H
>>>>>
>>>>> H^ is built on the H that you claim.
>>>>>
>>>>> If that H is not H1, you build H1^
>>>>>
>>>>> You are just showing how badly you need to lie and cheet.
>>>>
>>>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>>>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>>>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>>>>
>>>
>>>
>>> Ok, but that is irrelevent. Linz never claimed that some other
>>> decider besides H couldn't decide H^ correctly.
>>>
>>> So, that is just more Red Herring and distractions.
>>>
>>> H1 is NOT H, so doesnt' "FIX" the fact that H failed.
>>
>> I just wanted to be understood.
>
> If you want to be understood you must offer at least some motivation
> to at least try to understand you. When people understand that you
> try to cheat but fail they hardly expect anything useful or interesting.
> Also, you too often repeat what you said, which is taken to indicate
> that you have nothing interesting to offer.
>

I never ever try to cheat. Richard simply lies about that
or gets confused. When Richard says that I lie he does not
mean intentional falsehood. He means persistently mistaken.

This is my 2004 work that proposes that the halting problem has
an unsatisfiable specification thus asks an ill-formed question.
Two PhD computer science professors agree with this analysis.

E C R Hehner. *Objective and Subjective Specifications*
WST Workshop on Termination, Oxford. 2018 July 18.
See https://www.cs.toronto.edu/~hehner/OSS.pdf

Bill Stoddart. *The Halting Paradox*
20 December 2017
https://arxiv.org/abs/1906.05340
arXiv:1906.05340 [cs.LO]

Alan Turing's Halting Problem is incorrectly formed (PART-TWO) sci.logic
On 6/20/2004 11:31 AM, Peter Olcott wrote:
> PREMISES:
> (1) The Halting Problem was specified in such a way that a solution
> was defined to be impossible.
>
> (2) The set of questions that are defined to not have any possible
> correct answer(s) forms a proper subset of all possible questions.
> …
> CONCLUSION:
> Therefore the Halting Problem is an ill-formed question.
>
USENET Message-ID:
<kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>

*Direct Link to original message*
http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+

An incorrect YES/NO (thus polar) question is defined as any
YES/NO question where both YES and NO are the wrong answer.
Correctly answering incorrect questions is logically impossible.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Because for every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that can
possibly exist both YES and NO are the wrong answer to
this question: Does Ĥ ⟨Ĥ⟩ halts on its input?

This exactly meets the definition of an incorrect YES/NO
question for this decider/input pair: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

It is generally the case that the inability to do the
logically impossible places no actual limit on anything
or anyone otherwise CAD systems that cannot correctly
draw square circles would be another limit to computation.

The common fake rebuttal to this claim is to use the
strawman deception to switch to some other decider/input
pair besides Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

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

On 3/12/2024 4:23 AM, Mikko wrote:
> On 2024-03-11 16:14:29 +0000, olcott said:
>
>> On 3/11/2024 10:16 AM, Mikko wrote:
>>> On 2024-03-11 14:38:58 +0000, olcott said:
>>>
>>>> On 3/11/2024 5:12 AM, Mikko wrote:
>>>>> On 2024-03-10 14:59:13 +0000, olcott said:
>>>>>
>>>>>> On 3/10/2024 7:49 AM, Mikko wrote:
>>>>>>> On 2024-03-09 18:22:53 +0000, Richard Damon said:
>>>>>>>
>>>>>>>> On 3/9/24 9:39 AM, olcott wrote:
>>>>>>>>> On 3/9/2024 11:12 AM, Richard Damon wrote:
>>>>>>>>>> On 3/9/24 8:41 AM, olcott wrote:
>>>>>>>>>>> On 3/9/2024 9:36 AM, immibis wrote:
>>>>>>>>>>>> On 9/03/24 16:12, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 7:47 AM, immibis wrote:
>>>>>>>>>>>>>> On 8/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>> And since H^ can "lie" to that embedded H^.H about what
>>>>>>>>>>>>>>>> its description is, that H can't tell that it is part of
>>>>>>>>>>>>>>>> an H^ computation that is simulating an H^ computation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That subject must be postponed until after the Olcott
>>>>>>>>>>>>>>> refutation
>>>>>>>>>>>>>>> of the exact Linz proof is either fully accepted by three
>>>>>>>>>>>>>>> people
>>>>>>>>>>>>>>> or actual errors or gaps are found that cannot be
>>>>>>>>>>>>>>> addressed or
>>>>>>>>>>>>>>> corrected.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It's accepted that the Linz proof doen't work on Olcott
>>>>>>>>>>>>>> machines because the Linz proof is designed for Turing
>>>>>>>>>>>>>> machines. But you can't refute the Linz-immibis proof
>>>>>>>>>>>>>> designed for Olcott machines, where H is lied to about its
>>>>>>>>>>>>>> own description.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or
>>>>>>>>>>>>> fail to halt
>>>>>>>>>>>>> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for
>>>>>>>>>>>> exactly the same thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.
>>>>>>>>>>>
>>>>>>>>>>> It is easily proven that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
>>>>>>>>>>> simulation of
>>>>>>>>>>> its input and H ⟨Ĥ⟩ ⟨Ĥ⟩ need not abort the simulation of its
>>>>>>>>>>> input.
>>>>>>>>>>
>>>>>>>>>> How?
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>
>>>>>>>> Comment are SPECIFICATION, not actual behavior until existance
>>>>>>>> of a conforming H is proven
>>>>>>>
>>>>>>> To me they do not look like a specification but a false statement of
>>>>>>> the actual behaviour (for some non-conforming H).
>>>>>>>
>>>>>>
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy  // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn  // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Unlike anyone else has ever done my simulating termination
>>>>>> analyzers can always detect when their input will cause
>>>>>> themselves to never terminate. I have demonstrated this
>>>>>> for the Halting Problem's pathological input:
>>>>>>
>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>> The earliest point when Turing machine H can detect the repeating
>>>>>> state of Ĥ ⟨Ĥ⟩ is when Ĥ first reaches (c) where it would begin
>>>>>> simulating a copy of itself with a copy of its input.
>>>>>
>>>>> Nice to see that you don't disagree with my opinion about the
>>>>> apparent meahings.
>>>>>
>>>>
>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is
>>>> correct*
>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>> (a) If simulating halt decider H correctly simulates its input D
>>>> until H correctly determines that its simulated D would never stop
>>>> running unless aborted then
>>>> (b) H can abort its simulation of D and correctly report that D
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>> That goes directly against this definition
>>>> H(D,D) must report on the behavior of D(D).
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ must report on the behavior of Ĥ ⟨Ĥ⟩.
>>>>
>>>> The conventional definitions require the deciders to report
>>>> on different behavior than the behavior they actually see.
>>>
>>> If they don't actually see the behaviour they are reqquired to report on
>>> the deciders are defective, not the requirements.
>>>
>>
>> A specification is objective if the specified behavior does not
>> depend on the agent that performs it, and subjective if it does.
>
> Only if it doesn't depend on who compares the actual behaviour to
> the specification, either.
>

The behavior of H1(D,D) and H(D,D) are different thus meeting
professor Hehner's definition. This would be the same for a
Linz H ⟨Ĥ⟩ ⟨Ĥ⟩ versus an H1 ⟨Ĥ⟩ ⟨Ĥ⟩ adapted from a Linz H.

*My new post sums these things up more clearly and completely*
[Proving my 2004 claim that some decider/input pairs are incorrect
questions]

>> The Church-Turing Thesis applies to objective specifications,
>> not to subjective ones.
>
> As presented, it applies to both. Whether it really is true about
> either kind is unknown.
>
>> Because H(D,D) must abort the simulation of its input and H1(D,D)
>> need not abort the simulation of its input this proves that the
>> halting problem specification is subjective(Hehner).
>
> Whether H(D,D) must abort its simulation is not part of the
> specification of halting decider.

*Yes it is because all deciders must always halt*

> Other specifications are
> irrelevant. The specification of halting decider is objective:
> in order to determine whether the behaviout is correct one
> only needs to know:

Because the specification of a decider allows pathological inputs
this proves that this specification is subjective[Hehner].

> - Did the candidate decider halt in its accepting state?
> - Did the candidate decider halt in its reject state?
> - Does the computation asked about halt?
> The identity of the candidate decider need not be known.
>

On 3/12/2024 12:08 AM, Richard Damon wrote:
> On 3/11/24 8:26 PM, olcott wrote:
>> On 3/11/2024 9:18 PM, immibis wrote:
>>> On 12/03/24 02:56, olcott wrote:
>>>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>>>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>>>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>>>
>>> So what? Linz said that there isn't a program that gets ALL inputs
>>> correct.
>>>
>>
>> I just wanted to make sure that you understood what I was saying.
>> I initially couldn't tell that any decider could get ⟨Ĥ⟩ ⟨Ĥ⟩ correctly.
>> I didn't initially know how it cold do this.
>>
>
> Your just NOW figuring that out?
>
> Now, if this is in the new Olcott machines, where H counts on H^.H
> seeing the recursions (which it doesn't) then H1 fails just like H in
> waiting forever on a never halting infinite recursion.
>
> But, assuming that somehow you get H to incorrect abort it simulation,
> and that method doesn't cause H1 to also abort its simulation, then H1
> can get a right answer.

H is not incorrect to abort its simulation.
Because all deciders must halt H must abort its simulation.

When H does this it changes what the behavior of D would
have otherwise been.

Best selling author of Theory of Computation textbooks:
*Introduction To The Theory Of Computation 3RD, by sipser*
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/

Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

*When we apply this criteria* (elaborated above)
Will you halt if you never abort your simulation?
*Then the halting problem is conquered*

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

On 3/12/24 7:39 AM, olcott wrote:
> On 3/12/2024 4:08 AM, Mikko wrote:
>> On 2024-03-12 04:22:15 +0000, olcott said:
>>
>>> On 3/11/2024 11:07 PM, Richard Damon wrote:
>>>> On 3/11/24 6:56 PM, olcott wrote:
>>>>> On 3/11/2024 8:48 PM, Richard Damon wrote:
>>>>>> On 3/11/24 4:25 PM, olcott wrote:
>>>>>>> On 3/11/2024 6:19 PM, Richard Damon wrote:
>>>>>>>> On 3/11/24 1:19 PM, olcott wrote:
>>>>>>>>> On 3/11/2024 3:05 PM, Richard Damon wrote:
>>>>>>>>>> On 3/11/24 9:32 AM, olcott wrote:
>>>>>>>>>>> On 3/11/2024 11:21 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/11/24 3:10 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-10 18:17:58 +0000, Richard Damon said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU don't get to define H^, Linz does, and when you
>>>>>>>>>>>>>> changed your computation environment, you need to go to
>>>>>>>>>>>>>> the SEMANTIC definition of H^, not the syntactic derived
>>>>>>>>>>>>>> for Turing Machines.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It might be clearer to use a different symbol, e.g., H⁺ or
>>>>>>>>>>>>> Ḥ, for the
>>>>>>>>>>>>> machine that the Olcott machine H gets wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Then Olcott would claim that I am changing the subject, and
>>>>>>>>>>>> talking about a different machine since it has a different
>>>>>>>>>>>> name.
>>>>>>>>>>>>
>>>>>>>>>>>> After all, the name is important to him.
>>>>>>>>>>>
>>>>>>>>>>> H1(D,D) gets the right answer.
>>>>>>>>>>> A Linz based H1 would simply wait three complete execution
>>>>>>>>>>> traces
>>>>>>>>>>> and get the right answer.
>>>>>>>>>>>
>>>>>>>>>>> I don't know of any other way that any Turing machine based
>>>>>>>>>>> simulating halt decider could get the right answer to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> input.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, you don't know how it could get the right answer, but
>>>>>>>>>> claims it will.
>>>>>>>>>
>>>>>>>>> I did not say that.
>>>>>>>>
>>>>>>>> YOu effectctiely did.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Thus, you ADMIT that you are just making up your facts.
>>>>>>>>>>
>>>>>>>>>> If H1 waits "three complete execuiton traces to try to get the
>>>>>>>>>> "right answer", then H1^ will also wait 3 complete execution
>>>>>>>>>> cycles to decide on its "right" answer, so H1(H1^, H1^), by
>>>>>>>>>> its programming will see that H1^ is still working on getting
>>>>>>>>>> its right answer, and then stop and guess wrong.
>>>>>>>>>
>>>>>>>>> If H1 ⟨Ĥ⟩ ⟨Ĥ⟩ waits three execution cycles and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> reports as soon as it can then H1 correctly decides ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> when H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot.
>>>>>>>>
>>>>>>>> Nooe, H^.H1 waits just as long as H1 does.
>>>>>>>>
>>>>>>>
>>>>>>> It is not Ĥ.H1 ⟨Ĥ⟩ ⟨Ĥ⟩ and H1
>>>>>>> it is Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H1.
>>>>>>>
>>>>>>> Your failure to pay attention is causing me to lose
>>>>>>> interest in carefully reviewing what you say.
>>>>>>>
>>>>>>
>>>>>> It is if H1 is the Machine you are claiming to be the correct Halt
>>>>>> Decide, the Linz H
>>>>>>
>>>>>> H^ is built on the H that you claim.
>>>>>>
>>>>>> If that H is not H1, you build H1^
>>>>>>
>>>>>> You are just showing how badly you need to lie and cheet.
>>>>>
>>>>> I am just saying that the Linz H/Ĥ has a machine like H1 that
>>>>> decides ⟨Ĥ⟩ ⟨Ĥ⟩ correctly. This is true even if H1 has its own
>>>>> corresponding ⟨Ĥ1⟩ ⟨Ĥ1⟩ that it cannot decide.
>>>>>
>>>>
>>>>
>>>> Ok, but that is irrelevent. Linz never claimed that some other
>>>> decider besides H couldn't decide H^ correctly.
>>>>
>>>> So, that is just more Red Herring and distractions.
>>>>
>>>> H1 is NOT H, so doesnt' "FIX" the fact that H failed.
>>>
>>> I just wanted to be understood.
>>
>> If you want to be understood you must offer at least some motivation
>> to at least try to understand you. When people understand that you
>> try to cheat but fail they hardly expect anything useful or interesting.
>> Also, you too often repeat what you said, which is taken to indicate
>> that you have nothing interesting to offer.
>>
>
> I never ever try to cheat. Richard simply lies about that
> or gets confused. When Richard says that I lie he does not
> mean intentional falsehood. He means persistently mistaken.

Which IS a definition of LIE, as I have shown references for, and if you
admitting that is what you are, then you are admitting that all you have
said is just wrong and a mistake.

>
> This is my 2004 work that proposes that the halting problem has
> an unsatisfiable specification thus asks an ill-formed question.
> Two PhD computer science professors agree with this analysis.
>

Which doesn't make it WRONG, just that Halting is not computable.

Showing yo don't understand th e difference between those two terms.

> E C R Hehner. *Objective and Subjective Specifications*
> WST Workshop on Termination, Oxford.  2018 July 18.
> See https://www.cs.toronto.edu/~hehner/OSS.pdf
>
> Bill Stoddart. *The Halting Paradox*
> 20 December 2017
> https://arxiv.org/abs/1906.05340
> arXiv:1906.05340 [cs.LO]
>
> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)  sci.logic
> On 6/20/2004 11:31 AM, Peter Olcott wrote:
> > PREMISES:
> > (1) The Halting Problem was specified in such a way that a solution
> > was defined to be impossible.
> >
> > (2) The set of questions that are defined to not have any possible
> > correct answer(s) forms a proper subset of all possible questions.
> > …
> > CONCLUSION:
> > Therefore the Halting Problem is an ill-formed question.
> >
> USENET Message-ID:
> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>
> *Direct Link to original message*
> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>
> An incorrect YES/NO (thus polar) question is defined as any
> YES/NO question where both YES and NO are the wrong answer.
> Correctly answering incorrect questions is logically impossible.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Because for every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that can
> possibly exist both YES and NO are the wrong answer to
> this question: Does Ĥ ⟨Ĥ⟩ halts on its input?
>
> This exactly meets the definition of an incorrect YES/NO
> question for this decider/input pair: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> It is generally the case that the inability to do the
> logically impossible places no actual limit on anything
> or anyone otherwise CAD systems that cannot correctly
> draw square circles would be another limit to computation.
>
> The common fake rebuttal to this claim is to use the
> strawman deception to switch to some other decider/input
> pair besides Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
>