Liste des Groupes | Revenir à theory |
On 28/05/2025 19:23, Mr Flibble wrote:<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>On Mon, 26 May 2025 21:22:55 -0500, olcott wrote:Right, but its conclusion is incorrect due to PO's misunderstanding of simulation.
>On 5/26/2025 9:09 PM, Richard Damon wrote:>On 5/26/25 6:05 PM, olcott wrote:*Termination analyzers PREDICT behavior dip-shit* It is a tautology thatOn 5/26/2025 3:44 PM, Richard Damon wrote:But since HHH(DDD) DOES abort its emulation of DDD, it is a fact thatOn 5/26/25 11:29 AM, olcott wrote:>On 5/26/2025 5:04 AM, Mikko wrote:But you have to affirm first that HHH *IS* a program that does that,On 2025-05-25 14:36:26 +0000, olcott said:I am asking you to affirm that I am correct about this point.
>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.
>
>
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.
>
>
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.
>
>
DDD() will halt.
>
>
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 *infiniterecursion 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.
According to your definition of SHD below, PO does not in fact have an SHD.
>I think all here understand that such an SHD is logically possible.
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.
PO claims such a SHD, but PO's SHD is unsound (wrongly claiming non- halting for a halting computation).
Les messages affichés proviennent d'usenet.