Re: The philosophy of computation reformulates existing ideas on a new basis

On 11/6/2024 8:39 AM, Mikko wrote:

On 2024-11-05 13:18:43 +0000, olcott said:
 

On 11/5/2024 3:01 AM, Mikko wrote:

On 2024-11-03 15:13:56 +0000, olcott said:
>

On 11/3/2024 7:04 AM, Mikko wrote:

On 2024-11-02 12:24:29 +0000, olcott said:
>

HHH does compute the mapping from its input DDD
to the actual behavior that DDD specifies and this
DOES INCLUDE HHH emulating itself emulating DDD.

>
Yes but not the particular mapping required by the halting problem.

>
Yes it is the particular mapping required by the halting problem.
The exact same process occurs in the Linz proof.

>
The halting probelm requires that every halt decider terminates.
If HHH(DDD) terminates so does DDD. The halting problmen requires
that if DDD terminates then HHH(DDD) accepts as halting.

>
void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}
>
No that is false.
The measure is whether a C function can possibly
reach its "return" instruction final state.

 Not in the original problem but the question whether a particular strictly
C function will ever reach its return instruction is equally hard. About

It has always been about whether or not a finite string input
specifies a computation that reaches its final state.
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
DDD emulated by HHH cannot possibly reach its own "return" instruction.
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
⟨Ĥ⟩ simulated by embedded_H cannot possibly reach either
of its states ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ thus cannot possibly reach
its final state of ⟨Ĥ.qn⟩.
Thus when the measure of correct is the behavior that
the finite input string specifies and the measure of
halting is reaching the final state of this finite
string input then HHH and embedded_H are correct to
reject their input as non-halting.
If these measures are believed to be incorrect then sound
reasoning must be applied to show this.
That is just not what most everyone else believes IS NOT
sound reasoning.

a C function that is not strictly conforming the question may have a
third answer that it may or may not reach its "return" instruction dpending
on the C implementation.
 A C function can terminate without reaching its return statement.
The C standard specifies several other possibilities.
 

Your measure determines that Infinite_Loop() halts.

 No, it does not. You should not present claims without justification.
To look like liar is not the best defence against being called a liar.
 

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer