Re: HHH(DDD)==0 is correct

On 7/6/25 12:06 AM, olcott wrote:

On 7/5/2025 9:59 PM, Richard Damon wrote:

On 7/5/25 10:23 PM, olcott wrote:

On 7/5/2025 7:36 PM, Richard Damon wrote:

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

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

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

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

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

On 7/4/2025 1:14 PM, Richard Damon wrote:

On 7/4/25 10:43 AM, olcott wrote:

On 7/4/2025 8:23 AM, Richard Damon wrote:

On 7/4/25 8:50 AM, olcott wrote:

On 7/4/2025 2:35 AM, Mikko wrote:

On 2025-07-03 12:56:42 +0000, olcott said:
>

On 7/3/2025 3:57 AM, Mikko wrote:

On 2025-07-03 02:50:40 +0000, olcott said:
>

On 7/1/2025 11:37 AM, Mr Flibble wrote:

On Mon, 30 Jun 2025 21:12:48 -0400, Richard Damon wrote:
>

On 6/30/25 2:30 PM, Mr Flibble wrote:
>
PO just works off the lie that a correct simulation of the input is
different than the direct execution, even though he can't show the
instruction actually correctly simulated where they differ, and thus
proves he is lying.
>
The closest he comes is claiming that the simulation of the "Call HHH"
must be different when simulated then when executed, as for "some
reason" it must be just because otherwise HHH can't do the simulation.
>
Sorry, not being able to do something doesn't mean you get to redefine
it,
>
You ar4e just showing you are as stupid as he is.

>
No. A simulator does not have to run a simulation to completion if it can
determine that the input, A PROGRAM, never halts.
>
/Flibble

>
The most direct way to analyze this is that
HHH(DDD)==0 and HHH1(DDD)==1 are both correct
because DDD calls HHH(DDD) in recursive simulation and
DDD does not call HHH1(DDD) in recursive simulation.

>
Either "no" (encoded as 0) or "yes" (encoded as any other number) is the
wrong asnwer to the quesstion "does DDD specify a halting computation?".

>
That is *not* the actual question.

>
THe actual question is whatever someone asks.

>
What is the area of a square circle with a radius of 2?
>

However, if the question is
not "does DDD specify a halting computation?" or the same about some
other computation then it is not in the scope of the halting problem
or the termination problem.
>

>
The halting problem has always been flatly incorrect
by making that the question. So I am reframing the
question the same way that ZFC reframed Russell's Paradox.

>
Nope, just shows you are too stupid to understand it.
>

>
Then tell me where I go wrong on this explanation:
ZFC conquered Russell's Paradox by redefining how
sets are defined such that a set that is a member
of itself can no longer be defined.
>
"ZFC avoids this paradox by using axioms that restrict set formation."

>
And what does that distraction have to do with halting problem?
>

>
*Changing the definition of the problem is a way to solve it*
>

>
But you aren't allowed to do that.
>
Note, ZFC doesn't solve the problem of Russell's Paradox in Naive Set Theory, as it doesn't do anything to Naive Set Theory.
>

>
It replaced the erroneous naive set theory thus
conquering the misconception of Russell's Paradox.

>
Yes, by creating a totally new system.
>
Note, The don't say that Russell's Paradox no longer exists in Naive Set Theory, they
>

>
It proves that Russell's Paradox was always a misconception
anchored in incoherence.
>

>
No, it was anchored in the existing theory of the time.
>
It showed that the theory had a major problem that needed to be fixed, by finding a better system.
>
>

>
Likewise I am conquering the misconception that
partial halt deciders must report on the behavior
of directly executed Turing machines.
>

>
But you aren't making a totally new system, just lying about the existing system. In Computability Theory, reporting on the behavior of the direct execution of a Turing Machine is a valid operation. To say it isn't is just a lie.
>

>
The key correction that I am making to the halting problem
is the requirement that halt deciders report on the behavior
of a directly executed Turing machine when these have always
been outside of the domain of every Turing machine based decider.
>

>
But that isn't a "base" criteria in the system. That is like saying you are keeping standard addition, but you want 5 + 7 to be 57 instead of 12, as that doesn't make sense.
>
Your problem is you just don't understand how logic systems work at all, and thus you are trying to tackle a problem without knowing what you are doing.
>
Sort of like taking a car with a minor knocking probem, and trying to beat the engine with a big wrench.
>
If you want to change that criteria, you need to work on reformulating from the original axiom level.
>
Note, ZFC didn't just ban sets from containing themselves, but defined actual rules of how to build sets from previously created sets, with a notation that the set being created isn't part of the set of previously created sets. This RESULTS in the inability to define a set containing itself.
>
Thus, you need to do the same to achieve your results, the problem being that the idea that you can define what a "Halt Decider" would be is something that just comes out of the general principles of Computations.
>
The Halting of Computations is just a natural property of them.
>
Computations are encodable into finite strings (in a way that allows the full recreation of the behavior of that computation)
>
And thus, asking if the computation a will halt given a finite string representation of it just naturally follows.

>
All the Halting Problem proofs depend on the ability
of an *ACTUAL INPUT* to do the opposite of whatever its
decider decides and *THIS HAS ALWAYS BEEN IMPOSSIBLE*
>

>
No, they depend on the ability of being able to make a program that does the opposite of what the decider says when given a proper representation of that program.
>

 Yet no Turing machine decider can take an executing
Turing machine as an input thus not in the domain/scope of
any Turing machine decider. Halt deciders NEVER report
on the behavior of executing programs.
 

But it doesn't need to, it just needs the description of the algorithm of the machine and its input. Just like Turing Machines can't take "numbmers" as input, only representations of them.
The FUNCTION that is computed can, since that is just a mathematical entity, and so, to try to compute that function, it take the finite string representation of the input to the function, which is the detailed description of the algorithm and data.
All you are doing is proving your stupidity.
I guess that is your goal in life, to prove how stupid you are.