Liste des Groupes | Revenir à s logic |
On 4/26/2024 7:26 PM, Richard Damon wrote:But that doesn't make H answer the question.On 4/26/24 8:02 PM, olcott wrote:That is another much less useful way to make a universally correctOn 4/26/2024 12:05 PM, olcott wrote:>On 4/26/2024 11:19 AM, Richard Damon wrote:>On 4/26/24 11:34 AM, olcott wrote:>On 4/26/2024 3:32 AM, Mikko wrote:>On 2024-04-25 14:15:20 +0000, olcott said:>01 int D(ptr x) // ptr is pointer to int function>
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 D(D);
12 }
>
That H(D,D) must report on the behavior of its caller is the
one that is incorrect.
What H(D,D) must report is independet of what procedure (if any)
calls it.
>
Thus when H(D,D) correctly reports that its input D(D) cannot possibly
reach its own line 6 and halt no matter what H does then H can abort its
input and report that its input D(D) does not halt.
But since the program D(D) DOES reach its own line 6 when run, because H aborts its simulation and return 0 (since that is what you say this H will do), your statement is PROVEN TO BE A LIE, and you "logic" just a collection of contradictions.
>
D simulated by H cannot possibly reach its own line 06 thus when we do
not use the strawman deception to refer to a different D then we know
that D simulated by H never halts.
>>>>
The fact that the D(D) executed in main does halt is none of H's
business because H is not allowed to report on the behavior of its
caller.
>
In other words, H doesn't need to report on the Behavior of the Program described by its input because it isn't actually a Halt Decider, because you are just a LIAR.
>
>
Anyone knowing the theory of computation knows that H is not allowed to
report on the behavior of its caller.
>
In computability theory and computational complexity theory, an
undecidable problem is a decision problem for which it is proved to be
impossible to construct an algorithm that always leads to a correct yes-
or-no answer. https://en.wikipedia.org/wiki/Undecidable_problem
>
The behavior of the simulated D(D) before H aborts its simulation is
different than the behavior of the executed D(D) after H has aborted
its simulation.
>
Every time that a simulated input would never stop running unless
aborted the simulating termination analyzer must abort this simulation
to prevent its own infinite execution.
>
H(D,D) is a case of this H1(D,D) is not a case of this even though
the only difference between H and H1 is that D calls H and D does
not call H1.
>
D simulated by H would never stop running unless aborted and cannot
possibly reach its own line 06 and halt no matter what H does.
>
Thus whenever we do not use the strawman deception to refer to a
different D we know that D simulated by H specifies a non-halting
sequence of configurations to H.
>
*This might be a more succinct way of summing that up*
When you understand that D simulated by H cannot possibly reach past its own line 03 (thus cannot possibly halt) no matter what H does and
But since H does whatever H does, if H aborts and returns 0, the the direct execution of D, which is what actually matters, DOES get to that point.
>
termination analyzer:
int H(ptr x, ptr y)
{
printf("The input program does whatever it does!\n");
return 777; // code for it does what it does
}
It can be verified through ordinary software engineering that D(D)Yes, but that is just a lying RED HERRING, as the question isn't about what H's simulation of the input does, but what the program the input actually represents does when run.
simulated H cannot possibly reach past its own line 03.
It can be verified through computer science that this means that D(D) simulated H by never reaches its own final state and halts whetherWhich, since this H DOES abort its simulation is trying to introduce a red herring.
H aborts its simulation or not.
This means that D(D) simulated by H unequivocally DOES NOT HALT!Nope, prove you to be a stupid liar.
Universally everyone wants to use the strawman deception at thisBut D(D) simulated by H IS THE STRAWMAN as the question is about the execution of the actual program describe by the input (which needs to FULLY describe the input, and thus includes the H it calls).
point and refer to something else besides D(D) simulated by H.
Even these people might agree that D(D) simulated by H DOES NOT HALT.
Right, but that isn't the quest>Ah so you know the computer science of this, that is great!>>
you understand that it is incorrect for H to report on the behavior of its caller: void main() { D(D); } then this necessitates
But it MUST report on the program described to it, which is a call to D(D), and it doesn't matter if that is what calls H.
>
So, your claim is just a STUPID LIE.
>
Yes, you can't ask "What is the behavior of the program that called you?"
>
So, how does the input "D,D" mean "The program that called you"?But you CAN ask what is the behavior of M(d) even if M(d) happens to call you.So you don't totally understand the computer science of this.
>
It is always flat out incorrect for any computable function toREFERENCE?
ever report on the behavior of its caller or even the behavior
of itself. The theory of computation DOES NOT ALLOW THAT!
H(D,D) has different behavior than H1(D,D) even though the onlyDIFFERENT PROGRAMS ARE DIFFERENT
difference between H and H1 is that D calls H and does not call H1.
Original Linz Turing Machine HRight, embedded_H, to meet the requirements, must go to H^.qy if H^(M) will halt.
H.q0 ⟨M⟩ w ⊢* H.qy // M applied to w halts
H.q0 ⟨M⟩ w ⊢* Hqn // M applied to w does not halt
Linz Turing Machine Ĥ
Ĥ.q0 ⟨M⟩ ⊢* embedded_H ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨M⟩ ⊢* embedded_H ⟨M⟩ ⟨M⟩ ⊢* Ĥ.qn
This exact same reasoning applies to
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ relative to Linz H ⟨Ĥ⟩ ⟨Ĥ⟩
Sure I have, many times and you ignore it because you are too stupid and lack the understanding of the fundamenals.You are just proving you total lack of understand of the nature of the problem.You can't show any error in my actual reasoning the best that
>
you can show is the conventional wisdom arrives at different
conclusions through different assumptions.
WRONG QUESTION so a STRAWMAN.If D simulated by H is unequivocally non-halting and we are>>
H can abort its simulation of D and correctly report that D specifies a non-halting sequence of configurations.
>
Nope, it CAN'T correctly say that a program that will halt when run is none halting.
>
only reporting on the behavior of D simulated by H then I am
definitely correct.
If H is actually required to report on the behavior of itsH is required to report on the behavior of the program whose description it was given (agree or admit you are just a liar).
caller then I am incorrect.
Nope, I am not making "Assumptions", but following the rules of the field, which you just don't understand.Your claiming it can just proves that you are just a STUPID LIAR.No it proves that you have different assumptions and we are
>
both correct on the basis of our different assumptions.
No, it shows that you ARE lying, as there are no "assumptions" that need to be made here.You seem to believe it is correct to give wrong answer, but I suppose that should be expected from someone who doesn't understand the basic nature of truth and who has been shown to be a pathological liar.That I have different assumptions than you is no evidence that
>
either of us are lying.
WHy? you being wrong ios just you being wrong.You have probabably doomed to oblivian any piece of your ideas that might have some usefulness by the taint of your illogical stupidity that you have been spewing.I would be interested in seeing what Mike has to say about this.
Les messages affichés proviennent d'usenet.