Path: ...!news.misty.com!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: HHH maps its input to the behavior specified by it --- never
 reaches its halt state ---
Date: Thu, 8 Aug 2024 23:34:25 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <ca6cbe14b2f6d8e912084e2db0d86078e5c113d4@i2pn2.org>
References: <v8jh7m$30k55$1@dont-email.me> <v8kp6s$3c5h2$2@dont-email.me>
 <v8ld1f$3f6vr$5@dont-email.me> <v8ldl0$3ennf$1@dont-email.me>
 <v8lfb9$3g2jl$1@dont-email.me> <v8lgsr$3gadt$2@dont-email.me>
 <v8lhrr$3gkbk$1@dont-email.me> <v8n6un$3tv08$1@dont-email.me>
 <v8nums$1n09$6@dont-email.me> <v8vah7$29sva$1@dont-email.me>
 <v8vr7e$32fso$2@dont-email.me> <v91vc4$3qp1r$2@dont-email.me>
 <v92ge1$p1$2@dont-email.me>
 <f37108f5c9868fc309f42ef78982e2c865ad544c@i2pn2.org>
 <v940uh$hqmp$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 9 Aug 2024 03:34:25 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1932053"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v940uh$hqmp$1@dont-email.me>
Bytes: 4906
Lines: 95

On 8/8/24 11:03 PM, olcott wrote:
> On 8/8/2024 9:52 PM, Richard Damon wrote:
>> On 8/8/24 9:15 AM, olcott wrote:
>>>
>>> void DDD()
>>> {
>>>    HHH(DDD);
>>>    return;
>>> }
>>>
>>> Each HHH of every HHH that can possibly exist definitely
>>> *emulates zero to infinity instructions correctly* In
>>> none of these cases does the emulated DDD ever reach
>>> its "return" instruction halt state.
>>>
>>> *There are no double-talk weasel words around this*
>>> *There are no double-talk weasel words around this*
>>> *There are no double-talk weasel words around this*
>>>
>>> There is no need to show any execution trace at the x86 level
>>> every expert in the C language sees that the emulated DDD
>>> cannot possibly reaches its "return" instruction halt state.
>>>
>>> Every rebuttal that anyone can possibly make is necessarily
>>> erroneous because the first paragraph is a tautology.
>>>
>>>
>>
>> Nope, it is a lie based on comfusing the behavior of DDD which is what 
>> "Halting" is.
>>
> 
> Finally something besides
> the strawman deception,
> disagreeing with a tautology, or
> pure ad hominem.
> 
> You must first agree with everything that I said above
> before we can get to this last and final point that it
> not actually directly referenced above.
> 

Why do I need to agree to a LIE?


> *Two key facts*
> (a) The "return" instruction is the halt state of DDD.
> (b) DDD correctly emulated by any HHH never reaches this state.
> 

WRONG, as proven.

The SIMULATION BY HHH doesn't reach there, but DDD does, as DDD is the 
direct execution of DDD, and "halting" always refers to the direct 
exectuion or something that behaves identically to execution, like a 
COMPLETE correct emulaiton.

> Until you agree to these two points I will continue to
> point out that you are trying to disagree with a tautology.
> 

Agaim, why do I need to agree to a LIE?

You are just proving that you are trying to be deceptive and misusing 
definitions.

When talking about halting:

"DDD correctly simulated by HHH" must either mean that HHH does a 
COMPLETE and correct simulation, which means it NEVER aborts its 
simulation, or, as the actual English implies, that it is refering to 
the behavior of DDD (which is its direct execution), with the DDD being 
qualified as one that is corrcorrectly simualte by HHHY.

And agian, "Correctly Emulated" normally means the complete and correct 
emulation, and thus one that never aborts.

Now, if you do mean correctly but PARTIALLY emulated by HHH, then we can 
show that such an HHH creates a DDD that will call it, it will simulate 
for a while, and then return to that DDD, and DDD will halt.

Thus, your "tautology" either means that HHH actually does a complete 
and correct emulaiton, and thus you HHH can never abort its emulation to 
give an answer, and thus it fails to be a decider, or you are using the 
streached definition, and we see that (b) is not met, so it isn't a 
tautology.

Thus, your claim it is a tautology is a stipulation that you HHH can 
NEVER EVER abort its emulation of DDD, and thus you HHH is just not a 
decider, and you have lied that it correctly answered when it, in fact, 
could never have answered, or you lied that you had a tautology.

You are just caught with you hand in the cookie jar having played a 
shell game with word meanings.

Sorry, your proof fails.