Re: A computable function that reports on the behavior of its actual self is not allowed

On 5/12/24 5:18 PM, olcott wrote:

On 5/12/2024 2:27 PM, olcott wrote:

Computable functions are the basic objects of study in computability
theory. Computable functions are the formalized analogue of the
intuitive notion of algorithms, in the sense that a function is
computable if there exists an algorithm that can do the job of the
function, i.e. given an input of the function domain it can return the
corresponding output. https://en.wikipedia.org/wiki/Computable_function
>
A computable function that reports on the behavior of its actual
self (or reports on the behavior of its caller) is not allowed.
>
A decider must halt whereas simulating a pathological input
that would never halt unless aborted can only halt by aborting.
>
This causes the direct execution of this input after it has been aborted
to have different behavior than the simulated input that cannot possibly
stop running unless aborted.
>

 *MORE PRECISE WORDING* (this may take a few more rewrites)
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
 It is a verified fact that the directly executed Ĥ ⟨Ĥ⟩ cannot possibly
stop running unless simulating partial halt decider embedded_H aborts
its simulation of its input.

But since embedded_H implements a specific algorithm, either it will or it won't. "unless" is a meaningless word here, it implies a case that can't happen.
We can look at the two possible cases.
First, if embedded_H doesn't ever abort its simulation, then, as you have desceribed, THAT embedded_H creates a H^ that will never halt, but the H that was based on will also never abort its simulation (or you lied that embedded_H is the needed copy of H) and thus never answer and fail to be a decider.
Or, if embedded_H does abort its simulation at some point, then goes to qn, as you say, then it is clear that the H^ (H^) that uses that embedded_H (H^, H^) will halt.
To say that "unless" embedded_H aborts, is trying to LIE that embedded_H is allowed to look at an input other than the H^ that it wasn't given, the embedded_H@ that creates an H^@ that calls it. But that isn't the input that it is give,. so a logical error and a LIE to claim it is ok to do.

 (a) The behavior of the directly executed Ĥ ⟨Ĥ⟩ is after
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ has already aborted its simulation.
 (b) The behavior of the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
is before embedded_H has aborted its simulation.
 (c) These two behaviors (a) and (b) ARE NOT THE SAME. (a) will stop
running on its own (b) will never stop running unless aborted.

Nope, if embedded_H correctly simulates its input, the steps simulated by embedded_H will EXACTLY match the steps that the direct execution of H^ (H^) preform.
The difference is that your embedded_H incorrectly extrapolates what it THINKS the usage of embedded_H will do, and that differs from what actually happens, so it just shows that extrapolation was incorrect.

 embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is not allowed to report on the behavior of its
actual self, thus is not allowed to report on the behavior of the
directly executed Ĥ ⟨Ĥ⟩.

Of course it is, it is REQUIRED to report the behavior of the machine described by its input, so if the input describes a machine that includes a copy of embedded_H, to meet its requirements it must report on the behavior of that machine that included itself.
Where do you get the idea that embedded_H is "allowed" to report on this.
It might not be ABLE, but it can certainly be required to do it.

 

Since no one here understands that a simulating partial halt decider
is not even allowed to report on its own behavior or the behavior of its
caller they do not understand that the behavior of the directly executed
machine is irrelevant.
>
>
>