Re: Bad faith and dishonesty --- Mike feels free to disagree with tautologies

On 5/28/2025 8:32 PM, Mike Terry wrote:

On 28/05/2025 19:23, Mr Flibble wrote:

On Mon, 26 May 2025 21:22:55 -0500, olcott wrote:
>

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.

>
Olcott is claiming:
>

“My SHD detects that the program (e.g., `DDD()`) has an *infinite

recursion structure* and therefore halts early with a decision: non-
halting.”
>
This would mean:
>
* SHD *does not simulate* the entire execution.
* Instead, it performs **analysis** (akin to symbolic execution, static
control flow, or syntactic pattern detection).
* It concludes **before execution completes** that the input program will
never halt.

 Right, but its conclusion is incorrect due to PO's misunderstanding of simulation.
 According to your definition of SHD below, PO does not in fact have an SHD.
 

>
This now resembles modern **termination analyzers** used in:
>
* Formal methods (e.g., Coq, Agda)
* CompCert (verified C compiler)
* Model checking and static analysis tools
>
---
>
### 🔍 What This Means
>
1. **SHD becomes a partial analyzer.**
>
    * It is no longer a classical halt decider (which must be total).
    * It becomes a **sound** (never wrongly claims halting) but
**incomplete** (may fail to decide in some cases) analyzer.

 I think all here understand that such an SHD is logically possible.
 PO claims such a SHD, but PO's SHD is unsound (wrongly claiming non- halting for a halting computation).
 

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its
     input D until H correctly determines that its simulated D
     would never stop running unless aborted then
It is a tautology that any input D to termination
analyzer H that *would never stop running unless aborted*
DOES SPECIFY NON-TERMINATING BEHAVIOR
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer