On 8/3/2024 11:12 AM, Richard Damon wrote:
On 8/3/24 12:03 PM, olcott wrote:
On 8/3/2024 10:33 AM, Richard Damon wrote:
On 8/3/24 10:26 AM, olcott wrote:
On 8/3/2024 9:04 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 15:50 schreef olcott:
On 8/3/2024 3:14 AM, Fred. Zwarts wrote:
Op 02.aug.2024 om 22:57 schreef olcott:
Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?
void DDD()
{
HHH(DDD);
return;
}
Which proves that the simulation is incorrect.
When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?
I do not disagree.
When are you going to understand that it is a deviation of the
semantics of the x86 language to skip instructions of a halting
program,
HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process.
If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.
If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.
Nope, the PARTIAL SIMULATION of DDD never reaches the return
instruction.
For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.
The SIMULATION of DDD never reaches the return instruction.
Great! Finally.
When we understand that the return instruction is halt state
of DDD then DDD correctly simulated by HHH never halts.
On 8/3/2024 11:32 AM, Richard Damon wrote:
On 8/3/24 12:16 PM, olcott wrote:
On 8/3/2024 11:12 AM, Richard Damon wrote:No, you are just proving you are incapable of learning.
On 8/3/24 12:03 PM, olcott wrote:
On 8/3/2024 10:33 AM, Richard Damon wrote:
On 8/3/24 10:26 AM, olcott wrote:
On 8/3/2024 9:04 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 15:50 schreef olcott:
On 8/3/2024 3:14 AM, Fred. Zwarts wrote:
Op 02.aug.2024 om 22:57 schreef olcott:
Who here is too stupid to know that DDD correctly simulated >>>>>>>>>>> by HHH cannot possibly reach its own return instruction? >>>>>>>>>>>
void DDD()
{
HHH(DDD);
return;
}
Which proves that the simulation is incorrect.
When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?
I do not disagree.
When are you going to understand that it is a deviation of the >>>>>>>> semantics of the x86 language to skip instructions of a halting >>>>>>>> program,
HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process. >>>>>>>
If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.
If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.
Nope, the PARTIAL SIMULATION of DDD never reaches the return
instruction.
For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.
The SIMULATION of DDD never reaches the return instruction.
Great! Finally.
When we understand that the return instruction is halt state
of DDD then DDD correctly simulated by HHH never halts.
The PARTIAL simulation of DDD done by HHH doesn't reach the return
instruction.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
So you are saying that the infinite one does?
On 8/3/2024 12:45 PM, Richard Damon wrote:
On 8/3/24 12:35 PM, olcott wrote:
On 8/3/2024 11:32 AM, Richard Damon wrote:
On 8/3/24 12:16 PM, olcott wrote:
On 8/3/2024 11:12 AM, Richard Damon wrote:No, you are just proving you are incapable of learning.
On 8/3/24 12:03 PM, olcott wrote:
On 8/3/2024 10:33 AM, Richard Damon wrote:
On 8/3/24 10:26 AM, olcott wrote:
On 8/3/2024 9:04 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 15:50 schreef olcott:
On 8/3/2024 3:14 AM, Fred. Zwarts wrote:
Op 02.aug.2024 om 22:57 schreef olcott:
Who here is too stupid to know that DDD correctly simulated >>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction? >>>>>>>>>>>>>
void DDD()
{
HHH(DDD);
return;
}
Which proves that the simulation is incorrect.
When are you going to understand that you are not allowed >>>>>>>>>>> to disagree with the semantics of the x86 language?
I do not disagree.
When are you going to understand that it is a deviation of the >>>>>>>>>> semantics of the x86 language to skip instructions of a
halting program,
HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process. >>>>>>>>>
If it does this an infinite number of times the simulated DDD >>>>>>>>> never reaches its own return instruction.
If it does this a googolplex number of times the simulated DDD >>>>>>>>> never reaches its own return instruction.
Nope, the PARTIAL SIMULATION of DDD never reaches the return
instruction.
For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.
The SIMULATION of DDD never reaches the return instruction.
Great! Finally.
When we understand that the return instruction is halt state
of DDD then DDD correctly simulated by HHH never halts.
The PARTIAL simulation of DDD done by HHH doesn't reach the return
instruction.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
So you are saying that the infinite one does?
I said for the HHH's that do a partial simulation it does.
You said: "doesn't" you did not say: "does"
You can't even accurately quote your own self?
Every DDD correctly emulated by any HHH for a finite or
infinite number of steps never reaches its own "return"
halt state.
On 8/3/2024 1:09 PM, Richard Damon wrote:
On 8/3/24 1:58 PM, olcott wrote:
Every DDD correctly emulated by any HHH for a finite or
infinite number of steps never reaches its own "return"
halt state.
Nope. And you statment is just a incoherent statement, as no partial
simulaitoni for a finite number of steps is "correct".
In other words you are trying to get away with saying that
when N instructions are correctly emulated by HHH that none
of these correctly emulated instructions were correctly emulated.
On top of this you are deceitfully trying to get way
with saying that when and infinite number of instructions
of DDD are correctly emulated by HHH that this emulated
DDD reaches its "return" instruction halt state and halts.
Liar Liar swearing your allegiance to the father of
lies. I wonder what your pastor would say about this?
On 8/3/2024 1:58 PM, Richard Damon wrote:
On 8/3/24 2:33 PM, olcott wrote:
On 8/3/2024 1:09 PM, Richard Damon wrote:
On 8/3/24 1:58 PM, olcott wrote:
Every DDD correctly emulated by any HHH for a finite or
infinite number of steps never reaches its own "return"
halt state.
Nope. And you statment is just a incoherent statement, as no partial
simulaitoni for a finite number of steps is "correct".
In other words you are trying to get away with saying that
when N instructions are correctly emulated by HHH that none
of these correctly emulated instructions were correctly emulated.
No, I am saying that the result is NOT the final result that the x86
semantics says will happen, because the x86 semantics says it does not
stop therme
The x86 semantics says that DDD correctly emulated by HHH
never reaches its own halt state of "return" in any finite
or infinite number of steps.
On 8/3/2024 3:00 PM, Richard Damon wrote:...
On 8/3/24 3:06 PM, olcott wrote:
On 8/3/2024 1:58 PM, Richard Damon wrote:
On 8/3/24 2:33 PM, olcott wrote:
On 8/3/2024 1:09 PM, Richard Damon wrote:
On 8/3/24 1:58 PM, olcott wrote:
Every DDD correctly emulated by any HHH for a finite or
infinite number of steps never reaches its own "return"
halt state.
Nope. And you statment is just a incoherent statement, as no
partial simulaitoni for a finite number of steps is "correct".
In other words you are trying to get away with saying that
when N instructions are correctly emulated by HHH that none
of these correctly emulated instructions were correctly emulated.
No, I am saying that the result is NOT the final result that the x86
semantics says will happen, because the x86 semantics says it does
not stop therme
The x86 semantics says that DDD correctly emulated by HHH
never reaches its own halt state of "return" in any finite
or infinite number of steps.
But only if HHH DOES correct emulation that never aborts.
The x86 semantics says that
*DDD correctly emulated by HHH*
*DDD correctly emulated by HHH*
never reaches its own halt state of
"return" in any finite
or infinite number of steps.
On 8/3/2024 3:45 PM, Richard Damon wrote:
On 8/3/24 4:14 PM, olcott wrote:
On 8/3/2024 3:00 PM, Richard Damon wrote:...
On 8/3/24 3:06 PM, olcott wrote:
On 8/3/2024 1:58 PM, Richard Damon wrote:
On 8/3/24 2:33 PM, olcott wrote:
On 8/3/2024 1:09 PM, Richard Damon wrote:No, I am saying that the result is NOT the final result that the
On 8/3/24 1:58 PM, olcott wrote:
Every DDD correctly emulated by any HHH for a finite or
infinite number of steps never reaches its own "return"
halt state.
Nope. And you statment is just a incoherent statement, as no
partial simulaitoni for a finite number of steps is "correct". >>>>>>>>
In other words you are trying to get away with saying that
when N instructions are correctly emulated by HHH that none
of these correctly emulated instructions were correctly emulated. >>>>>>
x86 semantics says will happen, because the x86 semantics says it
does not stop therme
The x86 semantics says that DDD correctly emulated by HHH
never reaches its own halt state of "return" in any finite
or infinite number of steps.
But only if HHH DOES correct emulation that never aborts.
The x86 semantics says that
*DDD correctly emulated by HHH*
*DDD correctly emulated by HHH*
never reaches its own halt state of
"return" in any finite
or infinite number of steps.
Yes, but only for an HHH that corectly emulates its input, which means
it never aborts, and only for the DDD that calls THAT HHH.
*No you damned liar it does not mean that*
It means that when 0 to infinity steps of DDD are
correctly emulated by its corresponding HHH not a
single DDD ever reaches its own halt state of "return".
This means that every HHH can take a wild guess that
its DDD does not halt and it would be correct because
we exhaustively covered every damn one of them.
On 8/3/2024 4:48 PM, Richard Damon wrote:
On 8/3/24 4:52 PM, olcott wrote:
On 8/3/2024 3:45 PM, Richard Damon wrote:
On 8/3/24 4:14 PM, olcott wrote:
On 8/3/2024 3:00 PM, Richard Damon wrote:...
On 8/3/24 3:06 PM, olcott wrote:
On 8/3/2024 1:58 PM, Richard Damon wrote:
On 8/3/24 2:33 PM, olcott wrote:
On 8/3/2024 1:09 PM, Richard Damon wrote:No, I am saying that the result is NOT the final result that the >>>>>>>> x86 semantics says will happen, because the x86 semantics says >>>>>>>> it does not stop therme
On 8/3/24 1:58 PM, olcott wrote:
Every DDD correctly emulated by any HHH for a finite or
infinite number of steps never reaches its own "return"
halt state.
Nope. And you statment is just a incoherent statement, as no >>>>>>>>>> partial simulaitoni for a finite number of steps is "correct". >>>>>>>>>>
In other words you are trying to get away with saying that
when N instructions are correctly emulated by HHH that none
of these correctly emulated instructions were correctly emulated. >>>>>>>>
The x86 semantics says that DDD correctly emulated by HHH
never reaches its own halt state of "return" in any finite
or infinite number of steps.
But only if HHH DOES correct emulation that never aborts.
The x86 semantics says that
*DDD correctly emulated by HHH*
*DDD correctly emulated by HHH*
never reaches its own halt state of
"return" in any finite
or infinite number of steps.
Yes, but only for an HHH that corectly emulates its input, which
means it never aborts, and only for the DDD that calls THAT HHH.
*No you damned liar it does not mean that*
Why not? That *IS* the definition of correct emulation as defined by
the concept of a UTM, which is the only definition of emulation that
lets you get the actual full behavior of the program given.
It means that when 0 to infinity steps of DDD are
correctly emulated by its corresponding HHH not a
single DDD ever reaches its own halt state of "return".
Where do you get that from?
is it another lie that you took out of your ass?
Partial emulation is not correct emulation for the purposes of
determining full behavior of a program.
When every possible finite or infinite emulation of DDD
by HHH according to the semantics of the x86 language
never reaches the final state of DDD then each HHH can
correctly take a wild guess that DDD never halts.
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a *DIFFERENT*
input, so they don't prove anything together except that each one
didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a *DIFFERENT*
input, so they don't prove anything together except that each one
didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
On 8/3/2024 11:32 AM, Richard Damon wrote:
On 8/3/24 12:16 PM, olcott wrote:
On 8/3/2024 11:12 AM, Richard Damon wrote:No, you are just proving you are incapable of learning.
On 8/3/24 12:03 PM, olcott wrote:
On 8/3/2024 10:33 AM, Richard Damon wrote:
On 8/3/24 10:26 AM, olcott wrote:
On 8/3/2024 9:04 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 15:50 schreef olcott:
On 8/3/2024 3:14 AM, Fred. Zwarts wrote:
Op 02.aug.2024 om 22:57 schreef olcott:
Who here is too stupid to know that DDD correctly simulated >>>>>>>>>>> by HHH cannot possibly reach its own return instruction? >>>>>>>>>>>
void DDD()
{
HHH(DDD);
return;
}
Which proves that the simulation is incorrect.
When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?
I do not disagree.
When are you going to understand that it is a deviation of the >>>>>>>> semantics of the x86 language to skip instructions of a halting >>>>>>>> program,
HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process. >>>>>>>
If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.
If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.
Nope, the PARTIAL SIMULATION of DDD never reaches the return
instruction.
For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.
The SIMULATION of DDD never reaches the return instruction.
Great! Finally.
When we understand that the return instruction is halt state
of DDD then DDD correctly simulated by HHH never halts.
The PARTIAL simulation of DDD done by HHH doesn't reach the return
instruction.
∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
So you are saying that the infinite one does?
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a
*DIFFERENT* input, so they don't prove anything together except
that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it
isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that
reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute
for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
The correct simulation of a halting program halts. A truism.
HHH cannot possibly simulate itself correctly.
So by correctly you must mean that HHH incorrectly
skips the call from DDD to HHH(DDD).
I am happy that you were not a member of our team when we developed
simulators to check the design of big detector systems.
Crash dummy simulators?
Not x86 emulators.
We knew that a simulation is only correct if it matches the reality.
But you seem to think that it is correct that a simulator does not
match the reality.
The reality is that DDD does call HHH(DDD) in recursive
simulation. When you ignore this then you are out-of-touch
with reality.
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a
*DIFFERENT* input, so they don't prove anything together except >>>>>>>> that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it
isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that
reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
On 8/4/24 8:35 AM, olcott wrote:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a
*DIFFERENT* input, so they don't prove anything together except >>>>>>>>> that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it
isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that
reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
But by never aborting, it never gives up, and thus is completely correct.
Yes, it never "finishes" but you can't finish an infinite task, but
since all countable infinities are the same, it "reaches" "completion"
at the same point the input does.
Now, it can't ever give an answer after completing, since that
completion is at infinity, but that isn't the problem for a correct
emulator, only for a decider.
All this shows is that correct (and complete) emulation can not be the
method used to halt decide.
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute
for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
On 8/4/2024 1:45 PM, Richard Damon wrote:
On 8/4/24 8:35 AM, olcott wrote:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a
*DIFFERENT* input, so they don't prove anything together
except that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it >>>>>> isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that
reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
But by never aborting, it never gives up, and thus is completely correct.
The bottom line here is that you are requiring the impossible
thus making you necessarily incorrect.
Far worse than that you seem to be dishonest by never
admitting the truth that DDD correctly emulated by any
HHH cannot possibly reach its own "return" instruction.
Yes, it never "finishes" but you can't finish an infinite task, but
since all countable infinities are the same, it "reaches" "completion"
at the same point the input does.
Now, it can't ever give an answer after completing, since that
completion is at infinity, but that isn't the problem for a correct
emulator, only for a decider.
All this shows is that correct (and complete) emulation can not be the
method used to halt decide.
Yet again being dishonest by requiring a complete simulation
of an infinite computation.
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute
for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
DDD emulated by HHH a googleplex levels deep is included
in DDD emulated by HHH.
Yo keep screwing around trying to twist the meaning of the
actual words that I say.
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a *DIFFERENT* >>>>>>>> input, so they don't prove anything together except that each one >>>>>>>> didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it
isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that reaches >>>> its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute
for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
On 2024-08-04 12:35:04 +0000, olcott said:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a
*DIFFERENT* input, so they don't prove anything together except >>>>>>>>> that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it
isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that
reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
No, that is not what the words mean. A complete emulation is one that is continued as long as it can be continued. THe emulation is completed when
all of its instructions are executed. A complete emulaton that can be continues forever is complete but never completed.
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no
substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt
state when its machine code is correctly emulated by HHH.
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no
substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no
substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
Does infinite recursion ever reach its own "return"
instruction halt state?
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no
substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
Does infinite recursion ever reach its own "return"
instruction halt state?
On Mon, 2024-08-05 at 21:25 -0500, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
; ∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
Those that disagree either are totally lacking in even basic
knowledge of C or are liars.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
Does infinite recursion ever reach its own "return"
instruction halt state?
All do not matter. Since you modified the HP problem, you know you are not solving
the halting problem. It is POO Problem.
On 8/5/2024 9:31 PM, wij wrote:
On Mon, 2024-08-05 at 21:25 -0500, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:>>>> ∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>> a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
Those that disagree either are totally lacking in even basic
knowledge of C or are liars.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
Does infinite recursion ever reach its own "return"
instruction halt state?
All do not matter. Since you modified the HP problem, you know you are
not solving
the halting problem. It is POO Problem.
It may seem that way if you make sure to not pay enough attention.
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
(Of course, everything depends on what you take Sipser's quote to be saying. I choose to interpret it as I'm pretty confident that Sipser intended, under which the first half is mpst certainly NOT met!)
Mike.
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
(Of course, everything depends on what you take Sipser's quote to be saying. I choose to interpret it as I'm pretty confident that Sipser intended, under which the first half is mpst certainly NOT met!)
Mike.
On 8/5/24 11:21 PM, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>> Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
(Of course, everything depends on what you take Sipser's quote to be
saying. I choose to interpret it as I'm pretty confident that Sipser
intended, under which the first half is mpst certainly NOT met!)
Mike.
<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>
void DDD()
{
HHH(DDD);
return;
}
It is certainly the case that DDD correctly simulated by any
HHH cannot possibly stop running unless aborted.
I don't see how any expert in the C language can deny that
with a straight face. Four have affirmed it. Two of these
four have masters degrees in computer science.
The problem is that this only works with the correct definition of
"Correctly Simulated" but not YOUR definition of Correctly Simulated.
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>> a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
(Of course, everything depends on what you take Sipser's quote to be
saying. I choose to interpret it as I'm pretty confident that Sipser
intended, under which the first half is mpst certainly NOT met!)
Mike.
<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>
void DDD()
{
HHH(DDD);
return;
}
It is certainly the case that DDD correctly simulated by any
HHH cannot possibly stop running unless aborted.
I don't see how any expert in the C language can deny that
with a straight face. Four have affirmed it. Two of these
four have masters degrees in computer science.
On 8/5/2024 10:50 PM, Richard Damon wrote:
On 8/5/24 11:21 PM, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state. >>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction >>>>>>>>> halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
(Of course, everything depends on what you take Sipser's quote to be
saying. I choose to interpret it as I'm pretty confident that
Sipser intended, under which the first half is mpst certainly NOT met!) >>>>
Mike.
<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>
void DDD()
{
HHH(DDD);
return;
}
It is certainly the case that DDD correctly simulated by any
HHH cannot possibly stop running unless aborted.
I don't see how any expert in the C language can deny that
with a straight face. Four have affirmed it. Two of these
four have masters degrees in computer science.
The problem is that this only works with the correct definition of
"Correctly Simulated" but not YOUR definition of Correctly Simulated.
I say correctly emulated according to the semantics of the x86
language yet no one besides me understand that.
On 8/5/24 11:58 PM, olcott wrote:
On 8/5/2024 10:50 PM, Richard Damon wrote:
On 8/5/24 11:21 PM, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:void DDD()
reach their own "return" instruction final state. >>>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] >>>>>>>>>>>>>> never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology. >>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>>
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction >>>>>>>>>> halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
(Of course, everything depends on what you take Sipser's quote to
be saying. I choose to interpret it as I'm pretty confident that
Sipser intended, under which the first half is mpst certainly NOT
met!)
Mike.
<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> >>>>
void DDD()
{
HHH(DDD);
return;
}
It is certainly the case that DDD correctly simulated by any
HHH cannot possibly stop running unless aborted.
I don't see how any expert in the C language can deny that
with a straight face. Four have affirmed it. Two of these
four have masters degrees in computer science.
The problem is that this only works with the correct definition of
"Correctly Simulated" but not YOUR definition of Correctly Simulated.
I say correctly emulated according to the semantics of the x86
language yet no one besides me understand that.
Which means you are not allowed to abort it,
On 8/5/2024 11:08 PM, Richard Damon wrote:
On 8/5/24 11:58 PM, olcott wrote:
On 8/5/2024 10:50 PM, Richard Damon wrote:
On 8/5/24 11:21 PM, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of >>>>>>>>>>>>> emulation and not and direct execution.
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:void DDD()
reach their own "return" instruction final state. >>>>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] >>>>>>>>>>>>>>> never
So you are saying that the infinite one does? >>>>>>>>>>>>>>>>>
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology. >>>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>>>
If you mean anything other than what the words mean you wihout >>>>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it >>>>>>>>>>> up.
DDD (above) cannot possibly reach its own "return"
instruction halt
state when its machine code is correctly emulated by HHH. >>>>>>>>>>>
Only because an HHH that does so never returns to anybody. >>>>>>>>>>
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
(Of course, everything depends on what you take Sipser's quote to
be saying. I choose to interpret it as I'm pretty confident that >>>>>> Sipser intended, under which the first half is mpst certainly NOT
met!)
Mike.
<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> >>>>>
void DDD()
{
HHH(DDD);
return;
}
It is certainly the case that DDD correctly simulated by any
HHH cannot possibly stop running unless aborted.
I don't see how any expert in the C language can deny that
with a straight face. Four have affirmed it. Two of these
four have masters degrees in computer science.
The problem is that this only works with the correct definition of
"Correctly Simulated" but not YOUR definition of Correctly Simulated.
I say correctly emulated according to the semantics of the x86
language yet no one besides me understand that.
Which means you are not allowed to abort it,
It never meant that and you know it
*until H correctly determines that its simulated D would never*
*stop running unless aborted*
<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>
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>>>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>> a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state.∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>> Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved criteria
is met.
I was clearly discussing Ben's comments. If I had been
agreeing with your claim I would have said it explicitly - not that
"it's easy enough to say...". I am very confident that if Sipser
actually understood how you were trying to misinterpret his words, he
would quickly point out that they do not apply in the scenario you propose.
Pleas stop misrepresenting my views. [I accept you did not mean to do
this, and you have a basic inability to comprehend what other posters
are actually saying. I'll even accept that I might have expressed
myself more clearly on this occasion!]
In fact, why not go further, and stop altogether your fallacious appeals
to authority? They do not look good to casual readers as they suggest
you have no logical reasoning to argue your case.
Mike.
On 06/08/2024 17:18, olcott wrote:
On 8/6/2024 10:58 AM, Mike Terry wrote:
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:void DDD()
reach their own "return" instruction final state. >>>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] >>>>>>>>>>>>>> never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology. >>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>>
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction >>>>>>>>>> halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved
criteria is met.
That <is> my own criterion. Whatever else could you mean?
Do you still disagree with Ben on this point?
I do not agree that the first half of Sipser's quote has been satisfied
by your scenario. You have misunderstood/misapplied what Sipser agreed to.
Mike.
I don't think that is the shell game. PO really /has/ an H...
(it's trivial to do for this one case) that correctly determines
that P(P) *would* never stop running *unless* aborted.
But H determines (correctly) that D would not halt if it
were not halted. That much is a truism.
On 8/6/2024 10:58 AM, Mike Terry wrote:
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state. >>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>>>> state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved criteria is met.
That <is> my own criterion. Whatever else could you mean?
Do you still disagree with Ben on this point?
On 8/6/2024 11:35 AM, Mike Terry wrote:
On 06/08/2024 17:18, olcott wrote:
On 8/6/2024 10:58 AM, Mike Terry wrote:
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of >>>>>>>>>>>>> emulation and not and direct execution.
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:void DDD()
reach their own "return" instruction final state. >>>>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does? >>>>>>>>>>>>>>>>>
Dreaming again of HHH that does not abort? Dreams are no substitute for facts.
The HHH that aborts and halts, halts. A tautology. >>>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>>>
If you mean anything other than what the words mean you wihout >>>>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction halt >>>>>>>>>>> state when its machine code is correctly emulated by HHH. >>>>>>>>>>>
Only because an HHH that does so never returns to anybody. >>>>>>>>>>
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved criteria is met.
That <is> my own criterion. Whatever else could you mean?
Do you still disagree with Ben on this point?
I do not agree that the first half of Sipser's quote has been satisfied by your scenario. You
have misunderstood/misapplied what Sipser agreed to.
Mike.
So you think that Ben is wrong?
On 06/08/2024 17:18, olcott wrote:
On 8/6/2024 10:58 AM, Mike Terry wrote:
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:void DDD()
reach their own "return" instruction final state. >>>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] >>>>>>>>>>>>>> never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology. >>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>>
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction >>>>>>>>>> halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved
criteria is met.
That <is> my own criterion. Whatever else could you mean?
Do you still disagree with Ben on this point?
I do not agree that the first half of Sipser's quote has been satisfied
by your scenario. You have misunderstood/misapplied what Sipser agreed to.
Mike.
On 06/08/2024 17:44, olcott wrote:
On 8/6/2024 11:35 AM, Mike Terry wrote:
On 06/08/2024 17:18, olcott wrote:
On 8/6/2024 10:58 AM, Mike Terry wrote:
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of >>>>>>>>>>>>>> emulation and not and direct execution.
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:void DDD()
reach their own "return" instruction final state. >>>>>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] >>>>>>>>>>>>>>>> never
So you are saying that the infinite one does? >>>>>>>>>>>>>>>>>>
Dreaming again of HHH that does not abort? Dreams are >>>>>>>>>>>>>>>>> no substitute for facts.
The HHH that aborts and halts, halts. A tautology. >>>>>>>>>>>>>>>>
{
HHH(DDD);
return;
}
That is the right answer to the wrong question. >>>>>>>>>>>>>>>> I am asking whether or not DDD emulated by HHH >>>>>>>>>>>>>>>> reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>>>>
If you mean anything other than what the words mean you wihout >>>>>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look >>>>>>>>>>>> it up.
DDD (above) cannot possibly reach its own "return"
instruction halt
state when its machine code is correctly emulated by HHH. >>>>>>>>>>>>
Only because an HHH that does so never returns to anybody. >>>>>>>>>>>
Do you really not understand that recursive emulation <is> >>>>>>>>>> isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser >>>>>>>> approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this. >>>>>>>
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved
criteria is met.
That <is> my own criterion. Whatever else could you mean?
Do you still disagree with Ben on this point?
I do not agree that the first half of Sipser's quote has been
satisfied by your scenario. You have misunderstood/misapplied what
Sipser agreed to.
Mike.
So you think that Ben is wrong?
Why is it important to you whether I think Ben is wrong? I have said
that I disagree with you that your HHH/DDD scenario satisfies the Sipser criterion.
That disagreement is based on what I believe Sipser was agreeing to.
You have misunderstood/misapplied that agreement. I don't know what Ben thinks Sipser was saying, or whether that's even a relevant factor for
what Ben said.
Ben's statement appears to be based on something else - that you have
some new criterion for "PO-halting", and that if we translate Sipser's
quote to a statement about PO-halting and PO-halt deciders, then / interpreted like that/ he believes the criterion is, or may well be, met.
Since I don't believe that you have any such coherent definition of PO- halting,
I cannot interpret Sipser's statement that way. And if I was
convinced you /did/ have such a coherent definition, I would /still/
believe that Sipser was referring to conventional halt deciders, and
that therefore his criterion is not met by your HHH/DDD.
If you think Ben is supporting your broader claim of some problem with
HP then you are wrong there.
HP is about halting, not PO-halting, and if
we interpret Sipser's quote as refering to what would be a valid PO-
halting decider strategy, then it is nothing to do with halt deciders.
You'll also appreciate by now that I'm not going to engage in fruitless "arguments" with you about your claims.
So there is no requirement for
me to give "evidence" to refute anything you say
- I am not arguing or
debating with you! I have done that in the past, but it made absolutely
no difference to anything, other than using up time.
Mike.
olcott <abc@def.com> writes:
[snip]
I see you're now posting as <abc@def.com>.
def.com is an actual site. I presume you're not actually affiliated
with it. It's entirely possible that there's an actual user there
who has that email address.
Don't do that.
You've recently posted using a gmail address (several of them IIRC)
which I presume will actually reach you.
If you want to post using an invalid address, feel free to do so, but
you should use a clearly fake email address. I suggest something like <olcott@example.com>, which is guaranteed to be invalid.
I see at least 7 of your email addresses in my filters. I don't know
whether you've changed addresses in an attempt to evade filters.
If so, stop it; forcing your posts on people who have decided they
don't want to read them is extremely rude.
On 8/6/2024 10:58 AM, Mike Terry wrote:
On 06/08/2024 04:21, olcott wrote:
On 8/5/2024 10:12 PM, Mike Terry wrote:
On 06/08/2024 03:25, olcott wrote:
On 8/5/2024 8:32 PM, Richard Damon wrote:
On 8/5/24 8:07 PM, olcott wrote:
On 8/5/2024 5:59 PM, Richard Damon wrote:
On 8/5/24 9:49 AM, olcott wrote:
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:When I say DDD emulated by HHH I mean at any level of
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
reach their own "return" instruction final state. >>>>>>>>>>>>>>>∞ instructions of DDD correctly emulated by HHH[∞] never
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no >>>>>>>>>>>>>> substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above, >>>>>>>>>>>
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout >>>>>>>>>> a definition in the beginning of the same message then it is >>>>>>>>>> not reasonable to expect anyone to understand what you mean. >>>>>>>>>> Instead people may think that you mean what you say or that >>>>>>>>>> you don't know what you are saying.
If you don't understand what the word "emulate" means look it up. >>>>>>>>>
DDD (above) cannot possibly reach its own "return" instruction >>>>>>>>> halt
state when its machine code is correctly emulated by HHH.
Only because an HHH that does so never returns to anybody.
Do you really not understand that recursive emulation <is>
isomorphic to infinite recursion?
Not when the emulation is conditional.
Infinite_Recursion() meets the exact same condition that DDD
emulated by HHH makes and you know this. Since you are so
persistently trying to get away contradicting the semantics
of the x86 language the time is coming where there is zero
doubt that this is an honest mistake.
Ben does correctly understand that the first half of the Sipser
approved criteria is met. Even Mike finally admitted this.
I don't recall doing that. Please provide a reference for this.
On 8/2/2024 8:19 PM, Mike Terry wrote:
It's easy enough to say "PO has his own criterion for
halting, which is materially different from the HP condition,
and so we all agree PO is correct by his own criterion...
That is not agreeing that the first half of the Sipser approved
criteria is met.
That <is> my own criterion. Whatever else could you mean?
Do you still disagree with Ben on this point?
I was clearly discussing Ben's comments. If I had been agreeing with
your claim I would have said it explicitly - not that "it's easy
enough to say...". I am very confident that if Sipser actually
understood how you were trying to misinterpret his words, he would
quickly point out that they do not apply in the scenario you propose.
<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>
void DDD()
{
HHH(DDD);
return;
}
I propose that DDD correctly emulated by HHH according to
the semantics of the x86 language would be required to abort
its emulation of its finite string input of the x86 machine
language of DDD.
Do you think that professor Sipser would disagree with the
semantics of the x86 language?
What is every single detail of exactly how you believe
that Professor Sipser could possibly disagree?
Pleas stop misrepresenting my views. [I accept you did not mean to do
this, and you have a basic inability to comprehend what other posters
are actually saying. I'll even accept that I might have expressed
myself more clearly on this occasion!]
In fact, why not go further, and stop altogether your fallacious
appeals to authority? They do not look good to casual readers as they
suggest you have no logical reasoning to argue your case.
Mike.
I resort to appeals to authority to get people to bother to
pay attention to the fact that what I say is a semantic
tautology.
Most everyone starts with the immutable assumption that I
must be incorrect and then looks for some excuse to justify
this assumption.
On 8/5/2024 2:39 AM, Mikko wrote:
On 2024-08-04 18:59:03 +0000, olcott said:
On 8/4/2024 1:51 PM, Richard Damon wrote:
On 8/4/24 9:53 AM, olcott wrote:
On 8/4/2024 1:22 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 18:35 schreef olcott:
∞ instructions of DDD correctly emulated by HHH[∞] never >>>>>>> reach their own "return" instruction final state.
So you are saying that the infinite one does?
Dreaming again of HHH that does not abort? Dreams are no substitute for facts.
The HHH that aborts and halts, halts. A tautology.
void DDD()
{
HHH(DDD);
return;
}
That is the right answer to the wrong question.
I am asking whether or not DDD emulated by HHH
reaches its "return" instruction.
But the "DDD emulated by HHH" is the program DDD above,
When I say DDD emulated by HHH I mean at any level of
emulation and not and direct execution.
If you mean anything other than what the words mean you wihout
a definition in the beginning of the same message then it is
not reasonable to expect anyone to understand what you mean.
Instead people may think that you mean what you say or that
you don't know what you are saying.
If you don't understand what the word "emulate" means look it up.
On 8/5/2024 2:33 AM, Mikko wrote:
On 2024-08-04 12:35:04 +0000, olcott said:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a *DIFFERENT* >>>>>>>>>> input, so they don't prove anything together except that each one >>>>>>>>>> didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite
steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it >>>>>> isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that reaches >>>>>> its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
No, that is not what the words mean. A complete emulation is one that is
continued as long as it can be continued. THe emulation is completed when
all of its instructions are executed. A complete emulaton that can be
continues forever is complete but never completed.
That is incorrect. A completed task is a task where
there are no more steps to be accomplished.
On 8/6/2024 6:22 PM, Keith Thompson wrote:Sounds like a client issue.
I have changed the address because everyone's email address has begun to
be posted next to their name. I can't change it to another email address
for a few days or I lose access to the news server.
On 2024-08-05 13:45:19 +0000, olcott said:
On 8/5/2024 2:33 AM, Mikko wrote:
On 2024-08-04 12:35:04 +0000, olcott said:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a >>>>>>>>>>> *DIFFERENT* input, so they don't prove anything together >>>>>>>>>>> except that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return"
halt state of DDD then even the one that emulated infinite >>>>>>>>>> steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true.
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are,
it isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that
reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
No, that is not what the words mean. A complete emulation is one that is >>> continued as long as it can be continued. THe emulation is completed
when
all of its instructions are executed. A complete emulaton that can be
continues forever is complete but never completed.
That is incorrect. A completed task is a task where
there are no more steps to be accomplished.
That you agree does not mean that I was wrong (though it certainly
means that I should check one more time, and I did, and found some
typos but no substantial error).
...In some formulations, there are specific states
defined as "halting states" and the machine only
halts if either the start state is a halt state...
...these and many other definitions all have
equivalent computing prowess...
On 8/7/2024 2:17 AM, Mikko wrote:
On 2024-08-05 13:45:19 +0000, olcott said:
On 8/5/2024 2:33 AM, Mikko wrote:
On 2024-08-04 12:35:04 +0000, olcott said:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a >>>>>>>>>>>> *DIFFERENT* input, so they don't prove anything together >>>>>>>>>>>> except that each one didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return" >>>>>>>>>>> halt state of DDD then even the one that emulated infinite >>>>>>>>>>> steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true. >>>>>>>>
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, >>>>>>>> it isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that >>>>>>>> reaches its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
No, that is not what the words mean. A complete emulation is one
that is
continued as long as it can be continued. THe emulation is completed
when
all of its instructions are executed. A complete emulaton that can be >>>> continues forever is complete but never completed.
That is incorrect. A completed task is a task where
there are no more steps to be accomplished.
That you agree does not mean that I was wrong (though it certainly
means that I should check one more time, and I did, and found some
typos but no substantial error).
On 8/2/2024 11:32 PM, Jeff Barnett wrote:
...In some formulations, there are specific states
defined as "halting states" and the machine only
halts if either the start state is a halt state...
...these and many other definitions all have
equivalent computing prowess...
A completed task is one that reaches its halt state.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
void DDD()
{
HHH(DDD);
return;
}
int main()
{
HHH(Infinite_Recursion);
HHH(DDD);
}
Neither Infinite_Recursion nor DDD simulated by HHH
according to the semantics of the x86 language can
possibly reach their own halt state of "return" thus
can never be completed tasks.
On 8/7/2024 2:17 AM, Mikko wrote:
On 2024-08-05 13:45:19 +0000, olcott said:
On 8/5/2024 2:33 AM, Mikko wrote:
On 2024-08-04 12:35:04 +0000, olcott said:
On 8/4/2024 6:12 AM, Richard Damon wrote:
On 8/3/24 11:00 PM, olcott wrote:
On 8/3/2024 9:56 PM, Richard Damon wrote:
On 8/3/24 7:36 PM, olcott wrote:
On 8/3/2024 5:51 PM, Richard Damon wrote:
On 8/3/24 6:15 PM, olcott wrote:
On 8/3/2024 5:07 PM, Richard Damon wrote:
The problem is that every one of those emulation is of a *DIFFERENT*
input, so they don't prove anything together except that each one >>>>>>>>>>>> didn't go far enough.
void DDD()
{
HHH(DDD);
return;
}
When each HHH correctly emulates 0 to infinity steps of
its corresponding DDD and none of them reach the "return" >>>>>>>>>>> halt state of DDD then even the one that emulated infinite >>>>>>>>>>> steps of DDD did not emulate enough steps?
Just says lying YOU.
You got any source for that other than yourself?
It is self-evident and you know it. I do have four
people (two with masters in CS) that attest to that.
*It is as simple as I can possibly make it*
Maybe to your mind filled with false facts, but it isn't true. >>>>>>>>
I wonder how you think that you are not swearing your
allegiance to that father of lies?
Because, I know I speak the truth.
Why do you not think you are lying?
Anyone that truly understands infinite recursion knows
that DDD correctly simulated by HHH cannot possibly reach
its own "return" final state.
Right, but for every other HHH, which the ones that answer are, it >>>>>>>> isn't a fact.
Surpisingly (to me) Jeff Barnett set the record straight
on exactly what halting means.
No, there is one, and only one definition, it is a machine that reaches
its final state.
Note, *a machine*, not a (partial) emulation of the machine
You already know that a complete emulation of a non-ending
sequence is impossible and you already acknowledged that
DDD emulated by HHH that never aborts is non-ending.
WHy do you say it is impossible, it just takes forever,
A complete emulation is after all of the instructions have been
emulated. That never happens with any infinite execution.
No, that is not what the words mean. A complete emulation is one that is >>>> continued as long as it can be continued. THe emulation is completed when >>>> all of its instructions are executed. A complete emulaton that can be >>>> continues forever is complete but never completed.
That is incorrect. A completed task is a task where
there are no more steps to be accomplished.
That you agree does not mean that I was wrong (though it certainly
means that I should check one more time, and I did, and found some
typos but no substantial error).
On 8/2/2024 11:32 PM, Jeff Barnett wrote:
...In some formulations, there are specific states
defined as "halting states" and the machine only
halts if either the start state is a halt state...
...these and many other definitions all have
equivalent computing prowess...
A completed task is one that reaches its halt state.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (1 / 15) |
| Uptime: | 160:15:00 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,056 |
| Messages: | 6,416,492 |