On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination analyser can
be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof
you've got your work cut out to persuade anyone to listen, not least
because anyone who tries to enter into a dialogue with you is met with
contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
int sum(int x, int y) { return x + y; }
sum(3,2) == 5 even if God and all his angels say it == 7.
Likewise for the actual behavior of the input to HHH(DD)
when measured by the actual semantics of the x86 language
that includes XXX simulating itself simulating DD.
The direct execution of DD DOES NOT FREAKING HAVE DD
INVOKING ITS OWN EMULATOR STUPID !!!
The behavior is different because of this STUPID !!!
Initially I could not see how anyone could possibly be
be this stupid so I called many people despicable lying bass turds.
I am still doubting that people can actually be this stupid.
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question.
The question is whether a universal termination analyser can be
constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof
you've got your work cut out to persuade anyone to listen, not least
because anyone who tries to enter into a dialogue with you is met with
contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
On 4/28/2025 4:01 AM, Mikko wrote:Just like the direct execution.
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
It must do this by applying the finite string transformation rules*corresponding output to the input*sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO GET AWAY FOR
CLAIMING THIS USING THE STRAW DECEPTION INTENTIONALLY INCORRECT
PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination analyser
can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof
you've got your work cut out to persuade anyone to listen, not least
because anyone who tries to enter into a dialogue with you is met
with contempt and scorn.
The proof stands.
Not freaking allowed to look at any damn thing else besides the
freaking input. Must compute whatever mapping ACTUALLY EXISTS FROM
THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is
required to compute one specific mapping: to "no" if the computation
described by the input can be continesd forever without halting, to
"no" otherwise.
specified by the x86 language to the input to HHH(DD).
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD. It DOES
DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE EMULATION OF
HHH EMULATING ITSELF EMULATING DD.
On 4/28/2025 11:01 AM, dbush wrote:
On 4/28/2025 11:52 AM, olcott wrote:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination analyser >>>>>> can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof >>>>>> you've got your work cut out to persuade anyone to listen, not
least because anyone who tries to enter into a dialogue with you
is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is
required to compute one specific mapping: to "no" if the computation
described by the input can be continesd forever without halting, to
"no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
In other words, no H exists that satisfies the following requirements,
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
...
Flibble and I did not solve the Halting Problem
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination analyser
can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof
you've got your work cut out to persuade anyone to listen, not least
because anyone who tries to enter into a dialogue with you is met
with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is
required to compute one specific mapping: to "no" if the computation
described by the input can be continesd forever without halting, to
"no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).'
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question. >>>> The question is whether a universal termination analyser can be
constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof
you've got your work cut out to persuade anyone to listen, not least
because anyone who tries to enter into a dialogue with you is met with >>>> contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is
required to compute one specific mapping: to "no" if the computation
described by the input can be continesd forever without halting, to
"no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
On 4/28/2025 11:01 AM, dbush wrote:
On 4/28/2025 11:52 AM, olcott wrote:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question. >>>>>> The question is whether a universal termination analyser can be
constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof >>>>>> you've got your work cut out to persuade anyone to listen, not least >>>>>> because anyone who tries to enter into a dialogue with you is met with >>>>>> contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is
required to compute one specific mapping: to "no" if the computation
described by the input can be continesd forever without halting, to
"no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
In other words, no H exists that satisfies the following requirements,
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
BECAUSE THOSE REQUIREMENTS HAVE ALWAYS BEEN WRONG AND NO ONE NOTICED.
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question. >>>>>> The question is whether a universal termination analyser can be
constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof >>>>>> you've got your work cut out to persuade anyone to listen, not least >>>>>> because anyone who tries to enter into a dialogue with you is met with >>>>>> contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is
required to compute one specific mapping: to "no" if the computation
described by the input can be continesd forever without halting, to
"no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A computation >> either halts or not. A halt decider must just tell whether the somputation >> halts. It is true that no Turing machine can determine this about every
computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Dreams are no substitute for logic.
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination
analyser can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the
proof you've got your work cut out to persuade anyone to listen, >>>>>>>> not least because anyone who tries to enter into a dialogue with >>>>>>>> you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>> required to compute one specific mapping: to "no" if the computation >>>>>> described by the input can be continesd forever without halting, to >>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite
string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A
computation
either halts or not. A halt decider must just tell whether the
somputation
halts. It is true that no Turing machine can determine this about every >>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
HHH cannot possibly return to any DD correctly
emulated by HHH.
On 5/2/2025 4:03 AM, Mikko wrote:What you do not understand is that your aborting HHH does not do a
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination
analyser can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the
proof you've got your work cut out to persuade anyone to listen, >>>>>>>> not least because anyone who tries to enter into a dialogue with >>>>>>>> you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>> required to compute one specific mapping: to "no" if the computation >>>>>> described by the input can be continesd forever without halting, to >>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite
string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A
computation
either halts or not. A halt decider must just tell whether the
somputation
halts. It is true that no Turing machine can determine this about every >>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
When DD is correctly simulated by HHH it is impossible
for any HHH to return to any emulated DD.
This is only ordinary computer programming that no
one here seems to understand.
It HHH never returns it is not a halt
decider and therefore is not a counter-example to the proof. If it
returns it returns the wrong answer and therefore is not a counter-
example to the proof.
On 03/05/2025 07:31, Fred. Zwarts wrote:
Dreams are no substitute for logic.
But to be fair, logic is no substitute for dreams.
It's a matter of horses for courses. Where undecidability is concerned,
it appears that Mr Olcott is riding in a different race to the rest of us.
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question.
The question is whether a universal termination analyser can be >>>>>>>> constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof >>>>>>>> you've got your work cut out to persuade anyone to listen, not least >>>>>>>> because anyone who tries to enter into a dialogue with you is met with >>>>>>>> contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>> required to compute one specific mapping: to "no" if the computation >>>>>> described by the input can be continesd forever without halting, to >>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite string >>>> operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A computation
either halts or not. A halt decider must just tell whether the somputation >>>> halts. It is true that no Turing machine can determine this about every >>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
HHH cannot possibly return to any DD correctly
emulated by HHH.
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question.
The question is whether a universal termination analyser can be >>>>>>>> constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof >>>>>>>> you've got your work cut out to persuade anyone to listen, not least >>>>>>>> because anyone who tries to enter into a dialogue with you is met with >>>>>>>> contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>> required to compute one specific mapping: to "no" if the computation >>>>>> described by the input can be continesd forever without halting, to >>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite string >>>> operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A computation
either halts or not. A halt decider must just tell whether the somputation >>>> halts. It is true that no Turing machine can determine this about every >>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
When DD is correctly simulated by HHH it is impossible
for any HHH to return to any emulated DD.
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination
analyser can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the
proof you've got your work cut out to persuade anyone to listen, >>>>>>>> not least because anyone who tries to enter into a dialogue with >>>>>>>> you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>> required to compute one specific mapping: to "no" if the computation >>>>>> described by the input can be continesd forever without halting, to >>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite
string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A
computation
either halts or not. A halt decider must just tell whether the
somputation
halts. It is true that no Turing machine can determine this about every >>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
HHH cannot possibly return to any DD correctly
emulated by HHH.
It HHH never returns it is not a halt
decider and therefore is not a counter-example to the proof. If it
returns it returns the wrong answer and therefore is not a counter-
example to the proof.
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the
question. The question is whether a universal termination
analyser can be constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the
proof you've got your work cut out to persuade anyone to listen, >>>>>>>> not least because anyone who tries to enter into a dialogue with >>>>>>>> you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>> required to compute one specific mapping: to "no" if the computation >>>>>> described by the input can be continesd forever without halting, to >>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite
string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A
computation
either halts or not. A halt decider must just tell whether the
somputation
halts. It is true that no Turing machine can determine this about every >>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE
EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
When DD is correctly simulated by HHH it is impossible
for any HHH to return to any emulated DD.
This is only ordinary computer programming that no
one here seems to understand.
It HHH never returns it is not a halt
decider and therefore is not a counter-example to the proof. If it
returns it returns the wrong answer and therefore is not a counter-
example to the proof.
On 5/3/2025 2:50 AM, Mikko wrote:
On 2025-05-03 01:14:10 +0000, olcott said:
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the >>>>>>>>>> question. The question is whether a universal termination
analyser can be constructed, and the answer is that it can't. >>>>>>>>>>
This has been rigorously proved. If you want to overturn the >>>>>>>>>> proof you've got your work cut out to persuade anyone to
listen, not least because anyone who tries to enter into a >>>>>>>>>> dialogue with you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. >>>>>>>> It is
required to compute one specific mapping: to "no" if the
computation
described by the input can be continesd forever without halting, to >>>>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite >>>>>> string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A
computation
either halts or not. A halt decider must just tell whether the
somputation
halts. It is true that no Turing machine can determine this about
every
computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE >>>>>>> EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not
fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE. >>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
When DD is correctly simulated by HHH it is impossible
for any HHH to return to any emulated DD.
That HHH fails to emulate DD to the first "if" does not mean that
the excution of DD does not reach that "if".
When DD is emulated by HHH according to the rules
of the x86 language then the emulated DD cannot
possibly reach its own emulated final halt state.
That you don't have a clue about the x86 language
and still say that I am wrong is a reckless disregard
for the truth.
It only means that
HHH incorrectly interpretes a call to HHH to mean a call to a
non-terminating non-decider.
On 5/3/2025 2:55 AM, Mikko wrote:
On 2025-05-03 04:14:27 +0000, olcott said:
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the >>>>>>>>>> question. The question is whether a universal termination
analyser can be constructed, and the answer is that it can't. >>>>>>>>>>
This has been rigorously proved. If you want to overturn the >>>>>>>>>> proof you've got your work cut out to persuade anyone to
listen, not least because anyone who tries to enter into a >>>>>>>>>> dialogue with you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. >>>>>>>> It is
required to compute one specific mapping: to "no" if the
computation
described by the input can be continesd forever without halting, to >>>>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite >>>>>> string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A
computation
either halts or not. A halt decider must just tell whether the
somputation
halts. It is true that no Turing machine can determine this about
every
computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE >>>>>>> EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not
fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE. >>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
HHH cannot possibly return to any DD correctly
emulated by HHH.
In that case what I said is true. Another way to say the same is that
if you can determine that the above DD does not execute the "if" line
you can infer that HHH(DD) does not return and therefore HHH is not a
halt decider (nor any other decder).
That would be true IFF (if and only if) the directly
executed HHH did not see that DD has caused its emulated
self to get stuck in recursive emulation.
HHH(DD) does see this and rejects its input on that basis.
On 5/3/2025 2:50 AM, Mikko wrote:
On 2025-05-03 01:14:10 +0000, olcott said:
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION
INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not the question.
The question is whether a universal termination analyser can be >>>>>>>>>> constructed, and the answer is that it can't.
This has been rigorously proved. If you want to overturn the proof >>>>>>>>>> you've got your work cut out to persuade anyone to listen, not least >>>>>>>>>> because anyone who tries to enter into a dialogue with you is met with
contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever" mapping. It is >>>>>>>> required to compute one specific mapping: to "no" if the computation >>>>>>>> described by the input can be continesd forever without halting, to >>>>>>>> "no" otherwise.
It must do this by applying the finite string transformation
rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain finite string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD.
Whether the execution is "direct" or otherwise is irrelevant. A computation
either halts or not. A halt decider must just tell whether the somputation
halts. It is true that no Turing machine can determine this about every >>>>>> computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE >>>>>>> EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not fatal. >>>>
The contradictory part of the "impossible" input IS NEVER REACHABLE. >>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
When DD is correctly simulated by HHH it is impossible
for any HHH to return to any emulated DD.
That HHH fails to emulate DD to the first "if" does not mean that
the excution of DD does not reach that "if".
When DD is emulated by HHH according to the rules
of the x86 language then the emulated DD cannot
possibly reach its own emulated final halt state.
That you don't have a clue about the x86 language
and still say that I am wrong is a reckless disregard
for the truth.
On 5/4/2025 7:23 PM, Richard Damon wrote:
On 5/4/25 1:50 PM, olcott wrote:
On 5/3/2025 2:50 AM, Mikko wrote:
On 2025-05-03 01:14:10 +0000, olcott said:
On 5/2/2025 4:03 AM, Mikko wrote:
On 2025-04-30 15:28:33 +0000, olcott said:
On 4/29/2025 4:49 AM, Mikko wrote:
On 2025-04-28 15:52:13 +0000, olcott said:
On 4/28/2025 4:01 AM, Mikko wrote:
On 2025-04-16 17:36:31 +0000, olcott said:
On 4/16/2025 7:29 AM, Richard Heathfield wrote:
On 16/04/2025 12:40, olcott wrote:
sum(3,2) IS NOT THE SAME AS sum(5,2).
IT IS EITHER STUPID OR DISHONEST FOR YOU TO TRY TO
GET AWAY FOR CLAIMING THIS USING THE STRAW DECEPTION >>>>>>>>>>>>> INTENTIONALLY INCORRECT PARAPHRASE OF MY WORDS.
Whether sum(3,2) is or is not the same as sum(5,2) is not >>>>>>>>>>>> the question. The question is whether a universal
termination analyser can be constructed, and the answer is >>>>>>>>>>>> that it can't.
This has been rigorously proved. If you want to overturn the >>>>>>>>>>>> proof you've got your work cut out to persuade anyone to >>>>>>>>>>>> listen, not least because anyone who tries to enter into a >>>>>>>>>>>> dialogue with you is met with contempt and scorn.
The proof stands.
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
*corresponding output to the input*
Not freaking allowed to look at any damn thing
else besides the freaking input. Must compute whatever
mapping ACTUALLY EXISTS FROM THIS INPUT.
A halt decider is is not allowed to compute "whatever"
mapping. It is
required to compute one specific mapping: to "no" if the
computation
described by the input can be continesd forever without
halting, to
"no" otherwise.
It must do this by applying the finite string transformation >>>>>>>>> rules specified by the x86 language to the input to HHH(DD).
No, it needn't. A halt decider cannot do other than certain
finite string
operations. No relation to x86 language is required.
This DOES NOT DERIVE THE BEHAVIOR OF THE DIRECTLY EXECUTED DD. >>>>>>>>Whether the execution is "direct" or otherwise is irrelevant. A >>>>>>>> computation
either halts or not. A halt decider must just tell whether the >>>>>>>> somputation
halts. It is true that no Turing machine can determine this
about every
computation, i.e., no Turing machine is a halt decider.
It DOES DERIVE DD EMULATED BY HHH AND ALSO DERIVES THE RECURSIVE >>>>>>>>> EMULATION OF HHH EMULATING ITSELF EMULATING DD.
Which are not mentioned in the halting problem.
When understand rather than simply ignore the HHH/DD
example it can be seen that every conventional halting
problem proof suffers the same fate.
That you (or some other people) don't understand the proof is not
fatal.
The contradictory part of the "impossible" input IS NEVER REACHABLE. >>>>>>>
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
It is unless HHH never returns.
When DD is correctly simulated by HHH it is impossible
for any HHH to return to any emulated DD.
That HHH fails to emulate DD to the first "if" does not mean that
the excution of DD does not reach that "if".
When DD is emulated by HHH according to the rules
of the x86 language then the emulated DD cannot
possibly reach its own emulated final halt state.
But HHH doesn't correct emulated DD by those rules, as those rules do
not allow HHH to stop its emulation,
Sure they do you freaking moron...
If I say that I can count I don't need
to count to infinity to prove it dipshit.
What they DON'T ALLOW is skipping
over the "call" instruction and jumping
to the "ret" instruction.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 493 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 34:57:58 |
| Calls: | 9,740 |
| Files: | 13,741 |
| Messages: | 6,183,425 |