On 12/03/24 04:26, 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.
>

For example, since Ĥ ⟨Ĥ⟩ halts, this decider gets it correct:

bool DoesItHalt(finite_string program, finite_string input)
{ return true;
}

On 3/12/2024 11:10 AM, Richard Damon wrote:
> 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,

It is a lie that *persistently mistaken* is a lie.
It is a lie that *persistently mistaken* is a lie.
It is a lie that *persistently mistaken* is a lie.

*This discussion has moved to my new post*
[Proving my 2004 claim that some decider/input pairs are incorrect
questions]

--
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 8:58 AM, olcott wrote:
> 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.

Right, but it still must return the right answer to be correct.

it stopped before it KNEW the right answer, so it guesses, and guesses
wrong.

Just like you do.

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

Nope, because D use the behavior that H actually ends up being, not its
theroretical behavior. That is why D doesn't exist as an program until H
does

>
> 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*
>

No, POOP is conquered, because you are working on your POOPified
STRAWMAN, not the actual Halting Question.

The fact that you even think you can "redefine" what Halting means, just
shows that you are absolutely ignorant of anything that relates to
logic, and nothing more than a Pathological Liar that doesn't care what
truth actually means.

On 3/12/2024 11:23 AM, Richard Damon wrote:
> On 3/12/24 8:58 AM, olcott wrote:
>> 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.
>
> Right, but it still must return the right answer to be correct.
>
> it stopped before it KNEW the right answer, so it guesses, and guesses
> wrong.
>
> Just like you do.
>
>>
>> When H does this it changes what the behavior of D would
>> have otherwise been.
>
> Nope, because D use the behavior that H actually ends up being, not its
> theroretical behavior. That is why D doesn't exist as an program until H
> does
>
>>
>> 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*
>>
>
> No, POOP is conquered, because you are working on your POOPified
> STRAWMAN, not the actual Halting Question.
>
> The fact that you even think you can "redefine" what Halting means, just
> shows that you are absolutely ignorant of anything that relates to
> logic, and nothing more than a Pathological Liar that doesn't care what
> truth actually means.
>

In other words you are saying that Professor Sipser is incorrect.

--
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 9:30 AM, olcott wrote:
> On 3/12/2024 11:23 AM, Richard Damon wrote:
>> On 3/12/24 8:58 AM, olcott wrote:
>>> 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.
>>
>> Right, but it still must return the right answer to be correct.
>>
>> it stopped before it KNEW the right answer, so it guesses, and guesses
>> wrong.
>>
>> Just like you do.
>>
>>>
>>> When H does this it changes what the behavior of D would
>>> have otherwise been.
>>
>> Nope, because D use the behavior that H actually ends up being, not
>> its theroretical behavior. That is why D doesn't exist as an program
>> until H does
>>
>>>
>>> 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*
>>>
>>
>> No, POOP is conquered, because you are working on your POOPified
>> STRAWMAN, not the actual Halting Question.
>>
>> The fact that you even think you can "redefine" what Halting means,
>> just shows that you are absolutely ignorant of anything that relates
>> to logic, and nothing more than a Pathological Liar that doesn't care
>> what truth actually means.
>>
>
> In other words you are saying that Professor Sipser is incorrect.
>

No, you don't understand what he said, because you are using the wrong
definitions of the words.

"Correct Simulation" to Professer Sipser is the results of an unaborted
complete simulation.

If H aborts its simulation then "H's correct simulation" is a
non-existant thing, and thus H has no grounds to work on.

He would have expected you to know that, and maybe convert that to just
"THE Correct Simulation", which isn't what you are doing.

Either way, H never meets the condition specified, eiher becuase its
simulation wasn't correct, or that the actual correct simulation will
halt, so in your case, it is never given reason to abort, but does anyway.

On 3/12/24 9:18 AM, olcott wrote:
> On 3/12/2024 11:10 AM, Richard Damon wrote:
>> 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,
>
> It is a lie that *persistently mistaken* is a lie.
> It is a lie that *persistently mistaken* is a lie.
> It is a lie that *persistently mistaken* is a lie.

Nope, been proved otherwise, with a authorative definition quoted, so
your statement above has proved to have been a lie.

You don't get to define which definition of a word is to be used by another.

>
> *This discussion has moved to my new post*
> [Proving my 2004 claim that some decider/input pairs are incorrect
> questions]
>

On 2024-03-12 15:01:23 +0000, olcott said:

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

On 2024-03-12 14:39:37 +0000, olcott said:

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

Anyway that is what people understand your words to mean.
If you want to give a differnet impression you must say
something else or alt least in a different way.

> Richard simply lies about that or gets confused. When
> Richard says that I lie he does not mean intentional
> falsehood. He means persistently mistaken.

And lack of correction of errors that were originally
unintended.

--
Mikko

On 2024-03-12 14:05:23 +0000, olcott said:

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

Irrelevant distraction.

--
Mikko

On 13/03/24 17:42, Mikko wrote:
> On 2024-03-12 14:05:23 +0000, olcott said:
>> Will you halt if you never abort your simulation?
>> Always gets the right answer for every input.
>
> Irrelevant distraction.

+1