Re: Bad faith and dishonesty

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.

 Simulating Termination analyzers must PREDICT
non-terminating behavior, thus are inherently
required to report on what the behavior would be.

Right, of its input, which has a copy of it that does what it does.

 To require a STA to report on the actual behavior
of a non-terminating input is to require them to
never report. This is not allowed.

But the input isn't non-terminating. That is the similar input built on the disallowed STA that doesn't abort.
I guess you are admitting that you logic is based on LYING, either about which input the STA is looking at, or the actual behavior of that input.
Of course, since you input isn't a program and doesn't include all of the code, your problem is just incorrect set up and fails on a category error.
Your STA CAN'T correctly simulate that input, as it doesn't actually have behavior.

 _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]
 It is a tautology that every input to a simulating
termination analyzer would never stop running unless
aborted specifies a non-terminating sequence of
configurations.
 

And, when you complete the above with the code of the STA as you seem want to do, that input WILL Halt, since the STA, by your admission, will abort and return 0, and thus be wrong.
Thus, you are admitting that you logic is just based on lying about everything.