Path: ...!2.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 correctly emulated by HHH is Correctly rejected as
 non-halting V2 ---woefully mistaken rebuttal
Date: Fri, 26 Jul 2024 10:00:45 +0200
Organization: A noiseless patient Spider
Lines: 310
Message-ID: <v7vl3e$2o42f$1@dont-email.me>
References: <v6rg65$32o1o$3@dont-email.me> <v725d7$hlvg$1@dont-email.me>
 <aa7643b6d8c46d2c4dd5ef92ae3650afe114adbb@i2pn2.org>
 <v734ct$mjis$2@dont-email.me>
 <056325e336f81a50f4fb9e60f90934eaac823d22@i2pn2.org>
 <v73gk2$obtd$1@dont-email.me>
 <e2958e7ea04d53590c79b53bfb4bc9dff468772b@i2pn2.org>
 <v742r2$s48s$2@dont-email.me>
 <210383b2ee318f68a96d94aec314ee8b93f79b7f@i2pn2.org>
 <v75u22$19j7l$4@dont-email.me>
 <fde630817c49562bc765bdbc98e16a1582bcad53@i2pn2.org>
 <v78mda$1smtm$2@dont-email.me> <v7d5cl$2t3ja$1@dont-email.me>
 <v7ds0o$30pvh$3@dont-email.me> <v7fs29$3f4g7$1@dont-email.me>
 <v7gd17$3hlc2$2@dont-email.me> <v7ikn4$1jv5$1@dont-email.me>
 <v7j2pg$3o7r$3@dont-email.me> <v7l3di$idv1$1@dont-email.me>
 <v7lnrf$luh0$1@dont-email.me> <v7niqp$13ghd$1@dont-email.me>
 <v7obbn$17h8r$1@dont-email.me>
 <2eecnR6fa9XiWzz7nZ2dnZfqn_ednZ2d@brightview.co.uk>
 <v7tlin$2acgd$1@dont-email.me> <v7tncm$2a7st$1@dont-email.me>
 <wr6dnXToB7yE5T_7nZ2dnZfqnPSdnZ2d@brightview.co.uk>
 <v7u6fe$2ddim$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 26 Jul 2024 10:00:46 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="61dd50ac79df5a1cde36cf94e230b0d4";
	logging-data="2887759"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/H/SVv2v5bv9IfHzX0xjoV"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:ozqNGxYYrA6WYgkwwYPvnYG5KgM=
In-Reply-To: <v7u6fe$2ddim$1@dont-email.me>
Content-Language: en-GB
Bytes: 15318

Op 25.jul.2024 om 20:45 schreef olcott:
> On 7/25/2024 11:06 AM, Mike Terry wrote:
>> On 25/07/2024 15:27, Fred. Zwarts wrote:
>>> Op 25.jul.2024 om 15:56 schreef olcott:
>>>> On 7/24/2024 10:29 PM, Mike Terry wrote:
>>>>> On 23/07/2024 14:31, olcott wrote:
>>>>>> On 7/23/2024 1:32 AM, 0 wrote:
>>>>>>> On 2024-07-22 13:46:21 +0000, olcott said:
>>>>>>>
>>>>>>>> On 7/22/2024 2:57 AM, Mikko wrote:
>>>>>>>>> On 2024-07-21 13:34:40 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 7/21/2024 4:34 AM, Mikko wrote:
>>>>>>>>>>> On 2024-07-20 13:11:03 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 7/20/2024 3:21 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-07-19 14:08:24 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> When we use your incorrect reasoning we would conclude
>>>>>>>>>>>>>> that Infinite_Loop() is not an infinite loop because it
>>>>>>>>>>>>>> only repeats until aborted and is aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You and your HHH can reason or at least conclude correctly 
>>>>>>>>>>>>> about
>>>>>>>>>>>>> Infinite_Loop but not about DDD. Possibly because it 
>>>>>>>>>>>>> prefers to
>>>>>>>>>>>>> say "no", which is correct about Infinte_loop but not about 
>>>>>>>>>>>>> DDD.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Because this is true I don't understand how you are not 
>>>>>>>>>>>> simply lying*
>>>>>>>>>>>> int main
>>>>>>>>>>>> {
>>>>>>>>>>>>    DDD();
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Calls HHH(DDD) that must abort the emulation of its input
>>>>>>>>>>>> or {HHH, emulated DDD and executed DDD} never stop running.
>>>>>>>>>>>
>>>>>>>>>>> You are the lying one.
>>>>>>>>>>>
>>>>>>>>>>> If HHH(DDD) abrots its simulation and returns true it is 
>>>>>>>>>>> correct as a
>>>>>>>>>>> halt decider for DDD really halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (b) We know that a decider is not allowed to report on the 
>>>>>>>>>> behavior
>>>>>>>>>> computation that itself is contained within.
>>>>>>>>>
>>>>>>>>> No, we don't. There is no such prohibition.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Turing machines never take actual Turing machines as inputs.
>>>>>>>> They only take finite strings as inputs and an actual executing
>>>>>>>> Turing machine is not itself a finite string.
>>>>>>>
>>>>>>> The definition of a Turing machine does not say that a Turing 
>>>>>>> machine
>>>>>>> is not a finite string. It is an abstract mathematical object 
>>>>>>> without
>>>>>>> a specification of its exact nature. It could be a set or a finite
>>>>>>> string. Its exact nature is not relevant to the theory of 
>>>>>>> computation,
>>>>>>> which only cares about certain properties of Turing machines.
>>>>>>>
>>>>>>>> Therefore It is not allowed to report on its own behavior.
>>>>>>>
>>>>>>> Anyway, that does not follow. The theory of Turing machines does not
>>>>>>> prohibit anything.
>>>>>>>
>>>>>>>> Another different TM can take the TM description of this
>>>>>>>> machine and thus accurately report on its actual behavior.
>>>>>>>
>>>>>>> If a Turing machine can take a description of a TM as its input
>>>>>>> or as a part of its input it can also take its own description.
>>>>>>> Every Turing machine can be given its own description as input
>>>>>>> but a Turing machine may interprete it as something else.
>>>>>>>
>>>>>> In this case we have two x86utm machines that are identical
>>>>>> except that DDD calls HHH and DDD does not call HHH1.
>>>>>>
>>>>>> It is empirically proven that this changes their behavior
>>>>>> and the behavior of DDD.
>>>>>>
>>>>>
>>>>> You say a lot about things that are "empirically proven" and 
>>>>> without exception they are never "proven" at all.
>>>>>
>>>>
>>>> It is empirically proven according to the semantics of the
>>>> x86 machine code of DDD that DDD correctly emulated by HHH
>>>> has different behavior than DDD correctly emulated by HHH1.
>>>
>>> No, you have proven that the *simulation* is different, not that the 
>>> behaviour of the simulated function is different.
>>> The simulations differ, because one is correct and the other one is 
>>> incorrect.
>>> The one that skips x86 instructions (by aborting) does not follow the 
>>> semantics of the x86 language. Its simulation is incomplete and 
>>> therefore is wrong.
>>
>> But the point is that PO alleges HHH and HHH1 are identical copies.  
>> If that were the case, why would one abort while the other does not?
>>
> 
> I explain that most completely by providing the full execution trace.
> I have done that many times over the last three years. You are so
> sure that I must be incorrect that you don't bother to examine this
> trace that has consistently proven that I am correct for three years.
> 
>> The answer is obviously that they are NOT proper copies, just like 
>> PO's earlier H/H1.  Or PO has cheated with misuse of global variables 
>> or similar.  (PO has previously insisted these functions are "pure", 
>> but that is probably his own wishful thinking rather than fact... so 
>> who knows?)
>>
> 
> If you understand the semantics of the x86 language then you
> can see that N instructions of DDD are correctly emulated by
> HHH. 

You would also see that HHH skips M instructions of the X86 code, when 
it aborts. That makes the simulation incomplete and incorrect. It has 
been pointed out many times that the semantics of the x86 language does 
not allow skipping instructions and then claim that it will still show 
the behaviour of the program.

> You can also see by the repeating state of DDD correctly
> emulated by HHH that HHH must abort it emulation of DDD or
> DDD and HHH would never terminate.

And when it aborts, it aborts too soon, because one cycle later the 
simulated HHH would abort and halt, so the abort by the simulating HHH 
was premature.
It is clear that HHH cannot possibly simulate itself correctly, because 
the simulated HHH runs one cycle behind the simulating HHH. The 
simulating HHH, when it aborts, always one cycle too soon.

> 
>  From understanding the semantics of the x86 language you can
> also see that after HHH(DDD) has aborted the emulation of its
> input that the correct emulation of a different process instance
> of DDD by HHH1 does terminate normally.

Yes. HHH1 does a correct simulation of an incorrect simulation by HHH.

DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

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

This has the same problem. This proves that the problem is not in DDD, 
but in HHH, which halts when it aborts the simulation, but it decides 
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

========== REMAINDER OF ARTICLE TRUNCATED ==========