Re: My reviewers think that halt deciders must report on the behavior of their caller

On 7/5/25 12:31 PM, olcott wrote:

On 7/5/2025 8:20 AM, Richard Damon wrote:

On 7/4/25 6:15 PM, olcott wrote:

On 7/4/2025 3:53 PM, Richard Damon wrote:

On 7/4/25 4:43 PM, olcott wrote:

On 6/3/2025 10:02 PM, dbush wrote:

On 6/3/2025 10:58 PM, olcott wrote:

On 6/3/2025 9:46 PM, dbush wrote:

On 6/3/2025 10:34 PM, olcott wrote:

On 6/3/2025 9:12 PM, dbush wrote:

>
Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:
>
A solution to the halting problem is an algorithm H that computes the following mapping:
>
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly
>

>
Yes there is no algorithm that does that

>
Excellent!
>
Let The Record Show
>
That Peter Olcott
>
Has *EXPLICITLY* admitted
>
That no algorithm H exists that meets the above requirements, which is precisely the theorem that the halting problem proofs prove.

>
In the exact same way that there is no set of all set
that contain themselves. ZFC did not solve Russell's
Paradox as much as it showed that Russell's Paradox
was anchored in an incoherent foundation, now called
naive set theory.

>
Which arose because the axioms of naive set theory created a contradiction.
>

>
Likewise with halt deciders that are required to report
on the behavior of directly executed Turing machines.

>
And what is the CONTRADICTION?
>
The result is just some things are not computable.
>

>
Directly executed Turing machines are outside of the
domain of every Turing machine decider.

>
Then so is mathematics, as "numbers" can't be given to Turing Machines, only representations of them.
>

>
Numbers always work the same way so it makes no difference.

>
So do programs. (When they are programs)
>

>
*HHH(DDD)==0 and HHH1(DDD)==1 are both correct*
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c

>
Based on your LIE:
>
Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0
>
that the pattern HHH used was an actual non-termination pattern
>

 Since it proves that it figured out all of the details
of this non-terminating pattern itself its agreement
is not biased by my generic definition of the notion
of simulating termination analyzer.

But you didn't, you lied about it.

 HHH simulating DDD:
   - Enter DDD()
   - Call HHH(DDD)
   - Pattern detected: infinite recursion of HHH simulating DDD
   - Simulation aborted, return 0
 

But the pattern isn't non-halting, as the correct simulation of that exact same input (which calls the exact same HHH) will halt.
Thus, you prove you don't understand the meaning of the words you are using,
You don't know what a program is.
You don't know what correct simulation is.
You don't know what "non-halting" means, and what category of things it apply to.
In other words, you don't know what you are talking about, and think that lying is just correct reasoning.
Of course, that does seem to be you view of the world, that lying is correct, which is why no one can trust what you say.