Re: Bad faith and dishonesty

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

 2. **Detection ≠ Simulation**
     * Damon’s original critique presumes SHD reaches a contradiction
through simulation.
    * But if SHD performs structural detection of recursive constructs
(e.g., unguarded self-calls), it’s operating at the **language or AST
level**, not the runtime level.

99% of PO's analysis depends only on the simulation instruction trace, which we might call the "runtime level".
An aspect of his analysis is ignoring instruction trace entries corresponding to HHH and its subroutines.  I'd count that as "structural detection".

 3. **Olcott's Argument Gets Stronger**
     * If SHD statically proves a path leads to infinite recursion, then
halting early is valid.
    * This kind of structural non-termination detection is used in many
safe languages and compilers.

But PO's HHH is not, and never has been, an SHD as you define it, so in no way does his "argument get stronger"!
Mike.