Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Overview of proof that the input to HHH(DDD) specifies
 non-halting behavior
Date: Mon, 12 Aug 2024 22:05:49 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <c971d30c8f0058a63e46a3715524def167033ebf@i2pn2.org>
References: <v9edol$3metk$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Tue, 13 Aug 2024 02:05:49 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2312776"; 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: <v9edol$3metk$1@dont-email.me>
Bytes: 3800
Lines: 64

On 8/12/24 9:43 PM, olcott wrote:
> We prove that the simulation is correct.

Which means it runs unitl it reaches a final state, and exactly details 
the behavior of the machine the input represents.

> Then we prove that this simulation cannot possibly
> reach its final halt state / ever stop running without being aborted.

Which means that a NON-ABORTED simulation of this input will never reach 
the final state.

And that input is exactly the input that you will use belew.


> The semantics of the x86 language conclusive proves this is true.

Only if you FOLLOW the x86 language semantics, which again says you 
can't stop the simulation that defines the behavior until it reaches a 
final state.

> 
> Thus when we measure the behavior specified by this finite
> string by DDD correctly simulated/emulated by HHH it specifies
> non-halting behavior.

And, if that string doesn't contrain the code for the decider it was 
built on, it isn't the right string, as it isn't a program.

> 
> https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
> 

Except that the only way for HHH to DO a correct emulation is to never 
abort, and thus is can't return if its input is non-halting.

If it does abort, then the fact that its simulation didn't reach a final 
state doesn't say anything, we need to give that exact same input (which 
will be INCLUDE the copy of the decider that it was built on that 
doesn't change for this verification step) to a real complete simulator.

That simulator will see the start of the input program call the copy of 
the decider that the input usses, and since it aborts and returns, it 
will see the copy do that same thing which will thus return to the based 
decider which will halt.

Your problems are you think the input doesn't contain the copy of the 
decider, and thus all the inputs to every decider in your infinite set 
of input/decider pairs are the same, but then the input isn't a program, 
and you argument makes a category error.

Then, you try to let a partial simulation that doesn't reach the final 
state to be considered a "correct simulation" such that its not reaching 
the final state indicates non-halting, which is just an error.

Sorry, these errors have been expalined many times, and the fact you 
keep repeating them either means you are totally stupid, and can't even 
see that you are stupid (the worse kind of stupid) or are such a liar 
that you don't care that your lies are so blatant, which is worse.


Note, you also need to fix your decider so it IS a computation, and thus 
not vary its behavior based on things other than it explicit input, 
which basically removes the option of using static memory like your 
currect bunch uses.