Re: HHH(DDD) is correct to reject its input as non-halting --- EVIDENCE THAT I AM CORRECT

On 2025-06-29 14:34:33 +0000, olcott said:

On 6/29/2025 4:10 AM, Mikko wrote:

On 2025-06-28 13:51:21 +0000, olcott said:
 

On 6/28/2025 6:56 AM, Mikko wrote:

On 2025-06-27 14:26:41 +0000, olcott said:
 

On 6/27/2025 1:42 AM, Mikko wrote:

On 2025-06-27 04:21:01 +0000, olcott said:
 

On 6/26/2025 5:20 AM, Mikko wrote:>>>

In computer science the only measure of non-halting is the
possibility to execute an unlimited number of steps without
halting. An execution of a limited number of steps does not
count as non-haltign.

 Halting means reaching a final halt state.

 And non-halting means unlimited execution.

 Not at all. The measure has always been can't possibly reach
final halt state.

 In Post's simplified version, which is the most commonly used one,
a computation halts when there is no applicable rule to specify
the next action.

 It is best to use the standard measure of halting
as reaching a final halt state.

 If you use Turing's original form of Turing maches then it is best to
use Turing's definition of halting. If you are using some usual form
then the usual criterion that halting means inability to contimue.
Otherwise you get the paradox that a computation cannot be continued
but it has not halted, either.

 Because no one ever thought of a simulating partial halt
decider (SPHD) before as a partial halt decider (PHD) we
must divide halting from an aborted simulation.

Simulations and partial deciders are irrelevant to halting problem
adn halting uncomputability proofs of any kind. Simulation is
merely an implementation detail not exluded in the proof or in the
problem statement. Partial halt deciders are not in the scope of
the proofs. From other considerations it it known that a partial
halting decider is possible.

If we don't do this then actual infinite loops will
be misconstrued as halting because their SPHD stopped
simulating them.

Perhaps for some purposes in some contenxts but the proof of
uncomputablity of halting is not affected.

If we don't do this then we get psychotic ideas like Richard's that
we cannot know that a computation does not halt until after we
simulate it forever.

 It is a sin to lie about other people.
 Anyway, you don't know that a computation does not halt unless you
can prove it. There is no method that can find a proof in all cases
but that doesn't prevent from finding a proof for some non-halting
cases.

 This very simple proof seems too difficult for anyone
to understand.

Perhaps there is a reason why proofs are always preceded by the
claim to be proven.

void DDD()
{
   HHH(DDD);
   return;
}
 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 The x86 source code of DDD specifies that this emulated
DDD cannot possibly reach its own emulated "ret" instruction
final halt state when emulated by HHH according to the
semantics of the x86 language.

--
Mikko