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

On 5/13/24 2:20 PM, olcott wrote:

On 5/12/2024 7:39 PM, Richard Damon wrote:

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

On 5/12/2024 6:57 PM, Richard Damon wrote:

On 5/12/24 7:14 PM, olcott wrote:

On 5/12/2024 5:40 PM, Richard Damon wrote:

On 5/12/24 6:21 PM, olcott wrote:

On 5/12/2024 4:40 PM, Richard Damon wrote:

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

>
It can answer without halting by transitioning to its own internal
non-final state of embedded_H.qn without ever reaching Ĥ.qn. Every
simulated instance of embedded_H would do this same thing and then
continue simulating its input.

So, you just don't understand how algorithms work, and how compuations are DEFINED.
>
>
If you want to try to define a new system of compuation that allows giving answer without the algorithm ending, but still allows all the composition operations that are included in computation theory, go ahead and try.
>
You then need to show that it is Turing Complete, which means that you can't outlaw any computation allowed in a Turing Machine, like H^.
>

>
*It <is> a way for embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to get the correct answer*
*It <is> a way for embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to get the correct answer*
*It <is> a way for embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ to get the correct answer*

>
Nope.
>
Claiming to do something that isn't the way defined doesn't make it work.
>

>
It is not a halt decider. It is not even a termination analyzer.
It <is> an huge improvement over both YES and NO from H are the
wrong answer.  NO from H IS THE CORRECT ANSWER.

>
It isn't even a "program" per the term-of-the-art, since it generates and answer without ending, thus your "proof" is based on lies.
>

 I have no idea what you are basing this on, a "program"
is not any term-of-the-art of the theory of computation.

Then why is one phrasing of the Halting Problem about the decider answering about the "program" given to it?
I guess you just don't understand what the terms mean.

 It is well known in the field that some Turing Machines
never halt, so it certainly can be a Turing machine.

Yes, but it doesn't ANSWER.
Remember the definition of a decider,

 You are certainly correct that it is not a computable
function.

So, you AGREE that you 20 year quest to show that Turing was WRONG about Halting not being a computable function, as we can not build an always correct Halt Decider?

 We can say that H is proven to "know" the correct halt
status, yet cannot "say" the correct halt status in the
conventional way.

But that isn't what Computation Theory is about.

 Objectively this does seem to be a significant breakthrough
over both YES and NO are the wrong answer from H. I don't
think that you can provide any correct reasoning to the contrary.

Nope.
And Yes and No are not both wrong, Which ever answer that H gives is wrong, and the other is right.
You don't seem to understand that a given H will ALWAYS give the same answer to the same input, and thus only one answer needs to be wrong.

 *RHETORIC COUNTS AS ZERO REASONING*
*RHETORIC COUNTS AS ZERO REASONING*
*RHETORIC COUNTS AS ZERO REASONING*

Right, like what you use. Note, I intersperse my "Rhetoric" with facts, unlike you.

 

>

That it like claiming you can make you cat bark, by trying to call your dog a cat.
>

>
Every prior work that I have ever seen and probably every prior
work that exists essentially concludes that both YES and NO are the
wrong answer for H to provide for every H/D pair where H and D have
the HP pathological relationship.

>
Which ever answer H gives, will be wrong.
>

>
I JUST PROVED OTHERWISE.
YES IS THE CORRECT ANSWER AND AS LONG AS H PROVIDES
THIS ANSWER WITHOUT STOPPING NOTHING CONTRADICTS IT.
>

>
Where?
>
You claimed the equivalent of a cat being a 10 story office building.
>
embedded_H can NOT give an answer and continue to run and still be a program per the computability theory.
>
Your claim is that the right answer can't be the right answer because it is impossible for H to determine it. That is just throwing a two-year-olds hissy fit.
>

 I PROVED THAT H DOES KNOW THE CORRECT ANSWER YET
CANNOT PROVIDE THE CORRECT ANSWER IN THE CONVENTIONAL WAY.

And thus, FAILS to ANSWER the question.

 THIS SEEMS TO BE AN INCREMENTAL IMPROVEMENT OVER
BOTH YES AND NO ARE THE WRONG ANSWER FROM H

Nope. In fact, I believe I pointed out that option a few years ago, your H that simulates forever has the option of "indicating" that the input is non-halting, even if it can't answer.

 

>
You just don't seem to understand the basic computation model., because you are too stupid.
>
>

 *RHETORIC AND INSULTS ARE WHAT PEOPLE USE WHEN THEY HAVE NOTHING ELSE*
*RHETORIC AND INSULTS ARE WHAT PEOPLE USE WHEN THEY HAVE NOTHING ELSE*
*RHETORIC AND INSULTS ARE WHAT PEOPLE USE WHEN THEY HAVE NOTHING ELSE*
*RHETORIC AND INSULTS ARE WHAT PEOPLE USE WHEN THEY HAVE NOTHING ELSE*
*RHETORIC AND INSULTS ARE WHAT PEOPLE USE WHEN THEY HAVE NOTHING ELSE*
 

But I have shown that to be TRUE.
You DON'T understand the basics.