Path: ...!2.eu.feeder.erje.net!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,sci.logic
Subject: Re: 195 page execution trace of DDD correctly simulated by HH0
Date: Fri, 21 Jun 2024 09:44:27 +0200
Organization: A noiseless patient Spider
Lines: 119
Message-ID: <v53b0s$324b4$1@dont-email.me>
References: <v4vrfg$2793f$1@dont-email.me> <v50o2t$2fh98$2@dont-email.me>
 <v51dc8$2jmrd$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 21 Jun 2024 09:44:28 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="969895a6282d5611d0bdc4584ae51a10";
	logging-data="3215716"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+GAyAV8TcEfPExE1koRZfx"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:tO0mTtkdvgE7YtypacHCrSuH/jQ=
Content-Language: en-GB
In-Reply-To: <v51dc8$2jmrd$1@dont-email.me>
Bytes: 6330

Op 20.jun.2024 om 16:12 schreef olcott:
> On 6/20/2024 3:09 AM, Fred. Zwarts wrote:
>> Op 20.jun.2024 om 02:00 schreef olcott:
>>> This shows all of the steps of HH0 simulating DDD
>>> calling a simulated HH0 simulating DDD
>>>
>>> https://liarparadox.org/HH0_(DDD)_Full_Trace.pdf
>>> *Some of the key instructions are color coded*
>>> GREEN---DebugStep Address
>>> RED-----HH Address
>>> YELLOW--All of the DDD instructions
>>> CYAN----Return from DebugStep to Decide_Halting_HH
>>>
>>> _DDD()
>>> [000020a2] 55         push ebp      ; housekeeping
>>> [000020a3] 8bec       mov ebp,esp   ; housekeeping
>>> [000020a5] 68a2200000 push 000020a2 ; push DDD
>>> [000020aa] e8f3f9ffff call 00001aa2 ; call H0
>>> [000020af] 83c404     add esp,+04   ; housekeeping
>>> [000020b2] 5d         pop ebp       ; housekeeping
>>> [000020b3] c3         ret           ; never gets here
>>> Size in bytes:(0018) [000020b3]
>>>
>>> Exactly which step of DDD emulated by H0 was emulated
>>> incorrectly such that this emulation would be complete?
>>> AKA DDD emulated by H0 reaches machine address [000020b3]
>>>
>>>
>>>
>>
>> If the simulation of a program with a loop of 5 iterations is aborted 
>> after 3 iterations, all instructions are correctly simulated. 
>> Nevertheless, it is an incorrect simulation, because it should 
>> simulate up to the final state of the program.
>>
> 
> It would be helpful if you answer the actual question being asked
> right here and thus not answer some other question that was asked
> somewhere else.

If you do not understand that I answered the question why the simulation 
is incorrect, it is hopeless. The question which instruction is 
incorrect is not the right question.

> 
>> Similarly, if a simulator which aborts after 2 cycles of recursive 
>> simulation of it self, it simulates only 1 of the 2 cycles of itself. 
>> So, it is incorrect, not because one instruction was simulated 
>> incorrectly, but because it did not simulate up to the final state of 
>> the simulated self.
>>
> 
> void Infinite_Loop()
> {
>    HERE: goto HERE;
> }
> 
> It also looks like you fail to comprehend that it is possible
> for a simulating termination analyzer to recognize inputs that
> would never terminate by recognizing the repeating state of
> these inputs after a finite number of steps of correct simulation.

So, you ignore the example I gave and reply with a change of subject.
I was not talking about an infinite loop, about a loop of 5 recursions.
I use this example, because your simulating itself, only does not have 
infinite recursion, but only a finite number of recursive simulations 
before it aborts. So, you infinite loop is a change of subject.

> 
>> In other words, H0 is required to halt. If it does halt indeed, than a 
>> correct simulation can show the 'ret' instruction. 
> 
> If you look at the 195 page execution trace you will see that
> the directly executed H0 does reach its ret instruction and
> DDD correctly emulated by H0 cannot possibly reach its ret
> instruction in any finite number of steps.

If you would study the trace you produced you would notice that the 
simulated H0 does not reach its 'ret', which shows again that H0 is not 
able to simulate itself up to the end, even though we know that H0 halts.
That the directly simulated H0 halts only proves that the simulation is 
incorrect, because the simulation does not reproduce it.
Indeed, H0 cannot possibly reach its ret instruction in any finite 
number of steps. This proves that the simulation is incorrect. It always 
aborts one cycle to early, because the simulated H0 runs one cycle 
behind the simulating H0.
Why is that so difficult for you?

> 
>> We know that your simulation cannot do that. Your own words explain 
>> why it can't: the simulated self runs one cycle behind the simulator. 
>> That explains why the simulation is incorrect and aborts too soon.
>>
> 
> Every expert in the C language that has reviewed this in the C forums
> and by personal email has confirmed that H0 must abort its simulation
> of DDD to prevent its own non-termination. This seems to confirm your
> lack of sufficient technical competence.

It seems you cannot even read. I never denied it. I even said that both 
not-aborting and aborting are wrong. So, you are talking nonsense and 
even reading seems to be over your head.
Every C expert also told you that when H0 aborts, the simulation is 
incorrect, because it is incomplete.
Why are you unable to learn from experts?

> 
>> So, when you ask which step was emulated incorrectly, you only show 
>> that you don't understand what emulation is.
>> Stop talking about it. It is over your head.
>>
>> I am afraid that these simple facts are over your head. I wonder what 
>> your reaction will be:
>> Shouting, complaining about change of subject, claiming that I do not 
>> understand it, or again a baseless repetition of the claim?
>> Whatever, it is not probable that it will show any insight in this 
>> matter with a reasonable response.
>