Path: ...!3.eu.feeder.erje.net!feeder.erje.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: "Fred. Zwarts" <F.Zwarts@HetNet.nl>
Newsgroups: comp.theory
Subject: Re: DDD emulated by HHH --- (does not refer to prior posts)
Date: Wed, 28 Aug 2024 20:48:30 +0200
Organization: A noiseless patient Spider
Lines: 171
Message-ID: <vanrdv$3ipqt$2@dont-email.me>
References: <vajdta$2qe9s$1@dont-email.me> <vak3a0$2teq9$1@dont-email.me>
 <vakhnf$302rl$2@dont-email.me> <vampgq$3dl83$3@dont-email.me>
 <van46p$3f6c0$6@dont-email.me> <van671$3fgd3$4@dont-email.me>
 <van6um$3foem$4@dont-email.me> <vandsl$3grf3$3@dont-email.me>
 <vaneq4$3h3es$1@dont-email.me> <vani7u$3hh2l$1@dont-email.me>
 <vaniq2$3hnvu$1@dont-email.me> <vanjd0$3hh2l$3@dont-email.me>
 <vank65$3htts$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 28 Aug 2024 20:48:32 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="75b5fa56e09d4c6f30bc1773af702cac";
	logging-data="3762013"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+o82sub2WOFyTxpqod9QlP"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:2HYkt5Xh1YuXW8t/HVH+7b9vO74=
In-Reply-To: <vank65$3htts$1@dont-email.me>
Content-Language: en-GB
Bytes: 8668

Op 28.aug.2024 om 18:44 schreef olcott:
> On 8/28/2024 11:31 AM, Fred. Zwarts wrote:
>> Op 28.aug.2024 om 18:21 schreef olcott:
>>> On 8/28/2024 11:11 AM, Fred. Zwarts wrote:
>>>> Op 28.aug.2024 om 17:13 schreef olcott:
>>>>> On 8/28/2024 9:57 AM, Fred. Zwarts wrote:
>>>>>> Op 28.aug.2024 om 14:59 schreef olcott:
>>>>>>> On 8/28/2024 7:46 AM, Fred. Zwarts wrote:
>>>>>>>> Op 28.aug.2024 om 14:12 schreef olcott:
>>>>>>>>> On 8/28/2024 4:09 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 27.aug.2024 om 14:44 schreef olcott:
>>>>>>>>>>> On 8/27/2024 3:38 AM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 27.aug.2024 om 04:33 schreef olcott:
>>>>>>>>>>>>> This is intended to be a stand-alone post that does not
>>>>>>>>>>>>> reference anything else mentioned in any other posts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    HHH(DDD);
>>>>>>>>>>>>>    return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> _DDD()
>>>>>>>>>>>>> [00002172] 55         push ebp      ; housekeeping
>>>>>>>>>>>>> [00002173] 8bec       mov ebp,esp   ; housekeeping
>>>>>>>>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>>>>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
>>>>>>>>>>>>> [0000217f] 83c404     add esp,+04
>>>>>>>>>>>>> [00002182] 5d         pop ebp
>>>>>>>>>>>>> [00002183] c3         ret
>>>>>>>>>>>>> Size in bytes:(0018) [00002183]
>>>>>>>>>>>>>
>>>>>>>>>>>>> When we assume that:
>>>>>>>>>>>>> (a) HHH is an x86 emulator that is in the same memory space 
>>>>>>>>>>>>> as DDD.
>>>>>>>>>>>>> (b) HHH emulates DDD according to the semantics of the x86 
>>>>>>>>>>>>> language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> then we can see that DDD emulated by HHH cannot possibly 
>>>>>>>>>>>>> get past
>>>>>>>>>>>>> its own machine address 0000217a.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, we see. In fact DDD is not needed at all.
>>>>>>>>>>>
>>>>>>>>>>> A straw man fallacy (sometimes written as strawman) is the 
>>>>>>>>>>> informal fallacy of refuting an argument different from the 
>>>>>>>>>>> one actually under discussion...
>>>>>>>>>>> https://en.wikipedia.org/wiki/Straw_man
>>>>>>>>>>
>>>>>>>>>> Apparently you do not even understand the English that is used 
>>>>>>>>>> to describe the straw man fallacy.
>>>>>>>>>> Or are trying to distract the attention from the fact that DDD 
>>>>>>>>>> is not needed is a simple truism, a tautology in your terms?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When 100% of the whole point is for HHH to correctly determine
>>>>>>>>> whether or not DDD would stop running if not aborted
>>>>>>>>> *IT IS RIDICULOUSLY STUPID TO SAY THAT DDD IS NOT NEEDED*
>>>>>>>>>
>>>>>>>>> Acting ridiculously stupid when on is not stupid at all
>>>>>>>>> cannot be reasonably construed as anything besides a sadistic
>>>>>>>>> head game.
>>>>>>>>>
>>>>>>>> When without DDD it is clear as crystal that HHH cannot possibly 
>>>>>>>> simulate itself correctly:
>>>>>>>
>>>>>>>
>>>>>>> Damned Liar !!!
>>>>>>
>>>>>> I will ignore this, because I know how difficult it is for you to 
>>>>>> accept the truth.
>>>>>>
>>>>>>> I have told you too many times that correct simulation
>>>>>>> is simply obeying the semantics of the 86 language for
>>>>>>> whatever the x86 input finite string specifies.
>>>>>>
>>>>>> You may repeat it many more times, but HHH violated the semantics 
>>>>>> of the x86 language by skipping the last few instructions of a 
>>>>>> halting program. This finite string, when given for direct 
>>>>>> execution, shows a halting behaviour. This is the proof what the 
>>>>>> semantics of the x86 language means for this finite string: a 
>>>>>> halting program.
>>>>>>
>>>>>>>
>>>>>>> If the x86 string tells the computer to catch on fire and
>>>>>>> the computer catches on fire then this proves that the
>>>>>>> emulation was correct.
>>>>>>
>>>>>> And when the x86 string tells the computer that there is a halting 
>>>>>> program and the simulator decides that there is a non-halting 
>>>>>> program, this proves that the simulation is incorrect.
>>>>>> Clear as crystal: the semantics of the x86 string is proved by its 
>>>>>> direct execution.
>>>>>> This is shown in the example below, where the direct execution of 
>>>>>> HHH halts, but HHH decides that it does not halt.
>>>>>>
>>>>>
>>>>> By this same reasoning that fact that you are no longer hungry
>>>>> AFTER you have eaten proves that you never needed to eat.
>>>>
>>>> No, again, you do not understand what It said.
>>>>
>>>>>
>>>>> The behavior of DDD before HHH aborts its simulation
>>>>> (before it has eaten) it not the same behavior after
>>>>> DDD has been aborted (after it has eaten).
>>>>>
>>>>
>>>> If hungry stands for fear for infinite recursion 
>>>
>>> hungry stands for will not stop running unless aborted
>>> just like
>>> will remain hungry until eating is always true whenever hungry
>>
>> Your HHH will see a 'special condition' after a few recursions, abort 
>> and halt. 
> 
> Why to do dishonestly try to get away with the strawman
> deception and change the subject to HHH?

I don't. I point to exactly where the problem of the subject lies:
HHH cannot possibly simulate itself up to the end. DDD does not play a 
role therein.

> 
> It is a design requirement that HHH halts if it doesn't
> halt it is wrong.

But halting does not make it correct. There is no way to make it 
correct. HHH cannot possibly simulate itself correctly up to the end, no 
matter what trick you may think of.

> 
> _DDD()
> [00002172] 55         push ebp      ; housekeeping
> [00002173] 8bec       mov ebp,esp   ; housekeeping
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
> [0000217f] 83c404     add esp,+04
> [00002182] 5d         pop ebp
> [00002183] c3         ret
> Size in bytes:(0018) [00002183]
> 
> When DDD emulated by HHH according to the semantics of the
> x86 language cannot possibly reach its own machine address
> of 00002183, then HHH is correct to reject DDD as non-halting
> even of HHH does this entirely by wild guess.
> 

The semantics of the x86 language are that DDD specifies a halting 
program. This is proved when the same finite string is given for direct 
execution. It is also proved when this finite string is given to HHH1 to 
simulate. They both show that the semantics of the x86 language prove 
that HHH is a halting program.
But, of course HHH cannot possible reach the end of its own simulation, 
which proves that the simulation is incomplete. It aborts prematurely, 
violating the semantics of the x86 language by skipping the last few 
instructions of a halting program.
There is no way to solve this. Removing the abort code will make it even 
worse. It is simply impossible to make a HHH that simulates itself 
correctly.

        int main() {
          return HHH(main);
        }

This is the simplest demonstration of the problem: HHH halts, but 
decides that it does not halt. No DDD needed to demonstrate the problem.
This is the heart of the problem.