Re: Bad faith and dishonesty

On 5/26/2025 2:07 PM, Fred. Zwarts wrote:

Op 26.mei.2025 om 21:01 schreef olcott:

On 5/26/2025 1:55 PM, Fred. Zwarts wrote:

Op 26.mei.2025 om 20:41 schreef olcott:

On 5/26/2025 1:31 PM, Fred. Zwarts wrote:

Op 26.mei.2025 om 18:20 schreef olcott:

On 5/26/2025 11:07 AM, Fred. Zwarts wrote:

Op 26.mei.2025 om 17:16 schreef olcott:

On 5/26/2025 3:32 AM, Fred. Zwarts wrote:

Op 25.mei.2025 om 21:39 schreef olcott:

On 5/25/2025 2:27 PM, Fred. Zwarts wrote:

Op 25.mei.2025 om 20:42 schreef olcott:

On 5/25/2025 1:07 PM, Fred. Zwarts wrote:

Op 25.mei.2025 om 18:39 schreef olcott:

On 5/25/2025 10:49 AM, Fred. Zwarts wrote:

Op 25.mei.2025 om 16:36 schreef olcott:

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.

Why repeating this bug in HHH?

>
That everyone that understands these things
sees that there is no bug makes your statement
the kind of reckless disregard for the truth
that loses defamation cases.
>
In other words by objective standards: YOU ARE A LIAR
>

>
Ad hominem attacks showing lack of counter arguments.

>
When you are objectively a liar then calling
you a liar is merely stating the facts.
>

>
Again a baseless ad hominem attack, showing lack of counter arguments.

>
I dared you to show my mistake your failure to even
attempt this sufficiently proves that you are a liar.
>

You only ignore it when your failures are shown and start again repeating the baseless claims.

>

Every competent programmer will understand that when the input specifies a halting program, including the code to abort and return, but HHH fails to see that part of the specification, then HHH has a bug.
I know you will ignore it again and reply with only ad hominem attacks.

>
_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]
>
How many recursive emulations does HHH have to
wait before its emulated DDD magically halts
on its own without ever needing to be aborted?
>

>
HHH needs only one recursion more that the number of recursions in the input.
So, if your HHH has only one recursion, two recursions are needed, except when you change the input, but that is not allowed.

>
So you said that the first four instructions of DDD
are emulated twice and we are at machine address 0000219a.
So a correct emulator could interpret "call 000015d2"
to mean "jmp 000021a3" ???
>

Apparently this is over your head. That is not what I said. You are mixing recursion levels.
The simulated HHH in its first recursion (which is the second recursion of the simulating HHH) aborts at 0000219a (because we do not change the input, so the simulated HHH aborts after one cycle). It is programmed to not execute the call but abort and return. That will make that the call at 0000219a simulated by the simulating HHH returns and the simulating HHH will process the next instruction at 0000219f and the following instructions, up to the 'ret' instruction at 000021a3.
A return from a call is very normal in the x86 language and if you think that it means that the call is replaced with a jmp instruction, you show your ignorance of the x86 language.

>
_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]
>
unless some HHH aborts its emulation of its DDD
DDD() and HHH() never halt.

That is what I said. The simulated HHH, specified in the input, does abort, so no abort is needed in the simulating HHH.

>
Likewise when you are starving to death there is no reason
to get anything to eat because you know that after you eat
you will no longer be starving to death.

I see that it is over your head. But it is simple:
If no-one is starving, we do not need to eat. If there is no non-halting program, there is no need to abort its simulation.

Unless HHH(DDD) aborts its own simulation of DDD
then DDD(), HHH() never halt proving that DDD
specifies a non halting sequence of configurations.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer