Re: The philosophy of computation reformulates existing ideas on a new basis --- INFALLIBLY CORRECT REASONING

On 11/7/2024 9:10 PM, Richard Damon wrote:

On 11/7/24 11:39 AM, olcott wrote:

On 11/7/2024 3:56 AM, Mikko wrote:

On 2024-11-06 15:26:06 +0000, olcott said:
>

On 11/6/2024 8:39 AM, Mikko wrote:

On 2024-11-05 13:18:43 +0000, olcott said:
>

On 11/5/2024 3:01 AM, Mikko wrote:

On 2024-11-03 15:13:56 +0000, olcott said:
>

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.

>
The halting probelm requires that every halt decider terminates.
If HHH(DDD) terminates so does DDD. The halting problmen requires
that if DDD terminates then HHH(DDD) accepts as halting.

>
void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}
>
No that is false.
The measure is whether a C function can possibly
reach its "return" instruction final state.

>
Not in the original problem but the question whether a particular strictly
C function will ever reach its return instruction is equally hard. About

>
It has always been about whether or not a finite string input
specifies a computation that reaches its final state.

>
Not really. The original problem was not a halting problem but Turing's

>
Exactly. The actual Halting Problem was called that by Davis
in 1952. Not the same as Turing proof.
>
*So we are back to The Halting Problem itself*
>
has always been about whether or not a finite string input
specifies a computation that reaches its final state.
>

 No, it has always been about trying to make a computation that given a finite string representation of a program and input, decide if the program will halt on that input.
 

It has never ever been about anything other than the actual
behavior that this finite string specifies. You are not stupid
or ignorant about this your knowledge and intelligence has
seemed pretty good. What you and others are is indoctrinated.

It should be noted that the problem STARTS with a program, which gets represented with a finite string,

No that it incorrect. It never starts with a program. A TM
cannot handle another TM as its input. It starts with an
encoding that has associated semantics.

and that string might be different for different deciders, as the problem doesn't define a specific encoding method.
 Your insistance that the problem starts with a finite-string just shows your ignorance.
 

It is much dumber to think that a TM takes another actual
TM as input. It is common knowledge that this is not the case.

Try to show a reliable source that defines it as the string is the DEFINITION of what is being asked about, as opposed to being a representation of the program being asked about.
 

It is the semantics that the string specifies that is being
asked about.

Go ahead, TRY to do it.
 

DDD specifies a non-halting computation to HHH because
DDD calls HHH in recursive simulation.

 No, because the HHH that DDD calls is programmed to break that recursive simulation, and thus make the results finite.
 

Now you are back to stupidly saying that DDD emulated by
HHH reaches its final halt state because it is aborted.
You are not stupid (you are smart) and you are not ignorant.
You know that DDD emulated by HHH cannot possibly reach
its own final state (whether HHH ever aborts or not) and
seem to believe that this is irrelevant.

If you change HHH to not abort, then DDD does become non-halting, but

The infinite set of each HHH that emulates DDD (that aborts
at some point or not) is not above your educational or
intellectual capacity.

HHH doesn't give the right answer. That is a DIFFERENT HHH, and thus a DIFFERENT DDD (as DDD to be a program includes ALL the code it uses, so it includes the code of HHH, which you changed)
 

*We are not even talking about HHH giving the right answer yet*
(a) DDD emulated by every HHH that aborts at some point
     or not never reaches its final state.
*THEN FROM THIS WE DEDUCE*
(b) This means that the right answer would be that DDD emulated
     by HHH does not halt.
*THEN FROM THIS WE DEDUCE*
(c) If HHH rejects DDD as non halting then HHH is correct.
*Those are all verified facts*
(d) Can any HHH compute the mapping from its input DDD to
     the actual behavior that DDD specifies as a pure function
     of its inputs *IS THE ONLY ACTUAL REMAINING UNRESOLVED ISSUE*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer