On 11/7/24 10:54 PM, olcott wrote:
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.
But it always has been. From your favorite source, the Halting problem is stated as:
In computability theory, the halting problem is the problem of determining, from a description of an arbitrary computer program and an input, whether the program will finish running, or continue to run forever.
Note the behavior that is to decided on: "whether the program will finish running, or continue to run forever".
The description is just to point to the program.
The "behavior" of that string is what the program it represents does.
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.
Right, TM's can't take a TM as in input, but the "Halting Function" can.
Like most problems a TM solves, the "input" of the problem is converted and represented with a finite string, but the MEANING (i.e. the semantics) of that input is the thing we started with, in this case, is the program.
The "associated semantics" of the string given to HHH, is the PROGRAM DDD that it is supposed to represent.
Since yours doesn't, since it doesn't fully define the program, you just started with an error.
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.
And it is elementary knowledge (which seems to be beyond you) that the string given to it is just a representation of the program that it is supposed to try to determine the behavior of,
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.
Which is the PROGRAM it represents, and the behavior of that is the behavior of the PROGRAM.
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.
No, it reaches its final halt state because it does. It does because you have shown that behavior of the unspecified HHH that it calls is to return, and thus
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.
The DDD, that HHH emulates, does reach the end. You are just too stupid to understand that.
The emulation of DDD by HHH doesn't make it there, but that doesn't demonstrate to property of "cannot posssibly reach ..." for the program described by the finite string, because that is not a type of property that a partial emulation can demonstrate.
Your statement has an equivocation because it tries to confuse these two possible meanings.
The fact that the input, as stated, isn't the description of a program acutally means neither can be the actual meaning until you include HHH as part of the description of DDD given to the decider.
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.
And the fact that in infinite set of programs in not a program seems to be the fantasy of your lack of education.
DDD, to be the target of a program decision problem must be a full program, and thus it must include the HHH that it calls.
That means the infinte set of HHH, create an infinte set of DDDs to decide on.
This set can be divided into two classes:
Class 1: Where that HHH returns the non-halting answer, where we can show that because of that action, EVERY DDD made by such an HHH will halt, and thus HHH is just in error to say it doesn't.
Class 2: Where that HHH doesn't ever abort its emulation, where while we can show that because of that action, none of the DDD made by such an HHH will halt, none of the HHH will ever report this, but just fail to be a decider.
Thus, in your infinite set of HHH, none give the right answer about the DDD that is built on it, but that is the only DDD that it has been given, so your infinite set is full of WRONG deciders.
Your LYING logic tries to give an HHH in class 1, and DDD that was based on a DIFFERENT HHH (which it isn't, so that is just a LIE) that was in class 2.
What this proves is that you ar fundaentally ignorant of the definitions of the system you are in.
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.
And we get the two cases
*THEN FROM THIS WE DEDUCE*
(b) This means that the right answer would be that DDD emulated
by HHH does not halt.
Nope. We get that you don't understand the question you state, because you are caught in your own equivocation.
The DDD that is emulated by HHH halts if HHH answers.
The emulation of DDD by HHH doesn't show "does not halt" because a partial emulation doesn't define that behavior, and thus makes your statement just non-sense.
*THEN FROM THIS WE DEDUCE*
(c) If HHH rejects DDD as non halting then HHH is correct.
*Those are all verified facts*
Nope, because if HHH rejects DDD an non-halting, then the semantic meaning of DDD reaching a final state is not determined by the emulation done by HHH, so your arguement is just proven to be invalid, and you just a stupid liar.
(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*
Since the "Actual behavior that DDD specifies" would be based on the COMPLETE emulation of the program that it specifies, and that program first, needs all of its code, so your input is inadequite, and thus you "question" becomes the equivalent of:
What is the sum of one and?
WHen we include that code as the obvious fix, then we notice that any HHH that answer, means that it didn't do a complete emulation, and thus the question as you are trying to make it mean is non-sense, like what color is 1 + 2, or trying to say that
1/2 + 1/4 + 1/8 + ... + 1/(2^n) + ...
is 7/8s because you are allowed to shorten the operation that is defined.
The *ONLY* meanings that can be used for the semantic property is the behavior of the program the input described is the COMPLETE execution/emulation of that input, which isn't what HHH does if it answers, and thus its SUBJECTIVE idea of the behavior doesn't define the OBJECTIVE property that must be the focus of the question.
You are just showing you have a funny-mental problem with regards to logic, and computation, as you do not understand the basics, and seem to just naturally reject the facts about them, because you are so brainwashed (by yourself) about them.
Sorry, but that is the facts, whether you want to agree to them or not, all your arguments are doing is proving how ignorant AND stupid you are.
The philosophy of computation reformulates existing ideas on a new basis ---
Re: The philosophy of computation reformulates existing ideas on a new basis ---