Path: ...!weretis.net!feeder6.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: =?UTF-8?B?UmU6IFZlcmlmaWVkIGZhY3QgdGhhdCDEpC5IIOKfqMSk4p+pIOKfqMSk?=
 =?UTF-8?B?4p+pIGFuZCBIIOKfqMSk4p+pIOKfqMSk4p+pIGhhdmUgZGlmZmVyZW50IGJlaGF2?=
 =?UTF-8?Q?ior?=
Date: Sat, 9 Mar 2024 13:17:58 -0800
Organization: i2pn2 (i2pn.org)
Message-ID: <usijm6$1bt2h$1@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 9 Mar 2024 21:17:59 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1438801"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
In-Reply-To: <usia2e$2f2pd$1@dont-email.me>
Bytes: 5027
Lines: 113

On 3/9/24 10:33 AM, olcott wrote:
> *Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior*
> 
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt

Specifications, not actual behavior until the existance of such an H is 
shown.

IF taken as actual behavior, then it is conditional on such an H existing.

> 
> Execution trace of Ĥ applied to ⟨Ĥ⟩
> (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
> *This proves that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation*

It NEEDS to in order to meet its specification

It DOESN'T unless its algorithm says it does,

If it just fails to answer, then it has failed to be a correct Halt Decider.

The fact that you reach this conflict in actions, is the reason Halt 
Deciding is uncomputable.

> 
> *This is a verified fact*
> When simulating halt deciders always report on the behavior of
> their simulated input from their own POV then when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
> transitions to Ĥ.Hqn it is correct from its own POV.

In other words, you are admitting to changing the question, and thus 
LYING that you are working on the actual original problem.

> 
> *This is a verified fact*
> When that occurs then H ⟨Ĥ⟩ ⟨Ĥ⟩ would transition to H.qy from
> its own POV.

Which just means you are LYING that this apply to an actual Halt Decider 
per the Halting Theory,

> 
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ report on the basis of their own
> POV then Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports incorrectly about the behavior of
> Ĥ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ reports the behavior of Ĥ ⟨Ĥ⟩ correctly.

And thus you are admitting that the H in H^.H is WRONG and thus H is not 
a correct Halt Decider, because it gets some cases wrong.

> 
> *Verified facts*
> (a) It is a verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must abort the
> simulation of its input to prevent its own infinite execution.

Nope.

It may NEED to in order to meet its specification, but it only DOES so 
if that is what the algorithm says it does.

> 
> (b) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see that it
> must abort its simulation then it would transition to Ĥ.Hqn
> to reject this input as non-halting from its own POV.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of 
knowing the answer.

> 
> (c) It is a verified fact when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot see that it
> must abort its simulation then it would transition to Ĥ.Hqy
> and loop.


Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of 
knowing the answer.

> 
> (d) (b) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qy.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of 
knowing the answer.


> (e) (c) gives H ⟨Ĥ⟩ ⟨Ĥ⟩ the basis to transition to H.qn.

Only if you show HOW it "sees" this fact.

Algorithms are step by step descriptive, not based on the assumption of 
knowing the answer.

> 
> Because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ seem to be identical machines
> on identical input that have different behavior we must
> somehow explain how they are not identical machines with
> identical inputs.
> 
> 
> 

Right, and that is your problem, which is caused by you  assuming that 
they can get the answer you want.

You need to figure out the algorithm that it will use, and it must be 
the same algorithm for both, and with the same data, they WILL both do 
the same thing.