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

On 11/6/24 10:26 AM, olcott wrote:

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.

Which means the input needs to actually specify a computation, which yours doesn't, and when we add that code of HHH, we see that the program so described WILL halt as long as the HHH is like the one you present that returns an answer.

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

WHich is just your equivlocation again.
DDD does reach the return instruction.
The emulation by HHH (that answers) doesn't yield a result that qualfies to show "can't possibly reach", as partal emulations don't give that sort of fact.

 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

until the embedded_H that started in (c) decides to abort its emulation, and then the whole thing stops.
If it doesn't, then H can't abort its either, as they are supposed to be the same Turing Machine.

 ⟨Ĥ⟩ simulated by embedded_H cannot possibly reach either
of its states ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩ thus cannot possibly reach
its final state of ⟨Ĥ.qn⟩.

Which is irrelevent, as only the emulation by a UTM matters, and embedded_H can't be a UTM if H aborts its emulation to go to qn, as embedded_H is an exact copy of that H.

 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.

But the "behavior" that the finite input string specifies is the behavior of a UTM emulation that input, not that of a PARTIAL emulation.

 If these measures are believed to be incorrect then sound
reasoning must be applied to show this.

No, the DEFINITION must be applied, something you have rejected, but still imply you follow, as you haven't put yourself outside the system, since you still talk about refuting things in the system, which can only be done in the system.
So, you are just shown to be a stupid liar.

 That is just not what most everyone else believes IS NOT
sound reasoning.

Nope, just shows that you don't understand the definitions, and are too stupid to understand when people correct you.

 

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