| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 23 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:44:39 |
| Calls: | 583 |
| Files: | 1,139 |
| D/L today: |
179 files (27,921K bytes) |
| Messages: | 111,801 |
On 7/23/2025 6:14 AM, Richard Damon wrote:
On 7/23/25 12:11 AM, olcott wrote:
On 7/22/2025 9:24 PM, Richard Damon wrote:
On 7/22/25 11:39 AM, olcott wrote:
On 7/22/2025 6:29 AM, Richard Damon wrote:
On 7/21/25 11:46 PM, olcott wrote:
On 7/21/2025 5:56 PM, Richard Damon wrote:
On 7/21/25 5:49 PM, olcott wrote:
On 7/21/2025 3:58 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/21/2025 10:52 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/21/2025 9:40 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/21/2025 4:06 AM, Mikko wrote:
On 2025-07-20 11:48:37 +0000, Mr Flibble said:
[ .... ]On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote: >>>>>>>>>>
Your problem is you don't understand the meaning of >>>>>>>>>>>>>>>>>> the words you are
using.
This is an ad hominem attack, not argumentation.
It is also honest and truthful, which is not as common >>>>>>>>>>>>>>>> as it should.
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
What you call "verified facts" are generally nothing of >>>>>>>>>>>>>> the kind. They
are merely things, often false, you would like to be true. >>>>>>>>>>
*One key example of a denied verified fact is when Joes said* >>>>>>>>>>
On 7/18/2025 3:49 AM, joes wrote:
very obvious that HHH cannot simulate
DDD past the call to HHH.
Joes is quite right, here, as has been said to you many >>>>>>>>>>>> times over by
several people.
HHH(DDD) does emulate itself emulating DDD
You will have a get out clause from the vagueness of your >>>>>>>>>>>> language, which
could be construed to mean practically anything.
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
-a-a HHH(DDD);
-a-a return;
}
int main()
{
-a-a HHH(DDD);
}
Not at all. HHH does emulate the x86 machine code
of DDD pointed to by P. That is does this according
to the semantics of the x86 language conclusively
proves that this emulation is correct.
That's nauseatingly overstretching things into another lie. >>>>>>>>>> Whatever HHH
might do is far short of sufficient "conclusively to prove" >>>>>>>>>> that the
emulation is correct.-a To prove that is likely impossible in >>>>>>>>>> principle,
that's even assuming you could define "correct" coherently. >>>>>>>>>>
[00002192] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000-a-a-a-a push 00002192
[0000219a] e833f4ffff-a-a-a-a call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0018) [000021a3]
Which isn't a program, you need to include the code for HHH.
*Yet again your attention deficit disorder*
I have told you countless times that all of
the machine code for every function is in
the same global memory space of halt7.obj.
Doesn't matter what "is in the memory space", what matters is what >>>>>> is considedred part of the program, and thus part of the input.
Neither HHH nor DDD would ever stop running unless
HHH aborts its emulation of DDD.
But your HHH DOES stop running.
HHH would not stop running unless HHH aborts its
simulation this proves that the input specifies
non-halting behavior.
So? since it does, it does, and thus DDD does.
*This is a truism*
Every input that must have its simulation aborted to
prevent its infinite execution is a non-terminating
input.
Alternatively any input D simulated by termination
analyzer H that cannot possibly reach its own final
halt state no matter what H does specifies non-halting
behavior.
On 7/23/2025 3:40 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 05:15 schreef olcott:
On 7/22/2025 9:24 PM, Richard Damon wrote:
On 7/22/25 11:39 AM, olcott wrote:
On 7/22/2025 6:29 AM, Richard Damon wrote:
On 7/21/25 11:46 PM, olcott wrote:
On 7/21/2025 5:56 PM, Richard Damon wrote:
On 7/21/25 5:49 PM, olcott wrote:
On 7/21/2025 3:58 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory olcott <polcott333@gmail.com> wrote:
On 7/21/2025 10:52 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/21/2025 9:40 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 7/21/2025 4:06 AM, Mikko wrote:
On 2025-07-20 11:48:37 +0000, Mr Flibble said:
[ .... ]On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote: >>>>>>>>>>
Your problem is you don't understand the meaning of >>>>>>>>>>>>>>>>>> the words you are
using.
This is an ad hominem attack, not argumentation.
It is also honest and truthful, which is not as common >>>>>>>>>>>>>>>> as it should.
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
What you call "verified facts" are generally nothing of >>>>>>>>>>>>>> the kind. They
are merely things, often false, you would like to be true. >>>>>>>>>>
*One key example of a denied verified fact is when Joes said* >>>>>>>>>>
On 7/18/2025 3:49 AM, joes wrote:
very obvious that HHH cannot simulate
DDD past the call to HHH.
Joes is quite right, here, as has been said to you many >>>>>>>>>>>> times over by
several people.
HHH(DDD) does emulate itself emulating DDD
You will have a get out clause from the vagueness of your >>>>>>>>>>>> language, which
could be construed to mean practically anything.
typedef void (*ptr)();
int HHH(ptr P);
void DDD()
{
-a-a HHH(DDD);
-a-a return;
}
int main()
{
-a-a HHH(DDD);
}
Not at all. HHH does emulate the x86 machine code
of DDD pointed to by P. That is does this according
to the semantics of the x86 language conclusively
proves that this emulation is correct.
That's nauseatingly overstretching things into another lie. >>>>>>>>>> Whatever HHH
might do is far short of sufficient "conclusively to prove" >>>>>>>>>> that the
emulation is correct.-a To prove that is likely impossible in >>>>>>>>>> principle,
that's even assuming you could define "correct" coherently. >>>>>>>>>>
[00002192] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000-a-a-a-a push 00002192
[0000219a] e833f4ffff-a-a-a-a call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0018) [000021a3]
Which isn't a program, you need to include the code for HHH.
*Yet again your attention deficit disorder*
I have told you countless times that all of
the machine code for every function is in
the same global memory space of halt7.obj.
Doesn't matter what "is in the memory space", what matters is what >>>>>> is considedred part of the program, and thus part of the input.
Neither HHH nor DDD would ever stop running unless
HHH aborts its emulation of DDD.
But your HHH DOES stop running.
Yet you know that you changed the question to a different question.
As usual counter-factual claims without evidence.
*Correctly emulated is defined as*
Emulated according to the rules of the x86 language.
This includes DDD emulated by HHH and HHH emulating
itself emulating DDD one or more times.
*The question is*
Can DDD correctly emulated by HHH possibly reach
its own emulated "ret" instruction?
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
On 7/22/25 11:49 AM, olcott wrote:
On 7/22/2025 6:33 AM, Richard Damon wrote:
On 7/21/25 11:50 PM, olcott wrote:
On 7/21/2025 9:20 PM, Richard Damon wrote:
On 7/21/25 9:45 AM, olcott wrote:
On 7/21/2025 4:06 AM, Mikko wrote:
On 2025-07-20 11:48:37 +0000, Mr Flibble said:
On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote: >>>>>>>>>>>
On 7/20/25 12:58 AM, olcott wrote:
Title: A Structural Analysis of the Standard Halting >>>>>>>>>>>>> Problem ProofYour problem is you don't understand the meaning of the >>>>>>>>>>>> words you are
Author: PL Olcott
Abstract:
This paper presents a formal critique of the standard proof >>>>>>>>>>>>> of the
undecidability of the Halting Problem. While we do not >>>>>>>>>>>>> dispute the
conclusion that the Halting Problem is undecidable, we >>>>>>>>>>>>> argue that the
conventional proof fails to establish this conclusion due to a >>>>>>>>>>>>> fundamental misapplication of Turing machine semantics. >>>>>>>>>>>>> Specifically,
we show that the contradiction used in the proof arises >>>>>>>>>>>>> from conflating
the behavior of encoded simulations with direct execution, >>>>>>>>>>>>> and from
making assumptions about a decider's domain that do not >>>>>>>>>>>>> hold under a
rigorous model of computation.
using.
This is an ad hominem attack, not argumentation.
It is also honest and truthful, which is not as common as it >>>>>>>>>> should.
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
Right, so YOU are the liar.
It is a verified fact that the PROGRAM DDD halts since your
HHH(DDD) returns 0.
When I say that DDD simulated by HHH does not
halt you dishonestly change the subject.
Because you are just showing you don't know English.
Not at all. You dishonestly change the subject to
something besides DDD simulated by HHH.
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of what
HHH sees.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion is
irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
Counter-factual.
That you do not understand the semantics of the
x86 language well enough to understand that this
is true is less than no rebuttal at all.
In the several years that I have presenting this
not one person has come up with a single correct
rebuttal to the statement that DD emulated by HHH
(according to the semantics of the x86 language)
would ever stop running of not aborted.
All of the rebuttals either used the strawman
deception to change the subject or were merely
a statement that my statement was really really
disbelieved. No one ever pointed out any actual error.
D halts even when not aborted,
Neither DD simulated by HHH, HHH nor DD()
halts unless HHH aborts its simulation of DD.
Disagreement is merely a failure to understand.
because it calls a function H that aborts and halts. The simulation of
an aborting H has no need to be aborted.
Unless you change the input, but that is cheating.
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
On 7/22/25 11:49 AM, olcott wrote:
On 7/22/2025 6:33 AM, Richard Damon wrote:
On 7/21/25 11:50 PM, olcott wrote:
On 7/21/2025 9:20 PM, Richard Damon wrote:
On 7/21/25 9:45 AM, olcott wrote:
On 7/21/2025 4:06 AM, Mikko wrote:
On 2025-07-20 11:48:37 +0000, Mr Flibble said:
On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote: >>>>>>>>>>>
On 7/20/25 12:58 AM, olcott wrote:
Title: A Structural Analysis of the Standard Halting >>>>>>>>>>>>> Problem ProofYour problem is you don't understand the meaning of the >>>>>>>>>>>> words you are
Author: PL Olcott
Abstract:
This paper presents a formal critique of the standard proof >>>>>>>>>>>>> of the
undecidability of the Halting Problem. While we do not >>>>>>>>>>>>> dispute the
conclusion that the Halting Problem is undecidable, we >>>>>>>>>>>>> argue that the
conventional proof fails to establish this conclusion due to a >>>>>>>>>>>>> fundamental misapplication of Turing machine semantics. >>>>>>>>>>>>> Specifically,
we show that the contradiction used in the proof arises >>>>>>>>>>>>> from conflating
the behavior of encoded simulations with direct execution, >>>>>>>>>>>>> and from
making assumptions about a decider's domain that do not >>>>>>>>>>>>> hold under a
rigorous model of computation.
using.
This is an ad hominem attack, not argumentation.
It is also honest and truthful, which is not as common as it >>>>>>>>>> should.
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
Right, so YOU are the liar.
It is a verified fact that the PROGRAM DDD halts since your
HHH(DDD) returns 0.
When I say that DDD simulated by HHH does not
halt you dishonestly change the subject.
Because you are just showing you don't know English.
Not at all. You dishonestly change the subject to
something besides DDD simulated by HHH.
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of what
HHH sees.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion is
irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
Counter-factual.
That you do not understand the semantics of the
x86 language well enough to understand that this
is true is less than no rebuttal at all.
In the several years that I have presenting this
not one person has come up with a single correct
rebuttal to the statement that DD emulated by HHH
(according to the semantics of the x86 language)
would ever stop running of not aborted.
All of the rebuttals either used the strawman
deception to change the subject or were merely
a statement that my statement was really really
disbelieved. No one ever pointed out any actual error.
D halts even when not aborted,
Neither DD simulated by HHH, HHH nor DD()
halts unless HHH aborts its simulation of DD.
Disagreement is merely a failure to understand.
because it calls a function H that aborts and halts. The simulation of
an aborting H has no need to be aborted.
Unless you change the input, but that is cheating.
Alternatively DD emulated by HHH cannot possibly
reach its own "ret" instruction and halt no matter
what HHH does.
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of what
HHH sees.
It is always the case that every halt decider is
only accountable for the behavior that its actual
input specifies and not accountable for the behavior
of any non-inputs. The textbooks don't do it this
way proves that textbooks are wrong.
Textbooks incorrectly assume that the behavior specified
by the finite string machine description of rf?Mrf- is always
the same as the behavior of machine M. That is not the
case when M calls its own termination analyzer.
Turing machine halt deciders compute the mapping from
their input finite strings to the behavior that these
finite strings specify.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion is
irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
Counter-factual.
That you do not understand the semantics of the
x86 language well enough to understand that this
is true is less than no rebuttal at all.
In the several years that I have presenting this
not one person has come up with a single correct
rebuttal to the statement that DD emulated by HHH
(according to the semantics of the x86 language)
would ever stop running of not aborted.
All of the rebuttals either used the strawman
deception to change the subject or were merely
a statement that my statement was really really
disbelieved. No one ever pointed out any actual error.
D halts even when not aborted,
Neither DD simulated by HHH, HHH nor DD()
halts unless HHH aborts its simulation of DD.
Disagreement is merely a failure to understand.
because it calls a function H that aborts and halts. The simulation of
an aborting H has no need to be aborted.
Unless you change the input, but that is cheating.
Alternatively DD emulated by HHH cannot possibly
reach its own "ret" instruction and halt no matter
what HHH does.
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
On 7/22/25 11:49 AM, olcott wrote:
On 7/22/2025 6:33 AM, Richard Damon wrote:
On 7/21/25 11:50 PM, olcott wrote:
On 7/21/2025 9:20 PM, Richard Damon wrote:
On 7/21/25 9:45 AM, olcott wrote:
On 7/21/2025 4:06 AM, Mikko wrote:
On 2025-07-20 11:48:37 +0000, Mr Flibble said:
On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote: >>>>>>>>>>>
On 7/20/25 12:58 AM, olcott wrote:
Title: A Structural Analysis of the Standard Halting >>>>>>>>>>>>> Problem ProofYour problem is you don't understand the meaning of the >>>>>>>>>>>> words you are
Author: PL Olcott
Abstract:
This paper presents a formal critique of the standard proof >>>>>>>>>>>>> of the
undecidability of the Halting Problem. While we do not >>>>>>>>>>>>> dispute the
conclusion that the Halting Problem is undecidable, we >>>>>>>>>>>>> argue that the
conventional proof fails to establish this conclusion due to a >>>>>>>>>>>>> fundamental misapplication of Turing machine semantics. >>>>>>>>>>>>> Specifically,
we show that the contradiction used in the proof arises >>>>>>>>>>>>> from conflating
the behavior of encoded simulations with direct execution, >>>>>>>>>>>>> and from
making assumptions about a decider's domain that do not >>>>>>>>>>>>> hold under a
rigorous model of computation.
using.
This is an ad hominem attack, not argumentation.
It is also honest and truthful, which is not as common as it >>>>>>>>>> should.
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
Right, so YOU are the liar.
It is a verified fact that the PROGRAM DDD halts since your
HHH(DDD) returns 0.
When I say that DDD simulated by HHH does not
halt you dishonestly change the subject.
Because you are just showing you don't know English.
Not at all. You dishonestly change the subject to
something besides DDD simulated by HHH.
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of what
HHH sees.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion is
irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
Counter-factual.
That you do not understand the semantics of the
x86 language well enough to understand that this
is true is less than no rebuttal at all.
In the several years that I have presenting this
not one person has come up with a single correct
rebuttal to the statement that DD emulated by HHH
(according to the semantics of the x86 language)
would ever stop running of not aborted.>
All of the rebuttals either used the strawman
deception to change the subject or were merely
a statement that my statement was really really
disbelieved. No one ever pointed out any actual error.
D halts even when not aborted,
Neither DD simulated by HHH, HHH nor DD()
halts unless HHH aborts its simulation of DD.
Disagreement is merely a failure to understand.
because it calls a function H that aborts and halts. The simulation of
an aborting H has no need to be aborted.
Unless you change the input, but that is cheating.
Alternatively DD emulated by HHH cannot possibly
reach its own "ret" instruction and halt no matter
what HHH does.
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
On 7/22/25 11:49 AM, olcott wrote:
On 7/22/2025 6:33 AM, Richard Damon wrote:
On 7/21/25 11:50 PM, olcott wrote:
On 7/21/2025 9:20 PM, Richard Damon wrote:
On 7/21/25 9:45 AM, olcott wrote:
On 7/21/2025 4:06 AM, Mikko wrote:
On 2025-07-20 11:48:37 +0000, Mr Flibble said:
On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote: >>>>>>>>>>>
On 7/20/25 12:58 AM, olcott wrote:
Title: A Structural Analysis of the Standard Halting >>>>>>>>>>>>> Problem ProofYour problem is you don't understand the meaning of the >>>>>>>>>>>> words you are
Author: PL Olcott
Abstract:
This paper presents a formal critique of the standard proof >>>>>>>>>>>>> of the
undecidability of the Halting Problem. While we do not >>>>>>>>>>>>> dispute the
conclusion that the Halting Problem is undecidable, we >>>>>>>>>>>>> argue that the
conventional proof fails to establish this conclusion due to a >>>>>>>>>>>>> fundamental misapplication of Turing machine semantics. >>>>>>>>>>>>> Specifically,
we show that the contradiction used in the proof arises >>>>>>>>>>>>> from conflating
the behavior of encoded simulations with direct execution, >>>>>>>>>>>>> and from
making assumptions about a decider's domain that do not >>>>>>>>>>>>> hold under a
rigorous model of computation.
using.
This is an ad hominem attack, not argumentation.
It is also honest and truthful, which is not as common as it >>>>>>>>>> should.
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
Right, so YOU are the liar.
It is a verified fact that the PROGRAM DDD halts since your
HHH(DDD) returns 0.
When I say that DDD simulated by HHH does not
halt you dishonestly change the subject.
Because you are just showing you don't know English.
Not at all. You dishonestly change the subject to
something besides DDD simulated by HHH.
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of what
HHH sees.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion is
irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
Counter-factual.
That you do not understand the semantics of the
x86 language well enough to understand that this
is true is less than no rebuttal at all.
In the several years that I have presenting this
not one person has come up with a single correct
rebuttal to the statement that DD emulated by HHH
(according to the semantics of the x86 language)
would ever stop running of not aborted.
All of the rebuttals either used the strawman
deception to change the subject or were merely
a statement that my statement was really really
disbelieved. No one ever pointed out any actual error.
D halts even when not aborted,
Neither DD simulated by HHH, HHH nor DD()
halts unless HHH aborts its simulation of DD.
Disagreement is merely a failure to understand.
because it calls a function H that aborts and halts. The simulation of
an aborting H has no need to be aborted.
Unless you change the input, but that is cheating.
No, you have just been too stupid to see your error and to morally
corrupt to admit it.
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are you Damon?
/Flibble
Op 23.jul.2025 om 15:31 schreef olcott:
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of
what HHH sees.
It is always the case that every halt decider is
only accountable for the behavior that its actual
input specifies and not accountable for the behavior
of any non-inputs. The textbooks don't do it this
way proves that textbooks are wrong.
As usual irrelevant claim without evidence
Up to now you could not point to any textbook that is wrong.
Textbooks incorrectly assume that the behavior specified
by the finite string machine description of rf?Mrf- is always
the same as the behavior of machine M. That is not the
case when M calls its own termination analyzer.
As usual repeated claims without any evidence.
The behaviour specified in the description of the input does not depend
on who analyses it. When some analysers are unable to see the whole specification, that is an error in the analyser, it does not change the specification.
Turing machine halt deciders compute the mapping from
their input finite strings to the behavior that these
finite strings specify.
Exactly.
And when a halting behaviour is specified, but the analyser is unable to
see that, the analyser is wrong. It should not compute the behaviour of
a hypothetical non-halting non-input.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion
is irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
You have been told many times that these 35 bytes are not the complete input. In fact they are the least interesting part of the input. DD is completely irrelevant. What is relevant is that HHH must simulate itself.
-a-a-a-a-a-a int main() {
-a-a-a-a-a-a-a-a return HHH(main);
-a-a-a-a-a-a }
Here is no DD, and your own words are that HHH returns and reports that
it does not halt.
This clearly shows that HHH is unable to analyse its own behaviour and produces false negative when it tries to do so.
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are you Damon?
/Flibble
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are you
Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
On 7/25/2025 3:49 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 15:31 schreef olcott:
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of
what HHH sees.
It is always the case that every halt decider is
only accountable for the behavior that its actual
input specifies and not accountable for the behavior
of any non-inputs. The textbooks don't do it this
way proves that textbooks are wrong.
As usual irrelevant claim without evidence
Up to now you could not point to any textbook that is wrong.
Textbooks incorrectly assume that the behavior specified
by the finite string machine description of rf?Mrf- is always
the same as the behavior of machine M. That is not the
case when M calls its own termination analyzer.
As usual repeated claims without any evidence.
The behaviour specified in the description of the input does not
depend on who analyses it. When some analysers are unable to see the
whole specification, that is an error in the analyser, it does not
change the specification.
Turing machine halt deciders compute the mapping from
their input finite strings to the behavior that these
finite strings specify.
Exactly.
And when a halting behaviour is specified, but the analyser is unable
to see that, the analyser is wrong. It should not compute the
behaviour of a hypothetical non-halting non-input.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D >>>>> -a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion
is irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
You have been told many times that these 35 bytes are not the complete
input. In fact they are the least interesting part of the input. DD is
completely irrelevant. What is relevant is that HHH must simulate itself.
-a-a-a-a-a-a-a int main() {
-a-a-a-a-a-a-a-a-a return HHH(main);
-a-a-a-a-a-a-a }
Here is no DD, and your own words are that HHH returns and reports
that it does not halt.
This clearly shows that HHH is unable to analyse its own behaviour and
produces false negative when it tries to do so.
When-so-ever the input to a simulating termination
analyzer calls its actual self as (your example above)
or when the HHH(DDD) input calls HHH(DDD) this does
specify recursive emulation that must be aborted to
prevent the non-termination of the directly executed HHH.
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are you
Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your lies.
I point out your stupidity to help people understand where you are
coming from so they don't try to find the logic in your illogical statements.
On 7/25/25 12:44 PM, olcott wrote:
On 7/25/2025 3:49 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 15:31 schreef olcott:
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
No, YOU changed the subject of the problem from the OBJECTIVE
behavior of the execution of DDD, to the SUBJECTIVE criteria of >>>>>>> what HHH sees.
It is always the case that every halt decider is
only accountable for the behavior that its actual
input specifies and not accountable for the behavior
of any non-inputs. The textbooks don't do it this
way proves that textbooks are wrong.
As usual irrelevant claim without evidence
Up to now you could not point to any textbook that is wrong.
Textbooks incorrectly assume that the behavior specified
by the finite string machine description of rf?Mrf- is always
the same as the behavior of machine M. That is not the
case when M calls its own termination analyzer.
As usual repeated claims without any evidence.
The behaviour specified in the description of the input does not
depend on who analyses it. When some analysers are unable to see the
whole specification, that is an error in the analyser, it does not
change the specification.
Turing machine halt deciders compute the mapping from
their input finite strings to the behavior that these
finite strings specify.
Exactly.
And when a halting behaviour is specified, but the analyser is unable
to see that, the analyser is wrong. It should not compute the
behaviour of a hypothetical non-halting non-input.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>> -a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D >>>>>> -a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly
detects that its D would never stop unless aborted', the conclusion >>>>> is irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
You have been told many times that these 35 bytes are not the
complete input. In fact they are the least interesting part of the
input. DD is completely irrelevant. What is relevant is that HHH must
simulate itself.
-a-a-a-a-a-a-a int main() {
-a-a-a-a-a-a-a-a-a return HHH(main);
-a-a-a-a-a-a-a }
Here is no DD, and your own words are that HHH returns and reports
that it does not halt.
This clearly shows that HHH is unable to analyse its own behaviour
and produces false negative when it tries to do so.
When-so-ever the input to a simulating termination
analyzer calls its actual self as (your example above)
or when the HHH(DDD) input calls HHH(DDD) this does
specify recursive emulation that must be aborted to
prevent the non-termination of the directly executed HHH.
Where do you get this claim from?
REMEMBER the problem order, HHH existed first, and can't change to avoid problems, THEN we create the input DDD, which uses that SPECIFIC HHH.
The template DDD might have existed first, but not the program DDD, and
the input is of the PROGRAM.
Either it aborted in this condition, at which the program that calls it
can use that fact to establish that it will halt,
or it doesn't abort, and then fails in the way you describe.
HHH can't treat the input that calls this HHH (that aborts) as calling
some other code (a version that does).
All you are doing is showing that your "logic" is based on lying.
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are you
Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your lies.
I point out your stupidity to help people understand where you are
coming from so they don't try to find the logic in your illogical
statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
On 7/25/2025 12:30 PM, Richard Damon wrote:
On 7/25/25 12:44 PM, olcott wrote:
On 7/25/2025 3:49 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 15:31 schreef olcott:
On 7/23/2025 3:24 AM, Fred. Zwarts wrote:
Op 23.jul.2025 om 06:05 schreef olcott:
On 7/22/2025 9:32 PM, Richard Damon wrote:
No, YOU changed the subject of the problem from the OBJECTIVE >>>>>>>> behavior of the execution of DDD, to the SUBJECTIVE criteria of >>>>>>>> what HHH sees.
It is always the case that every halt decider is
only accountable for the behavior that its actual
input specifies and not accountable for the behavior
of any non-inputs. The textbooks don't do it this
way proves that textbooks are wrong.
As usual irrelevant claim without evidence
Up to now you could not point to any textbook that is wrong.
Textbooks incorrectly assume that the behavior specified
by the finite string machine description of rf?Mrf- is always
the same as the behavior of machine M. That is not the
case when M calls its own termination analyzer.
As usual repeated claims without any evidence.
The behaviour specified in the description of the input does not
depend on who analyses it. When some analysers are unable to see the
whole specification, that is an error in the analyser, it does not
change the specification.
Turing machine halt deciders compute the mapping from
their input finite strings to the behavior that these
finite strings specify.
Exactly.
And when a halting behaviour is specified, but the analyser is
unable to see that, the analyser is wrong. It should not compute the
behaviour of a hypothetical non-halting non-input.
*Its been three years now and you can't remember*
<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>>> -a-a-a-a would never stop running unless aborted then
-a-a-a-a H can abort its simulation of D and correctly report that D >>>>>>> -a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly >>>>>> detects that its D would never stop unless aborted', the
conclusion is irrelevant.
_DD()
[00002162] 55-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002163] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002165] 51-a-a-a-a-a-a-a-a-a-a-a-a push ecx
[00002166] 6862210000-a-a-a-a push 00002162 // push DD
[0000216b] e862f4ffff-a-a-a-a call 000015d2 // call HHH
[00002170] 83c404-a-a-a-a-a-a-a-a add esp,+04
[00002173] 8945fc-a-a-a-a-a-a-a-a mov [ebp-04],eax
[00002176] 837dfc00-a-a-a-a-a-a cmp dword [ebp-04],+00
[0000217a] 7402-a-a-a-a-a-a-a-a-a-a jz 0000217e
[0000217c] ebfe-a-a-a-a-a-a-a-a-a-a jmp 0000217c
[0000217e] 8b45fc-a-a-a-a-a-a-a-a mov eax,[ebp-04]
[00002181] 8be5-a-a-a-a-a-a-a-a-a-a mov esp,ebp
[00002183] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[00002184] c3-a-a-a-a-a-a-a-a-a-a-a-a ret
Size in bytes:(0035) [00002184]
You have been told many times that these 35 bytes are not the
complete input. In fact they are the least interesting part of the
input. DD is completely irrelevant. What is relevant is that HHH
must simulate itself.
-a-a-a-a-a-a-a int main() {
-a-a-a-a-a-a-a-a-a return HHH(main);
-a-a-a-a-a-a-a }
Here is no DD, and your own words are that HHH returns and reports
that it does not halt.
This clearly shows that HHH is unable to analyse its own behaviour
and produces false negative when it tries to do so.
When-so-ever the input to a simulating termination
analyzer calls its actual self as (your example above)
or when the HHH(DDD) input calls HHH(DDD) this does
specify recursive emulation that must be aborted to
prevent the non-termination of the directly executed HHH.
Where do you get this claim from?
If you understood recursion well enough you
could have figured this out on your own
as four different chatbots did figure this
out on their own.
REMEMBER the problem order, HHH existed first, and can't change to
avoid problems, THEN we create the input DDD, which uses that SPECIFIC
HHH.
The template DDD might have existed first, but not the program DDD,
and the input is of the PROGRAM.
Either it aborted in this condition, at which the program that calls
it can use that fact to establish that it will halt,
or it doesn't abort, and then fails in the way you describe.
HHH can't treat the input that calls this HHH (that aborts) as calling
some other code (a version that does).
All you are doing is showing that your "logic" is based on lying.
All that the above shows is that you don't understand
recursion well enough. If you did understand recursion
well enough you would understand that the input to HHH(DDD)
does specify the recursive emulation non-halting behavior
pattern.
_DDD()
[00002192] 55-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000 push 00002192-a // push DDD
[0000219a] e833f4ffff call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a ret
Size in bytes:(0018) [000021a3]
The conclusive proof that I am right and you are
wrong is provided by the correct execution trace
of DDD emulated by HHH.
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally >>>>>> corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are
you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your lies.
I point out your stupidity to help people understand where you are
coming from so they don't try to find the logic in your illogical
statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire.
You will need to get Fibber to agree to, or I will continue on him.
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally >>>>>>> corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are
you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your lies.
I point out your stupidity to help people understand where you are
coming from so they don't try to find the logic in your illogical
statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire.
You will need to get Fibber to agree to, or I will continue on him.
OK I will refrain from calling anyone a liar while
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
If you change the subject to anything else then this
change of subject makes you a liar.
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally >>>>>>>> corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are >>>>>>> you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your lies. >>>>>
I point out your stupidity to help people understand where you are
coming from so they don't try to find the logic in your illogical
statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire.
You will need to get Fibber to agree to, or I will continue on him.
OK I will refrain from calling anyone a liar while
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest that
doesn't count.
I won't call you a liar unless you say a lie.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the statement
is just a LIE.
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to morally >>>>>>>>> corrupt to admit it.
Yet another ad hominem attack, you are not very good at this are >>>>>>>> you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your lies. >>>>>>
I point out your stupidity to help people understand where you are >>>>>> coming from so they don't try to find the logic in your illogical >>>>>> statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire.
You will need to get Fibber to agree to, or I will continue on him.
OK I will refrain from calling anyone a liar while
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest that
doesn't count.
Disagreeing doesn't count as dishonesty.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
You cannot possibly refute that with any kind of correct
reasoning. That the emulation must be infinite to be
correct is fucking nuts.
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to >>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this >>>>>>>>> are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your >>>>>>> lies.
I point out your stupidity to help people understand where you
are coming from so they don't try to find the logic in your
illogical statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire.
You will need to get Fibber to agree to, or I will continue on him.
OK I will refrain from calling anyone a liar while
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest that
doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of halting.
The only simulation that can be used as a replacement for the direct execution is the CORRECT (which means complete with no aborting)
SIMULATION of the exact input, which must include in it ALL the code used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that are
just blantently incorrect.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue to the final state, as that is also part of the x86 language.
Partial simulations are NOT "correct" when talking about non-halting.
--
You cannot possibly refute that with any kind of correct
reasoning. That the emulation must be infinite to be
correct is fucking nuts.
Its the definition, do refuse to accept the definition is just stupid.
Your problem is you forget that the definition doesn't require HHH to do that simulation, just show that the simulation by the UTM, of the actual input (including the code of the original HHH) will not halt.
This is just your incorrect confusion between Knowledge and Truth.
The Truth of the halting is established by the UTM, but HHH can't "wait"
for the UTM, so needs to use proper logic to determine what it will do.
The problem is that there is no proper logic to allow HHH to determine a correct answer for D/DD (there is for DDD), because which ever answer
HHH ends up giving the correct answer will be the other.
For DDD, HHH just needs to return 1 to be correct, but your rules can't justify that answer, so it can't do it and follow your rules.
That the correct answer is not computable isn't actually a problem, as
it was reaslized after Turing showned this one question wasn't
conputable, as the mathemeatics of infinity was discovered, it became
clear that there MUST have been MANY uncomputable problems by a simple counting argument,but that seems to be beyond your understanding, as I
don't think you understand even simple infinities.
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:OK I will refrain from calling anyone a liar while
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote:
No, you have just been too stupid to see your error and to >>>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this >>>>>>>>>> are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance.
No, it is just the method that you both use to try to mask your >>>>>>>> lies.
I point out your stupidity to help people understand where you >>>>>>>> are coming from so they don't try to find the logic in your
illogical statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire.
You will need to get Fibber to agree to, or I will continue on him. >>>>>
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest that
doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the dishonest
claim, since it is a violation of the definition of halting.
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the direct
execution is the CORRECT (which means complete with no aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the code
used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that are
just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue to
the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
You cannot possibly refute that with any kind of correct
reasoning. That the emulation must be infinite to be
correct is fucking nuts.
Its the definition, do refuse to accept the definition is just stupid.
Your problem is you forget that the definition doesn't require HHH to
do that simulation, just show that the simulation by the UTM, of the
actual input (including the code of the original HHH) will not halt.
This is just your incorrect confusion between Knowledge and Truth.
The Truth of the halting is established by the UTM, but HHH can't
"wait" for the UTM, so needs to use proper logic to determine what it
will do.
The problem is that there is no proper logic to allow HHH to determine
a correct answer for D/DD (there is for DDD), because which ever
answer HHH ends up giving the correct answer will be the other.
For DDD, HHH just needs to return 1 to be correct, but your rules
can't justify that answer, so it can't do it and follow your rules.
That the correct answer is not computable isn't actually a problem, as
it was reaslized after Turing showned this one question wasn't
conputable, as the mathemeatics of infinity was discovered, it became
clear that there MUST have been MANY uncomputable problems by a simple
counting argument,but that seems to be beyond your understanding, as I
don't think you understand even simple infinities.
On 7/25/25 5:51 PM, olcott wrote:
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:OK I will refrain from calling anyone a liar while
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote: >>>>>>>>>>>
No, you have just been too stupid to see your error and to >>>>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this >>>>>>>>>>> are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance. >>>>>>>>>>
No, it is just the method that you both use to try to mask your >>>>>>>>> lies.
I point out your stupidity to help people understand where you >>>>>>>>> are coming from so they don't try to find the logic in your >>>>>>>>> illogical statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire. >>>>>>>
You will need to get Fibber to agree to, or I will continue on him. >>>>>>
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest that >>>>> doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of halting.
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the direct
execution is the CORRECT (which means complete with no aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the code
used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that are
just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue to
the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
[[ Two year old style rant trimed ]]
But H can't "Correctly Determine" that, since it isn't true.
On 7/25/25 5:51 PM, olcott wrote:
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:OK I will refrain from calling anyone a liar while
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote: >>>>>>>>>>>
No, you have just been too stupid to see your error and to >>>>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this >>>>>>>>>>> are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance. >>>>>>>>>>
No, it is just the method that you both use to try to mask your >>>>>>>>> lies.
I point out your stupidity to help people understand where you >>>>>>>>> are coming from so they don't try to find the logic in your >>>>>>>>> illogical statements.
Try not using any insults and only rely on correct reasoning.
When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire. >>>>>>>
You will need to get Fibber to agree to, or I will continue on him. >>>>>>
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest that >>>>> doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of halting.
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the direct
execution is the CORRECT (which means complete with no aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the code
used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that are
just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue to
the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
[[ Two year old style rant trimed ]]
But H can't "Correctly Determine" that, since it isn't true.
The CORRECT SIMULATION of D WILL HALT, BECAUSE you H ultimate has been assumed to detect some pattern and stopped.
On 7/25/2025 5:45 PM, Richard Damon wrote:
On 7/25/25 5:51 PM, olcott wrote:
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:OK I will refrain from calling anyone a liar while
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote: >>>>>>>>>>>>
No, you have just been too stupid to see your error and to >>>>>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this >>>>>>>>>>>> are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance. >>>>>>>>>>>
No, it is just the method that you both use to try to mask >>>>>>>>>> your lies.
I point out your stupidity to help people understand where you >>>>>>>>>> are coming from so they don't try to find the logic in your >>>>>>>>>> illogical statements.
Try not using any insults and only rely on correct reasoning. >>>>>>>>> When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire. >>>>>>>>
You will need to get Fibber to agree to, or I will continue on him. >>>>>>>
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest
that doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of halting. >>>>
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the direct
execution is the CORRECT (which means complete with no aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the code
used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that
are just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue to
the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
[[ Two year old style rant trimed ]]
But H can't "Correctly Determine" that, since it isn't true.
I have told you that 500 times and you keep contradicting it.
That is either dishonestly or brain damage.
On 7/25/2025 5:45 PM, Richard Damon wrote:
On 7/25/25 5:51 PM, olcott wrote:
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:OK I will refrain from calling anyone a liar while
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote: >>>>>>>>>>>>
No, you have just been too stupid to see your error and to >>>>>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at this >>>>>>>>>>>> are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance. >>>>>>>>>>>
No, it is just the method that you both use to try to mask >>>>>>>>>> your lies.
I point out your stupidity to help people understand where you >>>>>>>>>> are coming from so they don't try to find the logic in your >>>>>>>>>> illogical statements.
Try not using any insults and only rely on correct reasoning. >>>>>>>>> When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars.
Remember, YOU started it, and refused the offer of a cease-fire. >>>>>>>>
You will need to get Fibber to agree to, or I will continue on him. >>>>>>>
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest
that doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of halting. >>>>
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the direct
execution is the CORRECT (which means complete with no aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the code
used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that
are just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue to
the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
[[ Two year old style rant trimed ]]
But H can't "Correctly Determine" that, since it isn't true.
The CORRECT SIMULATION of D WILL HALT, BECAUSE you H ultimate has been
assumed to detect some pattern and stopped.
_DDD()
[00002192] 55-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000 push 00002192-a // push DDD
[0000219a] e833f4ffff call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a ret
Size in bytes:(0018) [000021a3]
Until you provide the execution trace of DDD emulated
by HHH (according to the rules of the x86 language)
such that this emulated DDD reaches its own emulated
"ret" instruction final halt state
*you will be considered a fucking liar*
On 7/25/25 7:42 PM, olcott wrote:*You dishonestly changed the words that I said, as you always do*
On 7/25/2025 5:45 PM, Richard Damon wrote:
On 7/25/25 5:51 PM, olcott wrote:
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote: >>>>>>>>>>>>>
No, you have just been too stupid to see your error and to >>>>>>>>>>>>>> morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at >>>>>>>>>>>>> this are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance. >>>>>>>>>>>>
No, it is just the method that you both use to try to mask >>>>>>>>>>> your lies.
I point out your stupidity to help people understand where >>>>>>>>>>> you are coming from so they don't try to find the logic in >>>>>>>>>>> your illogical statements.
Try not using any insults and only rely on correct reasoning. >>>>>>>>>> When you do this your reasoning errors will be laid bare.
Only if you first promise to also stop calling people liars. >>>>>>>>>
Remember, YOU started it, and refused the offer of a cease-fire. >>>>>>>>>
You will need to get Fibber to agree to, or I will continue on >>>>>>>>> him.
OK I will refrain from calling anyone a liar while
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest
that doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest.
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of halting. >>>>>
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the
direct execution is the CORRECT (which means complete with no
aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the
code used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that
are just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the
statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue
to the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting. >>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
[[ Two year old style rant trimed ]]
But H can't "Correctly Determine" that, since it isn't true.
The CORRECT SIMULATION of D WILL HALT, BECAUSE you H ultimate has
been assumed to detect some pattern and stopped.
_DDD()
[00002192] 55-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000 push 00002192-a // push DDD
[0000219a] e833f4ffff call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a ret
Size in bytes:(0018) [000021a3]
Until you provide the execution trace of DDD emulated
by HHH (according to the rules of the x86 language)
such that this emulated DDD reaches its own emulated
"ret" instruction final halt state
*you will be considered a fucking liar*
That is just a lIE.
Until you realize that HHH just doesn't do a correct simulation,
On 7/25/2025 8:22 PM, Richard Damon wrote:
On 7/25/25 7:42 PM, olcott wrote:*You dishonestly changed the words that I said, as you always do*
On 7/25/2025 5:45 PM, Richard Damon wrote:
On 7/25/25 5:51 PM, olcott wrote:
On 7/25/2025 4:26 PM, Richard Damon wrote:
On 7/25/25 4:34 PM, olcott wrote:
On 7/25/2025 3:04 PM, Richard Damon wrote:
On 7/25/25 3:50 PM, olcott wrote:
On 7/25/2025 1:07 PM, Richard Damon wrote:
On 7/25/25 1:31 PM, olcott wrote:
On 7/25/2025 12:25 PM, Richard Damon wrote:
On 7/25/25 10:43 AM, olcott wrote:
On 7/25/2025 8:56 AM, Mr Flibble wrote:
On Thu, 24 Jul 2025 22:58:34 -0400, Richard Damon wrote: >>>>>>>>>>>>>>
No, you have just been too stupid to see your error and >>>>>>>>>>>>>>> to morally
corrupt to admit it.
Yet another ad hominem attack, you are not very good at >>>>>>>>>>>>>> this are you Damon?
/Flibble
I think that he does this to attempt to mask his ignorance. >>>>>>>>>>>>>
No, it is just the method that you both use to try to mask >>>>>>>>>>>> your lies.
I point out your stupidity to help people understand where >>>>>>>>>>>> you are coming from so they don't try to find the logic in >>>>>>>>>>>> your illogical statements.
Try not using any insults and only rely on correct reasoning. >>>>>>>>>>> When you do this your reasoning errors will be laid bare. >>>>>>>>>>>
Only if you first promise to also stop calling people liars. >>>>>>>>>>
Remember, YOU started it, and refused the offer of a cease-fire. >>>>>>>>>>
You will need to get Fibber to agree to, or I will continue on >>>>>>>>>> him.
OK I will refrain from calling anyone a liar while
I see that this is mutually respected and there is
no evidence that the reply is in any way dishonest.
Since you see anyone who disagrees with you as being dishonest >>>>>>>> that doesn't count.
Disagreeing doesn't count as dishonesty.
Yes, but you call anyone who disagrees with you as being dishonest. >>>>>>
I didn't call them a liar just because they disagreed.
I called them a liar when they changed the words that
I said and then used these changed words as the basis
of their rebuttal.
Changing the subject away from DDD simulated by
HHH to anything else counts as dishonesty.
No,
Yes you are a liar otherwise.
insisting that the criteria *IS* DDD simulated by HHH is the
dishonest claim, since it is a violation of the definition of
halting.
If you want to insist on lying I will not stop calling you a liar.
The only simulation that can be used as a replacement for the
direct execution is the CORRECT (which means complete with no
aborting)
That you expect a correct simulation of a non-terminating
input to be infinite is fucking nuts. When one instruction
of a non-terminating input is correctly emulated then it
is dishonest to conclude that zero instructions were emulated
correctly.
SIMULATION of the exact input, which must include in it ALL the
code used.
I won't call you a liar unless you say a lie.
The we must also agree that an actual lie only
includes an INTENTIONALLY false statement.
Except it doesn't, as, as shown, it also includes statements that >>>>>> are just blantently incorrect.
Since that is not the way that most people take
the meaning of the word your use of this term
in that way is libelous.
For example when I refer to DDD correctly emulated
by HHH I mean that one or more instructions of DDD
have been emulated by HHH according to the rules
of the x86 language. This does include HHH emulating
itself when the emulated DDD calls HHH(DDD).
But that ISN'T the definition of a correct simulation, so the >>>>>>>> statement is just a LIE.
That HHH emulates the exact sequence of machine code bytes
that it is presented with according to the rules of the x86
language *IS THE DEFINITION OF CORRECT EMULATION*
No, you miss the requirement that to be correct, it must continue >>>>>> to the final state, as that is also part of the x86 language.
That is fucking nuts. Non-terminating inputs cannot
reach any final state.
Partial simulations are NOT "correct" when talking about non-halting. >>>>>>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a would never stop running unless aborted then
until H correctly determines
until H correctly determines
[[ Two year old style rant trimed ]]
But H can't "Correctly Determine" that, since it isn't true.
The CORRECT SIMULATION of D WILL HALT, BECAUSE you H ultimate has
been assumed to detect some pattern and stopped.
_DDD()
[00002192] 55-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000 push 00002192-a // push DDD
[0000219a] e833f4ffff call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a ret
Size in bytes:(0018) [000021a3]
Until you provide the execution trace of DDD emulated
by HHH (according to the rules of the x86 language)
such that this emulated DDD reaches its own emulated
"ret" instruction final halt state
*you will be considered a fucking liar*
That is just a lIE.
Until you realize that HHH just doesn't do a correct simulation,
*Here are the words that I actually said*
(according to the rules of the x86 language)