Path: ...!weretis.net!feeder9.news.weretis.net!news.quux.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!eternal-september.org!.POSTED!not-for-mail
From: Mikko <mikko.levanto@iki.fi>
Newsgroups: comp.theory
Subject: Re: Bad faith and dishonesty
Date: Sun, 1 Jun 2025 12:12:25 +0300
Organization: -
Lines: 130
Message-ID: <101h5hp$1v64q$1@dont-email.me>
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: Sun, 01 Jun 2025 11:12:26 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="e5394674ad0d6242ba242d5149f7d426";
	logging-data="2070682"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX19o0uKXjCtn6fjppGkj+sGA"
User-Agent: Unison/2.2
Cancel-Lock: sha1:jxNMESkzbdZRUgyOIQvbE0IdF0A=
Bytes: 7130

On 2025-05-31 15:51:04 +0000, olcott said:

> 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.

There is no must about it. Either way the value is correct for
some inputs and wrong for other inputs.

> 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.
> 
>>> 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.

No, it does not. You cannot prove that 0 = 1 from what I said.

-- 
Mikko