Discussion:
DDD correctly emulated by HHH is correctly rejected as non-halting V2
(too old to reply)
olcott
2024-07-12 14:56:05 UTC
Permalink
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]

When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.

Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Fred. Zwarts
2024-07-12 20:52:13 UTC
Permalink
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
But the following M steps are not simulated at all, making the as a
whole invalid, because:
1) That contradicts your stipulation that the only measure of a correct
emulation is the semantics of the x86 programming language. The x86
language does not allow an abort halfway of a series of instructions.
2) Skipping the simulation of only some steps will make the behaviour
different. The simulator must process the whole input, not only the
first part.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
Then it skips the last part of the simulation and that makes the
simulation as a whole incorrect.
Post by olcott
HHH₂ two steps of DDD are correctly emulated by HHH.
Then it skips the last part of the simulation and that makes the
simulation as a whole incorrect.
Post by olcott
HHH₃ three steps of DDD are correctly emulated by HHH.
Then it skips the last part of the simulation and that makes the
simulation as a whole incorrect.
Post by olcott
...
HHH∞ The emulation of DDD by HHH never stops running.
Even that simulation is incorrect, because it does not end.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
And where the HHH that abort skip the simulation of the last part of its
input, making the simulation incorrect.
Post by olcott
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Showing that none of these simulations was correct.
It only proves that no HHH in this set is able to simulate itself correctly.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
No, the conclusion must be that none of the HHH in this set is able to
simulate itself correctly and reach the end of the simulation.
They all miss the last part of the simulation and therefore, do not
process the full input.
So, the abort was always premature and no conclusion about halting or
non-halting is possible. For each of the HHH that abort, it makes no
sense to dream of a HHH that does not abort, because that is not the one
that this HHH is simulating.
Each of the HHH in this set only simulates itself, not another one of
this set. Dreaming of another HHH in this set when simulating only
itself, is irrelevant and does not make the simulation correct.

No matter how much you want it to be correct, or how many times you
repeat that it is correct, it does not change the fact that none of
these simulations is correct, because none of them is able to reach the end.
For each HHH in this set we see that HHH cannot possibly simulate itself
correctly.

DDD has nothing to do with it. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.

HHH is unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.
When it should decide about Finite_Recursion(5), the programmer starts
to dream about an infinite set of Finite_Recursion(M), with M=0 to
infinity, and decides that it must be an infinite recursion.
Richard Damon
2024-07-12 22:56:15 UTC
Permalink
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of the
program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior of
DDD, which continues per the definition of the x86 instruction set until
the COMPLETE emulation (or direct execution) reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and aborted
its emulation on a non-terminal instrucition only have partial knowledge
of the behavior of their DDD, and by returning to their caller, they
establish that behavior for ALL copies of that HHH, even the one that
DDD calls, which shows that DDD will be halting, even though HHH stopped
its observation of the input before it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.

The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY case,
when we look at the behavior past that point, which DOES occur per the
definition of the x86 instruction set, as we have not reached a
"termial" instruction that stops behavior, will see the HHH(DDD) that
DDD called continuing to simulate its input to the point that this one
was defined to stop, and then returns 0 to DDDD and then DDD returning
and ending the behavior.

You continue to stupidly confuse the PARTIAL observation that HHH does
of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL
behavior of DDD as defined by the full definition of the x86 insttuction
set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.

NONE Of them CORRECTLY rejected itS DDD as non-halting and you are shown
to be ignorant of what you are talking about.

The HHH that did a partial emulation got the wrong answer, because THEIR
DDD will halt. and the HHH that doen't abort never get around to
rejecting its DDD as non-halting.
olcott
2024-07-12 23:19:26 UTC
Permalink
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of the
program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior of
DDD, which continues per the definition of the x86 instruction set until
the COMPLETE emulation (or direct execution) reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and aborted
its emulation on a non-terminal instrucition only have partial knowledge
of the behavior of their DDD, and by returning to their caller, they
establish that behavior for ALL copies of that HHH, even the one that
DDD calls, which shows that DDD will be halting, even though HHH stopped
its observation of the input before it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY case,
when we look at the behavior past that point, which DOES occur per the
definition of the x86 instruction set, as we have not reached a
"termial" instruction that stops behavior, will see the HHH(DDD) that
DDD called continuing to simulate its input to the point that this one
was defined to stop, and then returns 0 to DDDD and then DDD returning
and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH does
of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL
behavior of DDD as defined by the full definition of the x86 insttuction
set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are shown
to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because THEIR
DDD will halt. and the HHH that doen't abort never get around to
rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.

*No double-talk and weasel words can overcome that*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-12 23:41:16 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have partial
knowledge of the behavior of their DDD, and by returning to their
caller, they establish that behavior for ALL copies of that HHH, even
the one that DDD calls, which shows that DDD will be halting, even
though HHH stopped its observation of the input before it gets to that
point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH does
of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL
behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around to
rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
Which is just your double-talk to try to redefine what halting means.

You are just showing your mential inability to distinguish between what
is actually true and the limited observation of your machines, or that
all the DDDs that the HHHs are emulating are DIFFERENT, because they
need to include the HHH they are paired with, or HHH CAN'T do what you
said it does.

The fact that HHH's partial emulation doesn't reach the terminal
instructions, doesn't mean that the actual behavior doesn't.

You are just stuck in your incorrect subjective view of the universe.
olcott
2024-07-13 03:00:08 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
Which is just your double-talk to try to redefine what halting means.
You try to cut my airtight proof up in little pieces and fail.
Every rebuttal that you make has disagreeing with the semantics
of the x86 language as its basis.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 03:48:30 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not
reached a "termial" instruction that stops behavior, will see the
HHH(DDD) that DDD called continuing to simulate its input to the
point that this one was defined to stop, and then returns 0 to DDDD
and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
Which is just your double-talk to try to redefine what halting means.
You try to cut my airtight proof up in little pieces and fail.
Every rebuttal that you make has disagreeing with the semantics
of the x86 language as its basis.
How?

What Semantic of the x86 instruction set as defined by Intel dp I violate?

Where is the statement that justifies stopping the simulation in any way
still recreates the full behavior of the program given to the simulator?

Where does it say that calling a function make the processor do ANYTHING
other than stepping through the function itself? (So you can try to
argue that calling HHH, a CONDITIONAL emulator, begins AT THE x86
INSTRUCTION LEVEL, and emulation of the program given as an input?)

What "instruction" tells the processor to "emulate" the program
specified as a parameter to the function being called.


This is just another of you many unfounded LIES where you claim
something that you can not prove and just deflect, deflect, deflect, as
you KNOW you have no grounds to base it on, just you own lies.

This is just like your "non-sense" and non-existent "Diagonalization"
proof that shows Godel wrong.

Your argument is only "Air-tight" in the sense that it is just like a 3
year old threatening to hold his breath until he turns blue.

Go ahead, keep repeating you lie, and we can keep on pointing out how
stupid you are to continue making the claim, it just show how absolutely
little you understand what you are talking about.
Fred. Zwarts
2024-07-13 08:15:37 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have partial
knowledge of the behavior of their DDD, and by returning to their
caller, they establish that behavior for ALL copies of that HHH, even
the one that DDD calls, which shows that DDD will be halting, even
though HHH stopped its observation of the input before it gets to that
point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH does
of the behavior of DDD by its PARTIAL emulation with the ACTUAL FULL
behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around to
rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that simulates
itself correctly. We know that every DDD would halt when simulated
correctly. Each HHH misses the last part of the behaviour of the input,
because they all abort one cycle too soon.
You like to ignore it and continue to double-talk about the properties
of an empty set of HHH that correctly simulate itself.

No matter how much you want it to be correct, or how many times you
repeat that it is correct, it does not change the fact that none of
these simulations is correct, because none of them is able to reach the end.
For each HHH in this set we see that HHH cannot possibly simulate itself
correctly.

DDD has nothing to do with it. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.

HHH is unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.
olcott
2024-07-13 11:39:31 UTC
Permalink
Post by Fred. Zwarts
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the behavior
of DDD, which continues per the definition of the x86 instruction set
until the COMPLETE emulation (or direct execution) reaches a terminal
instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a finite
number of steps WILL halt becuase it will reach its final return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not reached
a "termial" instruction that stops behavior, will see the HHH(DDD)
that DDD called continuing to simulate its input to the point that
this one was defined to stop, and then returns 0 to DDDD and then DDD
returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that simulates
itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Fred. Zwarts
2024-07-13 12:20:14 UTC
Permalink
Post by olcott
Post by Fred. Zwarts
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not
reached a "termial" instruction that stops behavior, will see the
HHH(DDD) that DDD called continuing to simulate its input to the
point that this one was defined to stop, and then returns 0 to DDDD
and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that simulates
itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
You have a wrong understanding of the semantics of the x86 language. You
think that the x86 language specifies that skipping instructions do not
change the behaviour of a program.
However, the x86 language does not allow an abort halfway the processing
of the instructions, because that would change the behaviour of the program.
Your simulation does not follow the semantics of the x86 language,
because it *does* stop the simulation halfway the simulation.
So it is wrong according to your own criteria.

DDD has nothing to do with it. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.

HHH is unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.

Your HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed N-1 cycles,
because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct
simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria you
stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

No matter how much you want it to be correct, or how many times you
repeat that it is correct, it does not change the fact that such a
simulation is incorrect, because it is unable to reach the end.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.
olcott
2024-07-13 13:04:01 UTC
Permalink
Post by Fred. Zwarts
Post by olcott
Post by Fred. Zwarts
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input
before it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES
occur per the definition of the x86 instruction set, as we have not
reached a "termial" instruction that stops behavior, will see the
HHH(DDD) that DDD called continuing to simulate its input to the
point that this one was defined to stop, and then returns 0 to DDDD
and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the
ACTUAL FULL behavior of DDD as defined by the full definition of
the x86 insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that simulates
itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
You have a wrong understanding of the semantics of the x86 language. You
think that the x86 language specifies that skipping instructions do not
change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.

As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 13:15:17 UTC
Permalink
Post by olcott
Post by Fred. Zwarts
Post by olcott
Post by Fred. Zwarts
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior
of the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning
to their caller, they establish that behavior for ALL copies of
that HHH, even the one that DDD calls, which shows that DDD will
be halting, even though HHH stopped its observation of the input
before it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES
occur per the definition of the x86 instruction set, as we have
not reached a "termial" instruction that stops behavior, will see
the HHH(DDD) that DDD called continuing to simulate its input to
the point that this one was defined to stop, and then returns 0 to
DDDD and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the
ACTUAL FULL behavior of DDD as defined by the full definition of
the x86 insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get
around to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that
simulates itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
You have a wrong understanding of the semantics of the x86 language.
You think that the x86 language specifies that skipping instructions
do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.

You seem to think it is ok for them to lie if they don't know the right
answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.

YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider actually
has, but look at the input that would have been given to a different
decider to show that one wrong.
olcott
2024-07-13 13:27:29 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
You have a wrong understanding of the semantics of the x86 language.
You think that the x86 language specifies that skipping instructions
do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.
You seem to think it is ok for them to lie if they don't know the right
answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.
YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider actually
has, but look at the input that would have been given to a different
decider to show that one wrong.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.

You seem to fail to understand the notion of differing
process contexts. It is a tricky notion for people that
have never done operating system level programming.
https://www.geeksforgeeks.org/context-switch-in-operating-system/
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 14:14:03 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
You have a wrong understanding of the semantics of the x86 language.
You think that the x86 language specifies that skipping instructions
do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.
You seem to think it is ok for them to lie if they don't know the
right answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.
YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider actually
has, but look at the input that would have been given to a different
decider to show that one wrong.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
But every DDD that calls an HHH that aborts its simulation of a copy of
that DDD and returns is shown to be halting, not non-halting. It is just
that HHH can't see that behavior becuase it aborted its simulation.

"DDD" is the program, not the partial emulation of it, so it halts even
if HHHs PARTIAL simulaton of it ddn't reach thatpoint.
Post by olcott
You seem to fail to understand the notion of differing
process contexts. It is a tricky notion for people that
have never done operating system level programming.
https://www.geeksforgeeks.org/context-switch-in-operating-system/
Which is something I don't have problems with, since I have written my
own operating systems.

Your problem is you don't seem to understand is that all copies of a
given deterministic program act the same and that the simulator aborting
its simulation doesn't actually stop the behavior of the program it is
emulating, as it can't affect that context that the program actually
runs in.


You seem to have a fundamental issue with understanding the difference
between truth, which is what actually happens with the thing, and the
results of finite partial observation of that thing that produces
partial knowledge. This just breaks your whole concept of logic.
olcott
2024-07-13 14:35:17 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
You have a wrong understanding of the semantics of the x86
language. You think that the x86 language specifies that skipping
instructions do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.
You seem to think it is ok for them to lie if they don't know the
right answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.
YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider
actually has, but look at the input that would have been given to a
different decider to show that one wrong.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
But every DDD that calls an HHH that aborts its simulation of a copy of
that DDD and returns is shown to be halting, not non-halting. It is just
that HHH can't see that behavior becuase it aborted its simulation.
"DDD" is the program, not the partial emulation of it, so it halts even
if HHHs PARTIAL simulaton of it ddn't reach thatpoint.
Post by olcott
You seem to fail to understand the notion of differing
process contexts. It is a tricky notion for people that
have never done operating system level programming.
https://www.geeksforgeeks.org/context-switch-in-operating-system/
Which is something I don't have problems with, since I have written my
own operating systems.
Your problem is you don't seem to understand is that all copies of a
given deterministic program act the same
By this same reasoning when you are hungry and eat until
you are full you are still hungry because you are still
yourself.

After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 14:48:43 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
You have a wrong understanding of the semantics of the x86
language. You think that the x86 language specifies that skipping
instructions do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.
You seem to think it is ok for them to lie if they don't know the
right answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.
YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider
actually has, but look at the input that would have been given to a
different decider to show that one wrong.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
But every DDD that calls an HHH that aborts its simulation of a copy
of that DDD and returns is shown to be halting, not non-halting. It is
just that HHH can't see that behavior becuase it aborted its simulation.
"DDD" is the program, not the partial emulation of it, so it halts
even if HHHs PARTIAL simulaton of it ddn't reach thatpoint.
Post by olcott
You seem to fail to understand the notion of differing
process contexts. It is a tricky notion for people that
have never done operating system level programming.
https://www.geeksforgeeks.org/context-switch-in-operating-system/
Which is something I don't have problems with, since I have written my
own operating systems.
Your problem is you don't seem to understand is that all copies of a
given deterministic program act the same
By this same reasoning when you are hungry and eat until
you are full you are still hungry because you are still
yourself.
Not at all, I am not a deterministic entity like HHH and DDD.
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD, not the behavior
that HHH sees in its emulation of DDD. The first is an objective
standard, suitable for trying to decide, the second is a subjective
standard, which can not be an objective mapping of just DDD, which is
what a decider given that input must be asked to decide on.

So, your logic is just invalid.
olcott
2024-07-13 15:15:13 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
You have a wrong understanding of the semantics of the x86
language. You think that the x86 language specifies that skipping
instructions do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.
You seem to think it is ok for them to lie if they don't know the
right answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.
YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider
actually has, but look at the input that would have been given to a
different decider to show that one wrong.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
But every DDD that calls an HHH that aborts its simulation of a copy
of that DDD and returns is shown to be halting, not non-halting. It
is just that HHH can't see that behavior becuase it aborted its
simulation.
"DDD" is the program, not the partial emulation of it, so it halts
even if HHHs PARTIAL simulaton of it ddn't reach thatpoint.
Post by olcott
You seem to fail to understand the notion of differing
process contexts. It is a tricky notion for people that
have never done operating system level programming.
https://www.geeksforgeeks.org/context-switch-in-operating-system/
Which is something I don't have problems with, since I have written
my own operating systems.
Your problem is you don't seem to understand is that all copies of a
given deterministic program act the same
By this same reasoning when you are hungry and eat until
you are full you are still hungry because you are still
yourself.
Not at all, I am not a deterministic entity like HHH and DDD.
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.

Try and use this free will to make a square circle.
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 15:25:51 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
You have a wrong understanding of the semantics of the x86
language. You think that the x86 language specifies that
skipping instructions do not change the behaviour of a program.
You have the wrong understanding of a decider.
All deciders are required to halt.
And are required to give the correct answer.
You seem to think it is ok for them to lie if they don't know the
right answer.
Post by olcott
As soon as the decider correctly determines that itself
would never halt unless is aborts the simulation of its
input the decider is required to abort this simulation.
Which it never does, so it gives up and guesses.
YOU lie that it does correctly determines the answer, but that is
because you lie and don't look at the input that this decider
actually has, but look at the input that would have been given to
a different decider to show that one wrong.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
But every DDD that calls an HHH that aborts its simulation of a copy
of that DDD and returns is shown to be halting, not non-halting. It
is just that HHH can't see that behavior becuase it aborted its
simulation.
"DDD" is the program, not the partial emulation of it, so it halts
even if HHHs PARTIAL simulaton of it ddn't reach thatpoint.
Post by olcott
You seem to fail to understand the notion of differing
process contexts. It is a tricky notion for people that
have never done operating system level programming.
https://www.geeksforgeeks.org/context-switch-in-operating-system/
Which is something I don't have problems with, since I have written
my own operating systems.
Your problem is you don't seem to understand is that all copies of a
given deterministic program act the same
By this same reasoning when you are hungry and eat until
you are full you are still hungry because you are still
yourself.
Not at all, I am not a deterministic entity like HHH and DDD.
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe with a
lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need to
switch to Red Herring because you lost the argument.

Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.

You just don't even know the problem you claim to be working on, because
you are jut THAT STUPID.
olcott
2024-07-13 15:34:36 UTC
Permalink
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe with a
lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need to
switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.

As soon as HHH correctly determines that it must abort the
simulation of its input to prevent its own infinite execution
HHH is necessarily correct to reject this finite string as
specifying non-halting behavior.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 16:05:34 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe with
a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need to
switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.

That is all that is needed.

You just don't understand the essential nature of how logic works.
Post by olcott
As soon as HHH correctly determines that it must abort the
simulation of its input to prevent its own infinite execution
HHH is necessarily correct to reject this finite string as
specifying non-halting behavior.
But it doesn't ever do that.

It determines that some other HHH with some other version of the input
DDD doesn't halt.

Any HHH that aborts, does so because it reached the point it was
programmed to do so. The PROGRAMMER is the one that needs to decide on
the algorithm to correctly determine that condition, which there,
unfortunately for you since you decided to take that job, doesn't exist.

When you design HHH, you need to think about EVERY possible input, since
that is what the problem statement says, INCLUDING inputs that happen to
be based on you. Because of that, everytime you make change in your
design based on the behavior of one input, the "pathological" input you
need to handle changes. This ability of pathological relationships, and
the fact that you need to be designing a causal program means that you
have yourself stuck in a corner. The program that the input represents
is a fixed program once we get to that point, and thus when you argue
about "NO HHH" can get this input right, you are wrong, as version that
run longer on THIS input, based on this HHH will reach the final state
and show this NHH was wrong, but those HHHs also have a DDD that was
based on them that they will get wrong.

Bsically, you are looking at your infinite set wrong, HHH can't justify
its behavior based on the actions of a DIFFERENT input, but you logic
tries to do that.
olcott
2024-07-13 16:19:04 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe with
a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need
to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 16:31:37 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe
with a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need
to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
Maybe you need to stop eating so much Herring with Red Sauce, and focus
on some of the errors pointed out in your logic rather than just
ignoring them, which, in effect, just admitss that you have no idea how
to get out of your lies.
olcott
2024-07-13 16:43:49 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe
with a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and need
to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a pathetic
ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
Maybe you need to stop eating so much Herring with Red Sauce, and focus
on some of the errors pointed out in your logic rather than just
ignoring them, which, in effect, just admitss that you have no idea how
to get out of your lies.
You continue to stupidly insist that DDD specifies
the same behavior before its simulation has been
aborted than after it simulation has been aborted.

Now you stupidly insist that this is not analogous
to being hungry before you have eaten and not being
hungry after you have eaten.

That you call me a liar will send you to Hell.
I don't want that.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 17:20:22 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe
with a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and
need to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a
pathetic ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
Maybe you need to stop eating so much Herring with Red Sauce, and
focus on some of the errors pointed out in your logic rather than just
ignoring them, which, in effect, just admitss that you have no idea
how to get out of your lies.
You continue to stupidly insist that DDD specifies
the same behavior before its simulation has been
aborted than after it simulation has been aborted.
And you think that HHH partial observation of the some of the behavior
of DDD affects it.

The behavior that HHH does with respect to its CALLER affects DDD, since
DDD calls HHH.

The behavior that HHH does with respect to its simulation does not,
except as far as it affects it behavior with resoect to its caller.

HHH aborting its simulation does NOTHING to the behavior of DDD, except
to establish that the HHH that DDD calls will abort its simulation.

DDD and HHH have code that defines the behavior of both of them.

If HHH aborts its simulation, for ANY REASON, and returns, then the DDD
tha calls that HHH will halt.

Thus, ANY HHH that reports HHH(DDD) is non-halting, is BY DEFINTION, wrong.
Post by olcott
Now you stupidly insist that this is not analogous
to being hungry before you have eaten and not being
hungry after you have eaten.
And you don't seem to understand how determinism works.

I know that if I eat I will become not hunger, even before I start to
eat, and
Post by olcott
That you call me a liar will send you to Hell.
I don't want that.
But I don't lie, you do.

You just don't understand even the basics of that which you talk about,
which is why you keep on need to go to totally unrelated ideas.
olcott
2024-07-13 18:22:56 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe
with a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and
need to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a
pathetic ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
Maybe you need to stop eating so much Herring with Red Sauce, and
focus on some of the errors pointed out in your logic rather than
just ignoring them, which, in effect, just admitss that you have no
idea how to get out of your lies.
You continue to stupidly insist that DDD specifies
the same behavior before its simulation has been
aborted than after it simulation has been aborted.
And you think that HHH partial observation of the some of the behavior
of DDD affects it.
No stupid you know that I didn't say anything like that.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 18:37:07 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
In other words when you are very hungry you have the
free will to decide that you are not hungry at all
and never eat anything ever again with no ill effects
to your health what-so-ever.
Just shows that though I have free will, I am also in a Universe
with a lot of determinism.
Post by olcott
Try and use this free will to make a square circle.
Nope, just shows you don't know what you are talking about and
need to switch to Red Herring because you lost the argument.
Face it, all you have proved is that you are nothing but a
pathetic ignorant pathological lying idiot.
Post by olcott
Post by Richard Damon
Post by olcott
After HHH has already aborted its simulation of DDD
and returns to the DDD that called it is not the same
behavior as DDD simulated by HHH that must be aborted.
Right, and the question is about the behavior of DDD,
the input finite string not an external process that HHH
has no access to.
Right, but the program it represents, and the question is about IS.
HHH cannot be correctly required to report on the behavior
of an external process that it has no access to.
But it has access to the complete representation of it.
In other words you are still hungry AFTER you filled
yourself with food BECAUSE you are the same person
thus the change in process state DOES NOT MATTER.
Maybe you need to stop eating so much Herring with Red Sauce, and
focus on some of the errors pointed out in your logic rather than
just ignoring them, which, in effect, just admitss that you have no
idea how to get out of your lies.
You continue to stupidly insist that DDD specifies
the same behavior before its simulation has been
aborted than after it simulation has been aborted.
And you think that HHH partial observation of the some of the behavior
of DDD affects it.
No stupid you know that I didn't say anything like that.
So HHH has NO evidence to back its claims?

What other evidence does HHH actually have?

Remember, your claim is that DDD does not halt, even if HHH decides that
DDD is non-halting and returns.

Since it is clear that just running this DDD that calls the HHH(DDD)
that aborts and returns will cause that DDD to return.

What makes that DDD not halt?

I guess you are just admitting that you are nothing but a LIAR.

Richard Damon
2024-07-13 13:15:23 UTC
Permalink
Post by olcott
Post by Fred. Zwarts
Post by olcott
Post by Richard Damon
Post by olcott
We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.
Which means the only "correct emulation" that tells the behavior of
the program at the input is a non-aborted one.
Post by olcott
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
When N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.
And thus HHH that do that know only the first N steps of the
behavior of DDD, which continues per the definition of the x86
instruction set until the COMPLETE emulation (or direct execution)
reaches a terminal instruction.
Post by olcott
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
And thus, the subset that only did a finite number of steps and
aborted its emulation on a non-terminal instrucition only have
partial knowledge of the behavior of their DDD, and by returning to
their caller, they establish that behavior for ALL copies of that
HHH, even the one that DDD calls, which shows that DDD will be
halting, even though HHH stopped its observation of the input before
it gets to that point.
Post by olcott
The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.
No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.
Wrong. EVERY DDD of an HHH that simulated its input for only a
finite number of steps WILL halt becuase it will reach its final
return.
The HHH that simulated it for only a finite number of steps, only
learned that finite number of steps of the behaivor, and in EVERY
case, when we look at the behavior past that point, which DOES occur
per the definition of the x86 instruction set, as we have not
reached a "termial" instruction that stops behavior, will see the
HHH(DDD) that DDD called continuing to simulate its input to the
point that this one was defined to stop, and then returns 0 to DDDD
and then DDD returning and ending the behavior.
You continue to stupidly confuse the PARTIAL observation that HHH
does of the behavior of DDD by its PARTIAL emulation with the ACTUAL
FULL behavior of DDD as defined by the full definition of the x86
insttuction set.
Post by olcott
Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.
Nope.
NONE Of them CORRECTLY rejected itS DDD as non-halting and you are
shown to be ignorant of what you are talking about.
The HHH that did a partial emulation got the wrong answer, because
THEIR DDD will halt. and the HHH that doen't abort never get around
to rejecting its DDD as non-halting.
*Here is the gist of my proof it is irrefutable*
When no DDD of every HHH/DDD that can possibly exist
halts then each HHH that rejects its DDD as non-halting
is necessarily correct.
*No double-talk and weasel words can overcome that*
This is double talk, because no HHH can possibly exist that simulates
itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
No your ideas of the x86 language contradicts the actual sematic of the
language.

Where does it ever even imply that a partial emulation correctly
predicts the behavior of the full program?

This is just another of your nonsense "Diagonalization" lies, that you
can not show what youy claim because it is not there.
olcott
2024-07-13 13:30:56 UTC
Permalink
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
This is double talk, because no HHH can possibly exist that simulates
itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
No your ideas of the x86 language contradicts the actual sematic of the
language.
Where does it ever even imply that a partial emulation correctly
predicts the behavior of the full program?
You switch from disagreeing with the x86 language to disagreeing
that all deciders must halt.

*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-07-13 14:14:14 UTC
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Fred. Zwarts
This is double talk, because no HHH can possibly exist that
simulates itself correctly.
Your definition of correct contradicts the semantics of
the x86 language making it wrong.
No your ideas of the x86 language contradicts the actual sematic of
the language.
Where does it ever even imply that a partial emulation correctly
predicts the behavior of the full program?
You switch from disagreeing with the x86 language to disagreeing
that all deciders must halt.
*This proves that every rebuttal is wrong somewhere*
No DDD instance of each HHH/DDD pair of the infinite set of
every HHH/DDD pair ever reaches past its own machine address of
0000216b and halts thus proving that every HHH is correct to
reject its input DDD as non-halting.
No, because it has been shown that EVERY DDD instance that is based on
ANY of the HHHs that abort their emulation and return will also reach
past that address and return. It is only the PARTIAL EMULATION of them
by HHH which does not and that is NOT a "correct emulation" per the x86
language as it breaks the "and the next instruction will execute rule"

The fact that HHH has been designed to do this to meet the requirement
to be a decider does not remove the requirement to answer per the
behavior specified by the x86 language, which the decider now does not know.

Your "Logic" seems to be based on the concept that it is ok to lie if
that is all you know how to do. That means yout logic just is not correct.

Your assumption that you can not be wrong just makes you wrong, as you
think it is ok to assume things that are just not true. So, you are just
lying to yourself and believing those lies.
Loading...