On 7/27/2024 1:54 AM, Mikko wrote:
On 2024-07-26 13:58:54 +0000, olcott said:
On 7/26/2024 3:05 AM, Mikko wrote:
On 2024-07-24 13:38:08 +0000, olcott said:
That is off topic. I am only referring to a sequence of
1 to N x86 machine language instructions simulated according
to the x86 semantic meaning of these instructions.
No, it isn't. Abortion of simulation is a deviation form x86 macine
language semantics. What I ask about does not deviate more.
In other words you are saying that it is absolutely impossible
to make an x86 program that is an x86 emulator that correctly
emulates a finite number of instructions of non-terminating
input x86 machine code.
You are lying again. That is not the same in other words, and I am
not saying what you falsely claim.
If a simulator correctly simulates a finite number of instructions
where x86 program specifies an execution of an infinite number of
instructions then the simulation deviates from x86 semantics at the
point where the simulation stops but the x86 semantics specify
countinuation.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider *H correctly simulates its input D*
*until H correctly determines that its simulated D would never*
*stop running unless aborted* then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Since you knew that all along I can't take your reply above as
anything but a strawman deception attempt at rebuttal.
On 8/1/2024 3:20 AM, Mikko wrote:
On 2024-07-30 21:35:20 +0000, olcott said:
On 7/27/2024 1:54 AM, Mikko wrote:
On 2024-07-26 13:58:54 +0000, olcott said:
On 7/26/2024 3:05 AM, Mikko wrote:
On 2024-07-24 13:38:08 +0000, olcott said:
That is off topic. I am only referring to a sequence of
1 to N x86 machine language instructions simulated according
to the x86 semantic meaning of these instructions.
No, it isn't. Abortion of simulation is a deviation form x86 macine >>>>>> language semantics. What I ask about does not deviate more.
In other words you are saying that it is absolutely impossible
to make an x86 program that is an x86 emulator that correctly
emulates a finite number of instructions of non-terminating
input x86 machine code.
You are lying again. That is not the same in other words, and I am
not saying what you falsely claim.
If a simulator correctly simulates a finite number of instructions
where x86 program specifies an execution of an infinite number of
instructions then the simulation deviates from x86 semantics at the
point where the simulation stops but the x86 semantics specify
countinuation.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider *H correctly simulates its input D*
*until H correctly determines that its simulated D would never* >>> *stop running unless aborted* then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Since you knew that all along I can't take your reply above as
anything but a strawman deception attempt at rebuttal.
That you cannot take my reply as what it is does not make my
reply anything other than what it is.
However, you should note that Sipser's agreement is not published in
a respectable publication you cannot use it in a publishable article.
Instead, you may quote what he has actually published.
He gave me permission to quote him.
Several people noted that it is is a freaking tautology.
On 8/1/2024 3:20 AM, Mikko wrote:
On 2024-07-30 21:35:20 +0000, olcott said:
On 7/27/2024 1:54 AM, Mikko wrote:
On 2024-07-26 13:58:54 +0000, olcott said:
On 7/26/2024 3:05 AM, Mikko wrote:
On 2024-07-24 13:38:08 +0000, olcott said:
That is off topic. I am only referring to a sequence of
1 to N x86 machine language instructions simulated according
to the x86 semantic meaning of these instructions.
No, it isn't. Abortion of simulation is a deviation form x86 macine >>>>>> language semantics. What I ask about does not deviate more.
In other words you are saying that it is absolutely impossible
to make an x86 program that is an x86 emulator that correctly
emulates a finite number of instructions of non-terminating
input x86 machine code.
You are lying again. That is not the same in other words, and I am
not saying what you falsely claim.
If a simulator correctly simulates a finite number of instructions
where x86 program specifies an execution of an infinite number of
instructions then the simulation deviates from x86 semantics at the
point where the simulation stops but the x86 semantics specify
countinuation.
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider *H correctly simulates its input D*
*until H correctly determines that its simulated D would never* >>> *stop running unless aborted* then
H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
Since you knew that all along I can't take your reply above as
anything but a strawman deception attempt at rebuttal.
That you cannot take my reply as what it is does not make my
reply anything other than what it is.
However, you should note that Sipser's agreement is not published in
a respectable publication you cannot use it in a publishable article.
Instead, you may quote what he has actually published.
He gave me permission to quote him.
Several people noted that it is is a freaking tautology.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 152:54:27 |
| Calls: | 10,383 |
| Files: | 14,054 |
| Messages: | 6,417,825 |