All fake rebuttals have been simply dismissing the verified facts
out-of-hand without showing any error. This is flat out dishonest.
That you really really don't believe what I am saying is no actual
rebuttal what-so-ever. Evaluating what I say using rhetoric instead of reasoning is deceitful.
We have these three verified facts:
(1) A halt decider must compute the mapping from its input to an accept reject state on the basis of the actual behavior specified by this input
(2) The ultimate measure of the behavior of the input to H(P,P) is the correct x86 emulation of the input to H(P,P) by H.
(3) P(P) specifies entirely different behavior than the correct x86
emulation of the input to H(P,P) by H. This is verified by the provably correct execution trace of each.
Therefore everyone that says that H must base its halt status decision
on the behavior of P(P) is conclusively proven wrong.
On 6/9/2022 4:55 AM, Mikko wrote:
On 2022-06-09 02:32:43 +0000, olcott said:
All fake rebuttals have been simply dismissing the verified facts
out-of-hand without showing any error. This is flat out dishonest.
That you really really don't believe what I am saying is no actual
rebuttal what-so-ever. Evaluating what I say using rhetoric instead
of reasoning is deceitful.
We have these three verified facts:
(1) A halt decider must compute the mapping from its input to an
accept reject state on the basis of the actual behavior specified by
this input
(2) The ultimate measure of the behavior of the input to H(P,P) is
the correct x86 emulation of the input to H(P,P) by H.
(3) P(P) specifies entirely different behavior than the correct x86
emulation of the input to H(P,P) by H. This is verified by the
provably correct execution trace of each.
Therefore everyone that says that H must base its halt status
decision on the behavior of P(P) is conclusively proven wrong.
It has been addressed more than sufficiently. If you think otherwise you
should read the responses again. If something remains unclear you may ask
specific questions.
Mikko
This is exactly the dishonest dodge prey that I expected.
All of the fake rebuttals were based on denying the verifiable facts.
On 2022-06-09 02:32:43 +0000, olcott said:
All fake rebuttals have been simply dismissing the verified facts
out-of-hand without showing any error. This is flat out dishonest.
That you really really don't believe what I am saying is no actual
rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
reasoning is deceitful.
We have these three verified facts:
(1) A halt decider must compute the mapping from its input to an
accept reject state on the basis of the actual behavior specified by
this input
(2) The ultimate measure of the behavior of the input to H(P,P) is the
correct x86 emulation of the input to H(P,P) by H.
(3) P(P) specifies entirely different behavior than the correct x86
emulation of the input to H(P,P) by H. This is verified by the
provably correct execution trace of each.
Therefore everyone that says that H must base its halt status decision
on the behavior of P(P) is conclusively proven wrong.
It has been addressed more than sufficiently. If you think otherwise you should read the responses again. If something remains unclear you may ask specific questions.
Mikko
On 6/8/22 10:32 PM, olcott wrote:
All fake rebuttals have been simply dismissing the verified facts
out-of-hand without showing any error. This is flat out dishonest.
That you really really don't believe what I am saying is no actual
rebuttal what-so-ever. Evaluating what I say using rhetoric instead of
reasoning is deceitful.
We have these three verified facts:
(1) A halt decider must compute the mapping from its input to an
accept reject state on the basis of the actual behavior specified by
this input
And actual behavior of the input to a Halt decider, since it is a representation of a computation, is what that computation does.
(2) The ultimate measure of the behavior of the input to H(P,P) is the
correct x86 emulation of the input to H(P,P) by H.
And correct emulation is defined by what that input would do if atually
Run, so the corrct emulation of the input to H(P,P) would be P(P).
(3) P(P) specifies entirely different behavior than the correct x86
emulation of the input to H(P,P) by H. This is verified by the
provably correct execution trace of each.
Nope, doen't see where you get this. Read my responce to the previous statement.
Please point out where they differ, and WHY they differ if one is a
CORRECT emulation of the other, and are based on the exact same code.
I think the key point is that you refuse to correctly emulate the call H instruction, because you don't quite understand the meaning of what a
program is, or what correct emulation means.
Therefore everyone that says that H must base its halt status decision
on the behavior of P(P) is conclusively proven wrong.
Nope, until you can figure out how to exp[alin that last one, you are
proven to be a LIAR.
You like to make *claims* that things are obvious, when they are not
actually true. This is a sign that you don't really understand how
things actually work and are inserting your own misconceptions and
ignoring the actual behaviors.
On 6/9/2022 5:52 AM, Richard Damon wrote:
On 6/8/22 10:32 PM, olcott wrote:
All fake rebuttals have been simply dismissing the verified facts
out-of-hand without showing any error. This is flat out dishonest.
That you really really don't believe what I am saying is no actual
rebuttal what-so-ever. Evaluating what I say using rhetoric instead
of reasoning is deceitful.
We have these three verified facts:
(1) A halt decider must compute the mapping from its input to an
accept reject state on the basis of the actual behavior specified by
this input
And actual behavior of the input to a Halt decider, since it is a
representation of a computation, is what that computation does.
Computer science textbooks may say this, software engineering does not
agree. The input to a software function is a specific byte string.
(2) The ultimate measure of the behavior of the input to H(P,P) is
the correct x86 emulation of the input to H(P,P) by H.
And correct emulation is defined by what that input would do if
atually Run, so the corrct emulation of the input to H(P,P) would be
P(P).
In software engineering the behavior of the input finite string of
machine code is correctly determined by its correct x86 emulation by H.
(3) P(P) specifies entirely different behavior than the correct x86
emulation of the input to H(P,P) by H. This is verified by the
provably correct execution trace of each.
Nope, doen't see where you get this. Read my responce to the previous
statement.
Please point out where they differ, and WHY they differ if one is a
CORRECT emulation of the other, and are based on the exact same code.
I have done this several times you are simply not bright enough to
understand the execution traces.
I think the key point is that you refuse to correctly emulate the call
H instruction, because you don't quite understand the meaning of what
a program is, or what correct emulation means.
When we have proof that H(P,P) derives this sequence
// H emulates the first seven instructions of P ...[00001352][0021233e][00212342] 55 push ebp // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp ...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08] ...[00001358][0021233a][00001352] 50 push eax // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08] ...[0000135c][00212336][00001352] 51 push ecx // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
Then people that are not dumber than a box of rocks would know that line seven above would repeat this sequence.
Therefore everyone that says that H must base its halt status
decision on the behavior of P(P) is conclusively proven wrong.
Nope, until you can figure out how to exp[alin that last one, you are
proven to be a LIAR.
I have done this several times and you are simply not bright enough to understand the execution traces.
You like to make *claims* that things are obvious, when they are not
actually true. This is a sign that you don't really understand how
things actually work and are inserting your own misconceptions and
ignoring the actual behaviors.
You are too stupid to understand that a partial x86 emulation of an
input does correctly predict that a complete emulation would never halt.
This makes you too stupid to understand what I am saying.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 297 |
Nodes: | 16 (0 / 16) |
Uptime: | 123:04:25 |
Calls: | 6,662 |
Files: | 12,212 |
Messages: | 5,334,693 |