Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!news.quux.org!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Bad faith and dishonesty
Date: Sat, 31 May 2025 14:44:01 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <9cf64f74d6a4cc30cc7dc8ff9832278e9c86184a@i2pn2.org>
References: <m99YP.725664$B6tf.610565@fx02.ams4>
 <100uct4$184ak$1@dont-email.me> <100v9ta$1d5lg$7@dont-email.me>
 <1011eai$1urdm$1@dont-email.me> <10121bt$22da5$4@dont-email.me>
 <8bb5266e35845a4d8f2feb618c0c18629c04e4e7@i2pn2.org>
 <1012oj1$278f8$1@dont-email.me>
 <1196d9de2e2aebc1b6d1a85047192e8ea1aeb1f1@i2pn2.org>
 <10137lv$2djeu$1@dont-email.me> <1013tkq$2h8vj$3@dont-email.me>
 <1014ls5$2lsi8$7@dont-email.me> <1016hsk$35agb$1@dont-email.me>
 <101782n$39etk$6@dont-email.me>
 <598498aff364c9e1b90a9db1e18bd1e27a18b993@i2pn2.org>
 <101bt22$dklb$1@dont-email.me> <101cj31$hfof$5@dont-email.me>
 <101ehoe$11tu3$1@dont-email.me> <101f8h8$173bb$7@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 31 May 2025 18:48:23 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2723957"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <101f8h8$173bb$7@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US

On 5/31/25 11:51 AM, olcott wrote:
> On 5/31/2025 4:22 AM, Mikko wrote:
>> On 2025-05-30 15:32:48 +0000, olcott said:
>>
>>> On 5/30/2025 4:16 AM, Mikko wrote:
>>>> On 2025-05-29 01:37:49 +0000, Richard Damon said:
>>>>
>>>>> On 5/28/25 10:54 AM, olcott wrote:
>>>>>> On 5/28/2025 3:35 AM, Fred. Zwarts wrote:
>>>>>>> Op 27.mei.2025 om 17:31 schreef olcott:
>>>>>>>> On 5/27/2025 3:37 AM, Fred. Zwarts wrote:
>>>>>>>>> Op 27.mei.2025 om 04:22 schreef olcott:
>>>>>>>>>> On 5/26/2025 9:09 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/26/25 6:05 PM, olcott wrote:
>>>>>>>>>>>> On 5/26/2025 3:44 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/26/25 11:29 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/26/2025 5:04 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2025-05-25 14:36:26 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 5/25/2025 1:21 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2025-05-24 01:20:18 +0000, Mr Flibble said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So much bad faith and dishonesty shown in this forum 
>>>>>>>>>>>>>>>>>> that myself and Peter
>>>>>>>>>>>>>>>>>> Olcott have to fight against.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Everything here seems to be dishonesty and protests 
>>>>>>>>>>>>>>>>> against dishonesty.
>>>>>>>>>>>>>>>>> If you could remove all dishonesty the protests woud 
>>>>>>>>>>>>>>>>> stop, too, and
>>>>>>>>>>>>>>>>> nothing would be left.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _DDD()
>>>>>>>>>>>>>>>> [00002192] 55             push ebp
>>>>>>>>>>>>>>>> [00002193] 8bec           mov ebp,esp
>>>>>>>>>>>>>>>> [00002195] 6892210000     push 00002192
>>>>>>>>>>>>>>>> [0000219a] e833f4ffff     call 000015d2  // call HHH
>>>>>>>>>>>>>>>> [0000219f] 83c404         add esp,+04
>>>>>>>>>>>>>>>> [000021a2] 5d             pop ebp
>>>>>>>>>>>>>>>> [000021a3] c3             ret
>>>>>>>>>>>>>>>> Size in bytes:(0018) [000021a3]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then acknowledge that DDD simulated by HHH according
>>>>>>>>>>>>>>>> to the rules of the x86 language cannot possibly reach
>>>>>>>>>>>>>>>> its own "ret" instruction final halt state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have never claimed that your HHH can simulate DDD to 
>>>>>>>>>>>>>>> from the beginning
>>>>>>>>>>>>>>> to end.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am asking you to affirm that I am correct about this point.
>>>>>>>>>>>>>> DDD simulated by HHH according to the rules of the x86
>>>>>>>>>>>>>> language cannot possibly reach its own "ret" instruction
>>>>>>>>>>>>>> final halt state, thus is correctly rejected as non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But you have to affirm first that HHH *IS* a program that 
>>>>>>>>>>>>> does that, and can't be "changed" to some other program, 
>>>>>>>>>>>>> and that DDD is "completed" to contain that same code.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Of course, once you define that HHH is such a program,
>>>>>>>>>>>>
>>>>>>>>>>>> Unless HHH(DDD) aborts its emulation of DDD then
>>>>>>>>>>>> DDD() and HHH() never stop running proving that
>>>>>>>>>>>> the input to HHH(DDD) SPECIFIES NON-TERMINATING
>>>>>>>>>>>> BEHAVIOR THAT MUST BE ABORTED.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But since HHH(DDD) DOES abort its emulation of DDD, it is a 
>>>>>>>>>>> fact that DDD() will halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Termination analyzers PREDICT behavior dip-shit*
>>>>>>>>>> It is a tautology that every input that must be
>>>>>>>>>> aborted to prevent the infinite simulation of this
>>>>>>>>>> input DOES SPECIFY NON-HALTING BEHAVIOR.
>>>>>>>>>>
>>>>>>>>> Counter-factual. There is no need to prevent infinite 
>>>>>>>>> simulation, because the input includes DDD with all functions 
>>>>>>>>> called by DDD, including the code in Halt7.c that specifies the 
>>>>>>>>> abort.
>>>>>>>>
>>>>>>>> Unless the outmost HHH aborts then none of them
>>>>>>>> abort because they all of the exact same machine code.
>>>>>>>>
>>>>>>>
>>>>>>> Only when you also change the input. Changing input from a HHH 
>>>>>>> that aborts to a HHH that does not abort is changing the subject.
>>>>>>>
>>>>>>
>>>>>> It either every HHH aborts or no HHH aborts
>>>>>> because they all have the same machine code.
>>>>>
>>>>> And if every HHH aborts and returns 0, then every DDD will Halt.
>>>>>
>>>>> If no HHH aborts, then no HHH ever answers.
>>>>>
>>>>> In both cases, it is wrong.
>>>>
>>>> And if every HHH aborts and returns 1 then every DDD will halt. In
>>>> this case HHH is right. But in this case HHH is not Olcott's HHH.
>>>
> 
> Abort must return 0, 1 is only returned when an input
> reaches its own final halt state.
> 
> int main()
> {
>    DDD(); // the HHH that DDD calls is not supposed to
> }        // report on the behavior of its caller.
>           // It is supposed to report on the behavior
>           // that its input specifies.


HHH is supposed to report on the behavior of the program represented to it.

When thisDDD is made a program (by including the code of the HHH that 
does what you claim HHH does) then since that HHH returns 0, the only 
correct answer for HHH to have returned was 1, so it was just wrong.

> 
>>> When DDD is correctly emulated by HHH the first four
>>> instructions of DDD are emulated. When HHH(DDD) is
>>> called from DDD then HHH emulates itself emulating DDD.
>>>
>>> No matter how many times HHH emulates itself emulating
>>> DDD the emulated DDD cannot possibly reach its "ret"
>>> instruction final halt state. This proves that DDD emulated
>>> by HHH is non-halting.
>>
>> That does not contradict what I said above.
>>
> 
> What you said above contradicts itself.
> 

Olcott, *YOU* are a man filled with contradictions and lies.