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

On 11/3/24 10:13 AM, olcott wrote:

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.
 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 emualation started at point (c) at the outer level aborts its emulation, just like H does, and then the whold thing halts.

 The initial input to the directly executed
embedded_H never reaches its own ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.

Sure it does, just not in the partial emulation done by H

 embedded_H is not allowed to report on its own behavior
it is only allowed to report on the behavior of its input.

Sure it is, and in fact, it MUST as its own behavior is part of the behavior of the input it is processing.
You are just PROVING you don't understand the meaning of the terms.

 

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

>
The behavour specified by DDD is the same in both cases,

 *That is counter-factual*

Nope, it is DEFINITION.

 DDD emulated by HHH
CANNOT POSSIBLY reach its own return instruction.

Sure it can, if you use the correct meaning that matches sematics, which means you are talking about the behavior of the program DDD, the DDD that HHH was emulating, and not the non-semantic subjective meaning of the partial emulation done by HHH.

 DDD emulated by HHH1
DOES REACH its own return instruction.
 Are you so totally clueless that you can't see this?

No, you are just showing you are cluesless to claim it.

 

incuding
the behaviour of HHH(DDD). The mapping computed by HHH1 is different
from HHH so at least one of them is not the mapping required by the
halting problem (and in fact the other isn't, either).
>

It seems ridiculously stupid for everyone here to simply
ignore how pathological self-reference DOES IN FACT
change the behavior of DDD.

>
The pathological self-reference does not change anything.

 *That is counter-factual*

That is factual.

 DDD emulated by HHH
CANNOT POSSIBLY reach its own return instruction.

Sure it can, if you use the correct meaning that matches sematics, which means you are talking about the behavior of the program DDD, the DDD that HHH was emulating, and not the non-semantic subjective meaning of the partial emulation done by HHH.

 DDD emulated by HHH1
DOES REACH its own return instruction.
 Are you so totally clueless that you can't see this?

No, you are just totally clueless to claim that lie.

 

 It just
is there. But it is not very pathological as HHH can detect it
and terminate anyway.
>