Deutsch   English   Français   Italiano  
<v59p71$smd5$4@i2pn2.org>

View for Bookmarking (what is this?)
Look up another Usenet article

Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: Re: DDD correctly emulated by H0
Date: Sun, 23 Jun 2024 14:23:29 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v59p71$smd5$4@i2pn2.org>
References: <v4vrfg$2793f$1@dont-email.me> <v50o2t$2fh98$2@dont-email.me>
 <v51dc8$2jmrd$1@dont-email.me> <v53b0s$324b4$1@dont-email.me>
 <v53tjm$35vak$1@dont-email.me> <v565d9$3mg7e$1@dont-email.me>
 <v56iht$3or0r$4@dont-email.me> <v576d7$3sg5p$2@dont-email.me>
 <v576k6$3soh6$3@dont-email.me> <v578a9$onl3$16@i2pn2.org>
 <v579lm$3t97b$2@dont-email.me> <v57b2q$onl3$19@i2pn2.org>
 <v57ok9$5d7$3@dont-email.me> <v57pcq$onl3$21@i2pn2.org>
 <v584ou$5ski$1@dont-email.me> <v590sp$rmf0$3@i2pn2.org>
 <v598g0$brmn$7@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 23 Jun 2024 18:23:30 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="940453"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <v598g0$brmn$7@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 7203
Lines: 146

On 6/23/24 9:38 AM, olcott wrote:
> On 6/23/2024 6:28 AM, Richard Damon wrote:
>> On 6/22/24 11:28 PM, olcott wrote:
>>> On 6/22/2024 7:14 PM, Richard Damon wrote:
>>>> On 6/22/24 8:01 PM, olcott wrote:
>>>>>
>>>>> When we stipulate that the only measure of a correct emulation
>>>>> is the semantics of the x86 programming language then we see
>>>>> that when DDD is correctly emulated by H0 that its call to
>>>>> H0(DDD) cannot possibly return.
>>>>
>>>> Right, so what do you do when you run out of instructions to simulate?
>>>>
>>>> Your logic just BLOWS UP.
>>>>
>>>
>>> That you are too stupid to see an infinite recursion behavior
>>> pattern does not mean that I am not correct.
>>
>> Except it is proven to not be the infinite recursion behavior if H0 is 
>> a decider.
>>
>> Just a finite recursion pattern.
>>
>> So, which LIE are you holding to:
>>
>> That this is an infinite recursion pattern, when every level of H0 
>> will break the pattern as it is a decider and not let itself go on 
>> forever
>>
>> That H0 is a decider, because it isn't "smart" enough to see it is 
>> caught in an infinte loop an get out of it, so it just fails to answer 
>> at ANY level
>>
>> That H0 is a "Pure Function" and thus *ALL* calls to it with the same 
>> parameters will act the same.
>>
>>
>> So, which *LIE* is it?
>>
>>
>> (Confirmed liar Peter Olcott)
>>
>>>
>>>>>
>>>>> _DDD()
>>>>> [00002172] 55               push ebp      ; housekeeping
>>>>> [00002173] 8bec             mov ebp,esp   ; housekeeping
>>>>> [00002175] 6872210000       push 00002172 ; push DDD
>>>>> [0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
>>>>> [0000217f] 83c404           add esp,+04
>>>>> [00002182] 5d               pop ebp
>>>>> [00002183] c3               ret
>>>>> Size in bytes:(0018) [00002183]
>>>>>
>>>>>
>>>>
>>>> This exposes the LIE of your system. YOu CAN'T correctly x86 emulate 
>>>> a partial program, becuase it isn't prpgram with behavior to emulate.
>>>>
>>>> PERIOD.
>>>>
>>>> That means, the call to H0(DDD), to have any actual meaning, must 
>>>> incluede *ALL* the instrutions in memory that are going to be used 
>>>> as part of the input, and thus, DDD is TIED to the H0 that we 
>>>> started with, so your "trick" of changing it is shows to just be a LIE.
>>>>
>>>>
>>>> You just don't understand that behavior is determined of an SPECIFIC 
>>>> program, a specific instance of the template AFTER pairing it with 
>>>> the decider it is to foil, and when you ask about other deciders 
>>>> looking at THIS input, the input can't change.
>>>>
>>>> There goes your two decades down the drain.
>>>
>>
> 
> _DDD()
> [00002172] 55               push ebp
> [00002173] 8bec             mov ebp,esp
> [00002175] 6872210000       push 00002172 ; push DDD
> [0000217a] e853f4ffff       call 000015d2 ; call HHH0
> [0000217f] 83c404           add esp,+04
> [00002182] 5d               pop ebp
> [00002183] c3               ret
> Size in bytes:(0018) [00002183]
> 
> According to the semantics of the x86 programming language
> when DDD correctly emulated by H0 calls H0(DDD) this call
> cannot possibly return.
> 
> Likewise according to the semantics of arithmetic for
> decimal integers: 2 + 3 = 5.
> 
> Anyone disagreeing with these two statements is WRONG.
> 


Now, if you REALLY mean just can HHH0 simulate this input to a final 
state, the answer is WHO CARES.

But I will put out a few comments on errors in your presentation\.

First, if you ONLY have the bytes presented, then the answer becomes 
trivial, as H0 HAS to stop emulating when it gets to the call 
instruction, as there is no data at address 000015d2 defined to simulate.

This means you need to fix your problem statement to include the 
instructions of HHH0, and everything that it calls as part of the 
"input", or your question isn't the one you mean to be asking.

Of course, this means that each HHH0 that you try, is processing a 
DIFFERENT input, so you can't argue from one about the behavior of a 
different one.

Second, you forgot to specify what HHH0 has as requirements. Once you 
include its code, so can simulate it, the "non-pure" function tricks 
allow it to correctly simulate to the return instruction.

Reminder, you complain when we point out assumptions made on previous 
statements that you didn't want to carry forward, so you can't also 
complain about us forgetting about requirements that you didn't bring 
forward.

If you want to pull in the past, we can just point out that we KNOW you 
are talking about a Halt Decider, and that your question is the wrong 
question for a Halt decider.

So, your statement is wrong for two logical reasons as described above, 
so your statement that anyone who disagrees is wrong is just wrong.

You don't know how to properly state a problem.

The last point to make, is that this is NOT a "proof" but just an 
argument claiming something should be obviously true.

That may be a "proof" in the wild west of Philosophy, but it isn't in 
the realm of Formal Logic, which is what the field you are talking about is.

So, you are making a statement, that when fixed to correct the deficits 
in it, becomes a statement that might be plausably true, but not proven.

A proof can likely be made, but it seems that is beyond your ability 
since you didn't even try, Of course, without the second fix, the 
statement is just false, and without the first fix, the statment is 
meaningless, as of course you can't simulate to a return from a call 
that you are unable to simulate past.