On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must halt this is
a design requirement.
(b) Every simulating termination analyzer HHH either aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort the
simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.
This violates the design requirement of (a) therefore HHH must abort >>>>> the simulation of its input.
Pretty much.And when it aborts, the simulation is incorrect. When HHH aborts andSo you are trying to get away with saying that no HHH ever needs to
halts, it is not needed to abort its simulation, because it will halt
of its own.
abort the simulation of its input and HHH will stop running?
I thought they all halt after a finite number of steps?It is the fact that HHH DOES abort its simulation that makes it notNo stupid it is not a fact that every HHH that can possibly exist aborts
need to.
its simulation.
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
You missed a couple details:(a) Termination Analyzers / Partial Halt Deciders must halt this is >>>>>> a design requirement.
(b) Every simulating termination analyzer HHH either aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort the
simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.
This violates the design requirement of (a) therefore HHH must abort >>>>>> the simulation of its input.
A terminating input shouldn't be aborted, or at least not classified
as not terminating. Terminating inputs needn't be aborted; they and the simulator halt on their own.
Pretty much.And when it aborts, the simulation is incorrect. When HHH aborts and >>>>> halts, it is not needed to abort its simulation, because it will halt >>>>> of its own.So you are trying to get away with saying that no HHH ever needs to
abort the simulation of its input and HHH will stop running?
I thought they all halt after a finite number of steps?It is the fact that HHH DOES abort its simulation that makes it notNo stupid it is not a fact that every HHH that can possibly exist aborts
need to.
its simulation.
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must halt this is >>>>>>> a design requirement.
(b) Every simulating termination analyzer HHH either aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort the
simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.
This violates the design requirement of (a) therefore HHH must abort >>>>>>> the simulation of its input.
A terminating input shouldn't be aborted, or at least not classified
as not terminating. Terminating inputs needn't be aborted; they and the
simulator halt on their own.
Pretty much.And when it aborts, the simulation is incorrect. When HHH aborts and >>>>>> halts, it is not needed to abort its simulation, because it will halt >>>>>> of its own.So you are trying to get away with saying that no HHH ever needs to
abort the simulation of its input and HHH will stop running?
I thought they all halt after a finite number of steps?It is the fact that HHH DOES abort its simulation that makes it notNo stupid it is not a fact that every HHH that can possibly exist aborts >>> its simulation.
need to.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
May God have mercy on your soul (if you have a soul).
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
[ .... ]
Olcott could not point to an error, but prefers to ignore it. So, I will >>> repeat it, until either an error is found, or olcott admits that HHH
cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read. All but
one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's wrong.
Richard has been trying that for much longer than you have, with the
same lack of success. Olcott's lack of capacity for abstract reasoning,
combined with his ignorance, combined with his arrogance, prevent him
learning at all.
May I suggest that you reconsider your strategy of endless repetition?
Thanks!
So you are going to stupidly disagree with this?
void DDD()
{
HHH(DDD);
return;
}
It *is* a fact that no DDD correctly simulated by any
pure function HHH ever reaches its own return instruction.
On 7/20/2024 5:11 PM, Richard Damon wrote:
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must halt
this is
a design requirement.
(b) Every simulating termination analyzer HHH either aborts the >>>>>>>>> simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort the >>>>>>>>> simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>>>> never stop running.
This violates the design requirement of (a) therefore HHH must >>>>>>>>> abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not classified
as not terminating. Terminating inputs needn't be aborted; they and the >>>> simulator halt on their own.
Pretty much.And when it aborts, the simulation is incorrect. When HHH aborts >>>>>>>> andSo you are trying to get away with saying that no HHH ever needs to >>>>>>> abort the simulation of its input and HHH will stop running?
halts, it is not needed to abort its simulation, because it will >>>>>>>> halt
of its own.
I thought they all halt after a finite number of steps?It is the fact that HHH DOES abort its simulation that makes it not >>>>>> need to.No stupid it is not a fact that every HHH that can possibly exist
aborts
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below:
It may be that the simulation by HHH never reaches that point,
but if HHH aborts its simuliaton and returns (as required for it to be
a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function.
call HHH(DDD), for that HHH to
Why condemn yourself to Hell over this?
partially emulate DDD, and (after the point in that DDD that it
emulated) abort that emulation and return and thus DDD will return.
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must halt >>>>>>>>>>> this is
a design requirement.
(b) Every simulating termination analyzer HHH either aborts the >>>>>>>>>>> simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort the >>>>>>>>>>> simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>>>>>> never stop running.
This violates the design requirement of (a) therefore HHH >>>>>>>>>>> must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not classified >>>>>> as not terminating. Terminating inputs needn't be aborted; they
and the
simulator halt on their own.
Pretty much.And when it aborts, the simulation is incorrect. When HHHSo you are trying to get away with saying that no HHH ever
aborts and
halts, it is not needed to abort its simulation, because it >>>>>>>>>> will halt
of its own.
needs to
abort the simulation of its input and HHH will stop running?
I thought they all halt after a finite number of steps?It is the fact that HHH DOES abort its simulation that makes it not >>>>>>>> need to.No stupid it is not a fact that every HHH that can possibly exist >>>>>>> aborts
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below:
Nope, YOU just don't what the words mean, and reckless disregard the
teaching you have been getting, which makes your errors not just
honest mistakes but reckless pathological lies.
It may be that the simulation by HHH never reaches that point,
but if HHH aborts its simuliaton and returns (as required for it to
be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function.
Nope, HHH is NOT the "Machine" that determines what the code does, so
can not "Kill" it.
So you are trying to get away with the lie
that an aborted simulation keeps on running.
On 7/20/2024 7:05 PM, Richard Damon wrote:
On 7/20/24 7:06 PM, olcott wrote:
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must halt >>>>>>>>>>>>> this is
a design requirement.
(b) Every simulating termination analyzer HHH either aborts >>>>>>>>>>>>> the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort the >>>>>>>>>>>>> simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>>>>>>>> never stop running.
This violates the design requirement of (a) therefore HHH >>>>>>>>>>>>> must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not
classified
as not terminating. Terminating inputs needn't be aborted; they >>>>>>>> and the
simulator halt on their own.
I thought they all halt after a finite number of steps?No stupid it is not a fact that every HHH that can possiblyIt is the fact that HHH DOES abort its simulation that makes >>>>>>>>>> it notAnd when it aborts, the simulation is incorrect. When HHH >>>>>>>>>>>> aborts andSo you are trying to get away with saying that no HHH ever >>>>>>>>>>> needs to
halts, it is not needed to abort its simulation, because it >>>>>>>>>>>> will halt
of its own.
abort the simulation of its input and HHH will stop running? >>>>>>>> Pretty much.
need to.
exist aborts
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below:
Nope, YOU just don't what the words mean, and reckless disregard the
teaching you have been getting, which makes your errors not just
honest mistakes but reckless pathological lies.
It may be that the simulation by HHH never reaches that point,
but if HHH aborts its simuliaton and returns (as required for it
to be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function.
Nope, HHH is NOT the "Machine" that determines what the code does,
so can not "Kill" it.
So you are trying to get away with the lie
that an aborted simulation keeps on running.
No, but the BEHAVIOR of the program does, and that is what matters.
So you agree that DDD correctly simulated by any pure function
HHH cannot possibly reach its own return instruction?
On 7/20/2024 8:01 PM, Richard Damon wrote:
On 7/20/24 8:21 PM, olcott wrote:
On 7/20/2024 7:05 PM, Richard Damon wrote:
On 7/20/24 7:06 PM, olcott wrote:
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must >>>>>>>>>>>>>>> halt this is
a design requirement.
(b) Every simulating termination analyzer HHH either >>>>>>>>>>>>>>> aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort >>>>>>>>>>>>>>> the
simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>>>>>>>>>> never stop running.
This violates the design requirement of (a) therefore HHH >>>>>>>>>>>>>>> must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not
classified
as not terminating. Terminating inputs needn't be aborted; >>>>>>>>>> they and the
simulator halt on their own.
I thought they all halt after a finite number of steps?No stupid it is not a fact that every HHH that can possibly >>>>>>>>>>> exist abortsIt is the fact that HHH DOES abort its simulation that makes >>>>>>>>>>>> it notAnd when it aborts, the simulation is incorrect. When HHH >>>>>>>>>>>>>> aborts andSo you are trying to get away with saying that no HHH ever >>>>>>>>>>>>> needs to
halts, it is not needed to abort its simulation, because >>>>>>>>>>>>>> it will halt
of its own.
abort the simulation of its input and HHH will stop running? >>>>>>>>>> Pretty much.
need to.
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below:
Nope, YOU just don't what the words mean, and reckless disregard
the teaching you have been getting, which makes your errors not
just honest mistakes but reckless pathological lies.
It may be that the simulation by HHH never reaches that point,
but if HHH aborts its simuliaton and returns (as required for it >>>>>>>> to be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function.
Nope, HHH is NOT the "Machine" that determines what the code does, >>>>>> so can not "Kill" it.
So you are trying to get away with the lie
that an aborted simulation keeps on running.
No, but the BEHAVIOR of the program does, and that is what matters.
So you agree that DDD correctly simulated by any pure function
HHH cannot possibly reach its own return instruction?
No, I will let you claim (without proof, so we can argue tha later)
that the simulation by HHH of DDD does not reach the return, but the
behavior of the DDD simuliated by HHH continues, to the return if HHH
aborts its simulation and returns, as the behavior of ALL copies of
DDD do not "stop" just because some simulator gave up looking at it.
In other words you never understood that the input to an x86
emulator is a static finite string of bytes that does not do
anything at all on its own?
On 7/20/2024 8:01 PM, Richard Damon wrote:
On 7/20/24 8:21 PM, olcott wrote:
On 7/20/2024 7:05 PM, Richard Damon wrote:
On 7/20/24 7:06 PM, olcott wrote:
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must >>>>>>>>>>>>>>> halt this is
a design requirement.
(b) Every simulating termination analyzer HHH either >>>>>>>>>>>>>>> aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort >>>>>>>>>>>>>>> the
simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>>>>>>>>>> never stop running.
This violates the design requirement of (a) therefore HHH >>>>>>>>>>>>>>> must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not
classified
as not terminating. Terminating inputs needn't be aborted; >>>>>>>>>> they and the
simulator halt on their own.
I thought they all halt after a finite number of steps?No stupid it is not a fact that every HHH that can possibly >>>>>>>>>>> exist abortsIt is the fact that HHH DOES abort its simulation that makes >>>>>>>>>>>> it notAnd when it aborts, the simulation is incorrect. When HHH >>>>>>>>>>>>>> aborts andSo you are trying to get away with saying that no HHH ever >>>>>>>>>>>>> needs to
halts, it is not needed to abort its simulation, because >>>>>>>>>>>>>> it will halt
of its own.
abort the simulation of its input and HHH will stop running? >>>>>>>>>> Pretty much.
need to.
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below:
Nope, YOU just don't what the words mean, and reckless disregard
the teaching you have been getting, which makes your errors not
just honest mistakes but reckless pathological lies.
It may be that the simulation by HHH never reaches that point,
but if HHH aborts its simuliaton and returns (as required for it >>>>>>>> to be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function.
Nope, HHH is NOT the "Machine" that determines what the code does, >>>>>> so can not "Kill" it.
So you are trying to get away with the lie
that an aborted simulation keeps on running.
No, but the BEHAVIOR of the program does, and that is what matters.
So you agree that DDD correctly simulated by any pure function
HHH cannot possibly reach its own return instruction?
No, I will let you claim (without proof, so we can argue tha later)
that the simulation by HHH of DDD does not reach the return, but the
behavior of the DDD simuliated by HHH continues,
We are talking about real hardware here not figments
of your imagination.
When an actual x86 emulator stops emulating its input
this emulated input immediately stops running.
On 7/20/2024 8:51 PM, Richard Damon wrote:
On 7/20/24 9:35 PM, olcott wrote:
On 7/20/2024 8:01 PM, Richard Damon wrote:
On 7/20/24 8:21 PM, olcott wrote:
On 7/20/2024 7:05 PM, Richard Damon wrote:
On 7/20/24 7:06 PM, olcott wrote:So you agree that DDD correctly simulated by any pure function
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
On 7/20/2024 2:50 PM, Richard Damon wrote:You missed a couple details:
On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders must >>>>>>>>>>>>>>>>> halt this is
a design requirement.
(b) Every simulating termination analyzer HHH either >>>>>>>>>>>>>>>>> aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not >>>>>>>>>>>>>>>>> abort the
simulation of its input {HHH, emulated DDD and executed >>>>>>>>>>>>>>>>> DDD}
never stop running.
This violates the design requirement of (a) therefore >>>>>>>>>>>>>>>>> HHH must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not >>>>>>>>>>>> classified
as not terminating. Terminating inputs needn't be aborted; >>>>>>>>>>>> they and the
simulator halt on their own.
I thought they all halt after a finite number of steps? >>>>>>>>>>>>No stupid it is not a fact that every HHH that can possibly >>>>>>>>>>>>> exist abortsIt is the fact that HHH DOES abort its simulation that >>>>>>>>>>>>>> makes it notAnd when it aborts, the simulation is incorrect. When >>>>>>>>>>>>>>>> HHH aborts andSo you are trying to get away with saying that no HHH >>>>>>>>>>>>>>> ever needs to
halts, it is not needed to abort its simulation, because >>>>>>>>>>>>>>>> it will halt
of its own.
abort the simulation of its input and HHH will stop running? >>>>>>>>>>>> Pretty much.
need to.
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below:
Nope, YOU just don't what the words mean, and reckless disregard >>>>>>>> the teaching you have been getting, which makes your errors not >>>>>>>> just honest mistakes but reckless pathological lies.
Nope, HHH is NOT the "Machine" that determines what the code
It may be that the simulation by HHH never reaches that point, >>>>>>>>>
but if HHH aborts its simuliaton and returns (as required for >>>>>>>>>> it to be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function. >>>>>>>>
does, so can not "Kill" it.
So you are trying to get away with the lie
that an aborted simulation keeps on running.
No, but the BEHAVIOR of the program does, and that is what matters. >>>>>
HHH cannot possibly reach its own return instruction?
No, I will let you claim (without proof, so we can argue tha later)
that the simulation by HHH of DDD does not reach the return, but the
behavior of the DDD simuliated by HHH continues, to the return if
HHH aborts its simulation and returns, as the behavior of ALL copies
of DDD do not "stop" just because some simulator gave up looking at it. >>>>
In other words you never understood that the input to an x86
emulator is a static finite string of bytes that does not do
anything at all on its own?
But it represents a program that does,
There is no representing to it.
It is static data within the x86 emulator process.
On 7/20/2024 9:05 PM, Richard Damon wrote:
On 7/20/24 9:54 PM, olcott wrote:
On 7/20/2024 8:51 PM, Richard Damon wrote:
On 7/20/24 9:35 PM, olcott wrote:
On 7/20/2024 8:01 PM, Richard Damon wrote:
On 7/20/24 8:21 PM, olcott wrote:
On 7/20/2024 7:05 PM, Richard Damon wrote:
On 7/20/24 7:06 PM, olcott wrote:So you agree that DDD correctly simulated by any pure function
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:Nope, YOU just don't what the words mean, and reckless
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 7/20/2024 2:50 PM, Richard Damon wrote:
You missed a couple details:On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders >>>>>>>>>>>>>>>>>>> must halt this is
a design requirement.
(b) Every simulating termination analyzer HHH either >>>>>>>>>>>>>>>>>>> aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not >>>>>>>>>>>>>>>>>>> abort the
simulation of its input {HHH, emulated DDD and >>>>>>>>>>>>>>>>>>> executed DDD}
never stop running.
This violates the design requirement of (a) therefore >>>>>>>>>>>>>>>>>>> HHH must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least not >>>>>>>>>>>>>> classified
as not terminating. Terminating inputs needn't be aborted; >>>>>>>>>>>>>> they and the
simulator halt on their own.
Pretty much.And when it aborts, the simulation is incorrect. When >>>>>>>>>>>>>>>>>> HHH aborts andSo you are trying to get away with saying that no HHH >>>>>>>>>>>>>>>>> ever needs to
halts, it is not needed to abort its simulation, >>>>>>>>>>>>>>>>>> because it will halt
of its own.
abort the simulation of its input and HHH will stop >>>>>>>>>>>>>>>>> running?
I thought they all halt after a finite number of steps? >>>>>>>>>>>>>>It is the fact that HHH DOES abort its simulation that >>>>>>>>>>>>>>>> makes it notNo stupid it is not a fact that every HHH that can >>>>>>>>>>>>>>> possibly exist aborts
need to.
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot
possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below: >>>>>>>>>>
disregard the teaching you have been getting, which makes your >>>>>>>>>> errors not just honest mistakes but reckless pathological lies. >>>>>>>>>>
Nope, HHH is NOT the "Machine" that determines what the code >>>>>>>>>> does, so can not "Kill" it.
It may be that the simulation by HHH never reaches that point, >>>>>>>>>>>
but if HHH aborts its simuliaton and returns (as required >>>>>>>>>>>> for it to be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function. >>>>>>>>>>
So you are trying to get away with the lie
that an aborted simulation keeps on running.
No, but the BEHAVIOR of the program does, and that is what matters. >>>>>>>
HHH cannot possibly reach its own return instruction?
No, I will let you claim (without proof, so we can argue tha
later) that the simulation by HHH of DDD does not reach the
return, but the behavior of the DDD simuliated by HHH continues,
to the return if HHH aborts its simulation and returns, as the
behavior of ALL copies of DDD do not "stop" just because some
simulator gave up looking at it.
In other words you never understood that the input to an x86
emulator is a static finite string of bytes that does not do
anything at all on its own?
But it represents a program that does,
There is no representing to it.
It is static data within the x86 emulator process.
In other words, you have just been lying for years about doing the
Halting problem, whose input is the reperesentation of the program to
be decided.
No program to be decided on, no program to be emulated.
There is never any representing involved when a simulator
correctly simulates a finite string.
It has always been a mapping from the static finite string
to the behavior specified by this finite string.
It mean you are just admitting that all you are doing is talking about
your POOP.
Throw away to problems actual definition and all you work that you
claim to be ablut it become nothing but LIES.
You can't even connect that string of bytes to you description of it
being "DDD" without a concept of representation, as the bytes do not
have names on them.
On 7/20/2024 9:55 PM, Richard Damon wrote:
On 7/20/24 10:23 PM, olcott wrote:
On 7/20/2024 9:05 PM, Richard Damon wrote:
On 7/20/24 9:52 PM, olcott wrote:
On 7/20/2024 8:46 PM, Richard Damon wrote:
On 7/20/24 9:23 PM, olcott wrote:
On 7/20/2024 8:01 PM, Richard Damon wrote:
On 7/20/24 8:21 PM, olcott wrote:We are talking about real hardware here not figments
On 7/20/2024 7:05 PM, Richard Damon wrote:
On 7/20/24 7:06 PM, olcott wrote:
On 7/20/2024 6:00 PM, Richard Damon wrote:
On 7/20/24 6:47 PM, olcott wrote:
On 7/20/2024 5:11 PM, Richard Damon wrote:Nope, YOU just don't what the words mean, and reckless >>>>>>>>>>>> disregard the teaching you have been getting, which makes >>>>>>>>>>>> your errors not just honest mistakes but reckless
On 7/20/24 5:21 PM, olcott wrote:
On 7/20/2024 4:06 PM, joes wrote:
Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 7/20/2024 2:50 PM, Richard Damon wrote:
You missed a couple details:On 7/20/24 3:09 PM, olcott wrote:
On 7/20/2024 2:00 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 20.jul.2024 om 17:28 schreef olcott:
(a) Termination Analyzers / Partial Halt Deciders >>>>>>>>>>>>>>>>>>>>> must halt this is
a design requirement.
(b) Every simulating termination analyzer HHH >>>>>>>>>>>>>>>>>>>>> either aborts the
simulation of its input or not.
(c) Within the hypothetical case where HHH does not >>>>>>>>>>>>>>>>>>>>> abort the
simulation of its input {HHH, emulated DDD and >>>>>>>>>>>>>>>>>>>>> executed DDD}
never stop running.
This violates the design requirement of (a) >>>>>>>>>>>>>>>>>>>>> therefore HHH must abort
the simulation of its input.
A terminating input shouldn't be aborted, or at least >>>>>>>>>>>>>>>> not classified
as not terminating. Terminating inputs needn't be >>>>>>>>>>>>>>>> aborted; they and the
simulator halt on their own.
Pretty much.And when it aborts, the simulation is incorrect. >>>>>>>>>>>>>>>>>>>> When HHH aborts andSo you are trying to get away with saying that no HHH >>>>>>>>>>>>>>>>>>> ever needs to
halts, it is not needed to abort its simulation, >>>>>>>>>>>>>>>>>>>> because it will halt
of its own.
abort the simulation of its input and HHH will stop >>>>>>>>>>>>>>>>>>> running?
I thought they all halt after a finite number of steps? >>>>>>>>>>>>>>>>It is the fact that HHH DOES abort its simulation that >>>>>>>>>>>>>>>>>> makes it notNo stupid it is not a fact that every HHH that can >>>>>>>>>>>>>>>>> possibly exist aborts
need to.
its simulation.
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by pure function HHH cannot >>>>>>>>>>>>>>> possibly reach its own return instruction.
Wrong.
You know that you are lying about this as you admit below: >>>>>>>>>>>>
pathological lies.
Nope, HHH is NOT the "Machine" that determines what the code >>>>>>>>>>>> does, so can not "Kill" it.
It may be that the simulation by HHH never reaches that >>>>>>>>>>>>>> point,
but if HHH aborts its simuliaton and returns (as required >>>>>>>>>>>>>> for it to be a decider) then the behavior of DDD
Simulated by HHH is to Die, stop running, no longer function. >>>>>>>>>>>>
So you are trying to get away with the lie
that an aborted simulation keeps on running.
No, but the BEHAVIOR of the program does, and that is what >>>>>>>>>> matters.
So you agree that DDD correctly simulated by any pure function >>>>>>>>> HHH cannot possibly reach its own return instruction?
No, I will let you claim (without proof, so we can argue tha
later) that the simulation by HHH of DDD does not reach the
return, but the behavior of the DDD simuliated by HHH continues, >>>>>>>
of your imagination.
No, you are not. The "Hardware" would be the actual CPU chip which >>>>>> never stops the program when it is running. A Simulator is just a
piece of software running on it, and what it does can't affect the >>>>>> behavior of the actual CPU running the program.
When an actual x86 emulator stops emulating its input
this emulated input immediately stops running.
Nope, that is you stupidity where you confuse the observation for
the facts.
It has been told to you MANY times, but it seems that you just can >>>>>> not understand it.
The SIMULATION is an observation of the program,
Not at all. It is the same as a finite string of static data
interpreted by an interpreter. It is merely data within the
process of the x86 emulator. When the emulator stops emulating
it immediately stops.
In other words, you have just been lying for years about doing the
Halting problem, whose input is the reperesentation of the program
to be decided.
No program to be decided on, no program to be emulated.
I was shocked to find out that you really believed that a static
finite string could keep running after its x86 emulator stopped
emulating it.
I thought that you understood that when an interpreter stops
interpreting its input source-code the the interpreted program
would stop.
I guess I need to be shocked that you so poorly understand the problem
Trying to get away with changing the subject won't work.
Your knowledge of software engineering is apparently
insufficient to understand very basic ideas that are
a mandatory prerequisite.
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
[ .... ]
Olcott could not point to an error, but prefers to ignore it. So, I will >>> repeat it, until either an error is found, or olcott admits that HHH
cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read. All but
one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's wrong.
Richard has been trying that for much longer than you have, with the
same lack of success. Olcott's lack of capacity for abstract reasoning,
combined with his ignorance, combined with his arrogance, prevent him
learning at all.
May I suggest that you reconsider your strategy of endless repetition?
Thanks!
I have made slight changes to what I have been saying nearly every day.
This is my newest clearest way of saying it:
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by any pure function HHH cannot
possibly reach its own return instruction.
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
[ .... ]
Olcott could not point to an error, but prefers to ignore it. So, I will >>> repeat it, until either an error is found, or olcott admits that HHH
cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read. All but
one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's wrong.
Richard has been trying that for much longer than you have, with the
same lack of success. Olcott's lack of capacity for abstract reasoning,
combined with his ignorance, combined with his arrogance, prevent him
learning at all.
May I suggest that you reconsider your strategy of endless repetition?
Thanks!
So you are going to stupidly disagree with this?
void DDD()
{
HHH(DDD);
return;
}
It *is* a fact that no DDD correctly simulated by any
pure function HHH ever reaches its own return instruction.
On 7/21/2024 5:34 AM, Fred. Zwarts wrote:
Op 21.jul.2024 om 05:25 schreef olcott:
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
[ .... ]
Olcott could not point to an error, but prefers to ignore it. So, I
will
repeat it, until either an error is found, or olcott admits that HHH >>>>> cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read. All but >>>> one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's wrong. >>>> Richard has been trying that for much longer than you have, with the
same lack of success. Olcott's lack of capacity for abstract
reasoning,
combined with his ignorance, combined with his arrogance, prevent him
learning at all.
May I suggest that you reconsider your strategy of endless repetition? >>>>
Thanks!
I have made slight changes to what I have been saying nearly every day.
This is my newest clearest way of saying it:
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by any pure function HHH cannot
possibly reach its own return instruction.
Which proves that the simulation is not correct.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
When you disagree with the semantics of the meaning
of the x86 machine code instructions of DDD you are
taking a break from reality.
On 7/21/2024 5:25 AM, Fred. Zwarts wrote:
Op 20.jul.2024 om 22:08 schreef olcott:
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
[ .... ]
Olcott could not point to an error, but prefers to ignore it. So, I
will
repeat it, until either an error is found, or olcott admits that HHH >>>>> cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read. All but >>>> one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's wrong. >>>> Richard has been trying that for much longer than you have, with the
same lack of success. Olcott's lack of capacity for abstract
reasoning,
combined with his ignorance, combined with his arrogance, prevent him
learning at all.
May I suggest that you reconsider your strategy of endless repetition? >>>>
Thanks!
So you are going to stupidly disagree with this?
void DDD()
{
HHH(DDD);
return;
}
It *is* a fact that no DDD correctly simulated by any
pure function HHH ever reaches its own return instruction.
Which proves that these simulations are incorrect.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
*You don't get to be the judge of this*
As long as the x86 machine language instructions of DDD
are emulated by HHH according to the semantic meaning
of these instructions then the emulation is correct and
anyone that disagrees is disagreeing with a tautology.
This correct emulation must take into account the fact
that DDD is calling its own emulator: HHH(DDD) in recursive
emulation.
Op 21.jul.2024 om 16:25 schreef olcott:Yes. It is as spammy as olcott themselves, or Richard for that matter.
On 7/21/2024 5:25 AM, Fred. Zwarts wrote:
Op 20.jul.2024 om 22:08 schreef olcott:
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
Olcott could not point to an error, but prefers to ignore it. So, I >>>>>> will repeat it, until either an error is found, or olcott admits
that HHH cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read. All >>>>> but one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's
wrong. Richard has been trying that for much longer than you have,
with the same lack of success. Olcott's lack of capacity for
abstract reasoning,
combined with his ignorance, combined with his arrogance, prevent
him learning at all.
May I suggest that you reconsider your strategy of endless
repetition?
Well putAs long as the x86 machine language instructions of DDD are emulated byBut if some x86 instructions are skipped, then it is dishonest to say
HHH according to the semantic meaning of these instructions then the
emulation is correct and anyone that disagrees is disagreeing with a
tautology.
that it is a correct simulation. If the last cycle of HHH, after which
it would halt, is skipped by the simulation, then the simulation is incorrect.
It is dishonest to deny that skipping instructions is correct according
to the semantics of the x86 language.
Yes. Why does HHH think it doesn't halt, when it makes damn sure to halt?This correct emulation must take into account the fact that DDD isAnd since HHH cannot possibly simulate itself correctly, the simulation
calling its own emulator: HHH(DDD) in recursive emulation.
of DDD is incorrect.
DDD is a misleading and unneeded complication. It is easy to eliminate
DDD:
int main() {
return HHH(main);
}
This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.
HHH is simply unable to decide about finite recursions.Do you agree with this analysis?
void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}
It decides after N recursions that there is an infinite recursion, which
is incorrect.
Olcott does not know how to point to an error in this explanation, but prefers to ignore it. He even consistently removes it from theWONTFIX
citations. So, I will repeat it, until either an error is found, or
olcott admits that HHH cannot possibly simulate itself correctly.
void DDD()
{
HHH(DDD);
}
int main()
{
DDD();
}
(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.
(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.
(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.
This violates the design requirement of (a) therefore HHH must
abort the simulation of its input.
On 7/21/2024 11:47 AM, Fred. Zwarts wrote:
Op 21.jul.2024 om 16:27 schreef olcott:
On 7/21/2024 5:34 AM, Fred. Zwarts wrote:
Op 21.jul.2024 om 05:25 schreef olcott:
On 7/20/2024 3:03 PM, Alan Mackenzie wrote:
[ Followup-To: set ]
In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:
[ .... ]
Olcott could not point to an error, but prefers to ignore it. So, >>>>>>> I will
repeat it, until either an error is found, or olcott admits that HHH >>>>>>> cannot possibly simulate itself correctly.
This has the disadvantage of making your posts boring to read.
All but
one poster on this newsgroup KNOW that Olcott is wrong, here.
Continually repeating your argument won't get him to admit he's
wrong.
Richard has been trying that for much longer than you have, with the >>>>>> same lack of success. Olcott's lack of capacity for abstract
reasoning,
combined with his ignorance, combined with his arrogance, prevent him >>>>>> learning at all.
May I suggest that you reconsider your strategy of endless
repetition?
Thanks!
I have made slight changes to what I have been saying nearly every
day.
This is my newest clearest way of saying it:
void DDD()
{
HHH(DDD);
return;
}
DDD correctly simulated by any pure function HHH cannot
possibly reach its own return instruction.
Which proves that the simulation is not correct.
_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]
When you disagree with the semantics of the meaning
of the x86 machine code instructions of DDD you are
taking a break from reality.
But since it is *you* who does not understand that skipping
instructions is against the semantics of the meaning of the x86
language, we know who is far from reality.
Skipping the last cycle of the simulation of HHH, after which it would
halt, is against the semantics of the x86 language.
It seems that your lack sufficient understanding of
ordinary programming.
I am talking about hypothetical possible ways that HHH could be encoded.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
Therefore (a) is correct and (b) is incorrect according to the
design requirements for HHH that it must halt.
It is also a truism that any input that must be aborted
is a non-halting input.
On 7/22/2024 6:05 AM, Mikko wrote:
On 2024-07-20 15:28:31 +0000, olcott said:
void DDD()
{
HHH(DDD);
}
int main()
{
DDD();
}
(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.
For a partial analyzer or deciders this is not always required.
*You can't even get my words correctly*
A termination analyzer must report on the behavior of at least
one input for all of the inputs of this one input. This is
met when a termination analyzer analyzes an input having no inputs.
A partial halt decider must correctly determine the halt status
of at least one input and its specific input (if any).
HHH is both a partial halt decider and a termination analyzer
for DDD and a few other inputs having no input.
(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.
This must be interpreted to mean that a simulating termination analyzer
may abort its simulation for some simulated abort and simulate others
to the termination.
I am talking about hypothetical possible ways that HHH could be encoded.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.
The case is not very hypothetical. Given the HHH you already have,
it is fairly easy to construct the "hypothetical" HHH and see what
it actually does.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
Therefore (a) is correct and (b) is incorrect according to theThis violates the design requirement of (a) therefore HHH must
abort the simulation of its input.
The violation simply means that the "hypothetical" HHH is not a
termination analyzer of partial halt decider in sense (a). What
it "must" be or do depends on the requirements.
design requirements for HHH that it must halt.
It is also a truism that any input that must be aborted
is a non-halting input.
On 7/23/2024 2:32 AM, Mikko wrote:
On 2024-07-22 15:05:41 +0000, olcott said:
On 7/22/2024 6:05 AM, Mikko wrote:
On 2024-07-20 15:28:31 +0000, olcott said:
void DDD()
{
HHH(DDD);
}
int main()
{
DDD();
}
(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.
For a partial analyzer or deciders this is not always required.
*You can't even get my words correctly*
A termination analyzer must report on the behavior of at least
one input for all of the inputs of this one input. This is
met when a termination analyzer analyzes an input having no inputs.
A partial halt decider must correctly determine the halt status
of at least one input and its specific input (if any).
HHH is both a partial halt decider and a termination analyzer
for DDD and a few other inputs having no input.
(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.
This must be interpreted to mean that a simulating termination analyzer >>>> may abort its simulation for some simulated abort and simulate others
to the termination.
I am talking about hypothetical possible ways that HHH could be encoded. >>> (a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.
The case is not very hypothetical. Given the HHH you already have,
it is fairly easy to construct the "hypothetical" HHH and see what
it actually does.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
Therefore (a) is correct and (b) is incorrect according to theThis violates the design requirement of (a) therefore HHH must
abort the simulation of its input.
The violation simply means that the "hypothetical" HHH is not a
termination analyzer of partial halt decider in sense (a). What
it "must" be or do depends on the requirements.
design requirements for HHH that it must halt.
It is also a truism that any input that must be aborted
is a non-halting input.
No, it is not. The "must" and "non-halting" belong to different worlds.
The word "must" blongs to requirements. The word "non-halting" is a
feature of a program. They are unrelated, so one cannot be inferred
from the other.
When-so-ever there are two hypothetical possible way to encode
a simulating halt decider for a specific input
(a) one aborts its simulation of DDD
(b) never aborts its simulation of DDD
On 7/24/2024 4:01 AM, Mikko wrote:
On 2024-07-23 14:41:11 +0000, olcott said:
On 7/23/2024 2:32 AM, Mikko wrote:
On 2024-07-22 15:05:41 +0000, olcott said:
On 7/22/2024 6:05 AM, Mikko wrote:
On 2024-07-20 15:28:31 +0000, olcott said:
void DDD()
{
HHH(DDD);
}
int main()
{
DDD();
}
(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.
For a partial analyzer or deciders this is not always required.
*You can't even get my words correctly*
A termination analyzer must report on the behavior of at least
one input for all of the inputs of this one input. This is
met when a termination analyzer analyzes an input having no inputs.
A partial halt decider must correctly determine the halt status
of at least one input and its specific input (if any).
HHH is both a partial halt decider and a termination analyzer
for DDD and a few other inputs having no input.
(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.
This must be interpreted to mean that a simulating termination analyzer >>>>>> may abort its simulation for some simulated abort and simulate others >>>>>> to the termination.
I am talking about hypothetical possible ways that HHH could be encoded. >>>>> (a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>> never stop running.
The case is not very hypothetical. Given the HHH you already have, >>>>>> it is fairly easy to construct the "hypothetical" HHH and see what >>>>>> it actually does.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
Therefore (a) is correct and (b) is incorrect according to theThis violates the design requirement of (a) therefore HHH must
abort the simulation of its input.
The violation simply means that the "hypothetical" HHH is not a
termination analyzer of partial halt decider in sense (a). What
it "must" be or do depends on the requirements.
design requirements for HHH that it must halt.
It is also a truism that any input that must be aborted
is a non-halting input.
No, it is not. The "must" and "non-halting" belong to different worlds. >>>> The word "must" blongs to requirements. The word "non-halting" is a
feature of a program. They are unrelated, so one cannot be inferred
from the other.
When-so-ever there are two hypothetical possible way to encode
a simulating halt decider for a specific input
(a) one aborts its simulation of DDD
(b) never aborts its simulation of DDD
Does the simulator that simulates the beginning and end of the
simulated computation but skips a part in ghe middle belong to
class (a) or class (b)?
That is off topic. I am only referring to a sequence of
1 to N x86 machine language instructions simulated according
to the x86 semantic meaning of these instructions.
On 7/26/2024 3:05 AM, Mikko wrote:
On 2024-07-24 13:38:08 +0000, olcott said:
On 7/24/2024 4:01 AM, Mikko wrote:
On 2024-07-23 14:41:11 +0000, olcott said:
On 7/23/2024 2:32 AM, Mikko wrote:
On 2024-07-22 15:05:41 +0000, olcott said:
On 7/22/2024 6:05 AM, Mikko wrote:
On 2024-07-20 15:28:31 +0000, olcott said:
void DDD()
{
HHH(DDD);
}
int main()
{
DDD();
}
(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.
For a partial analyzer or deciders this is not always required. >>>>>>>>
*You can't even get my words correctly*
A termination analyzer must report on the behavior of at least
one input for all of the inputs of this one input. This is
met when a termination analyzer analyzes an input having no inputs. >>>>>>>
A partial halt decider must correctly determine the halt status
of at least one input and its specific input (if any).
HHH is both a partial halt decider and a termination analyzer
for DDD and a few other inputs having no input.
(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.
This must be interpreted to mean that a simulating termination analyzer
may abort its simulation for some simulated abort and simulate others >>>>>>>> to the termination.
I am talking about hypothetical possible ways that HHH could be encoded.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD} >>>>>>>>> never stop running.
The case is not very hypothetical. Given the HHH you already have, >>>>>>>> it is fairly easy to construct the "hypothetical" HHH and see what >>>>>>>> it actually does.
(a) HHH(DDD) is encoded to abort its simulation.
(b) HHH(DDD) is encoded to never abort its simulation.
Therefore (a) is correct and (b) is incorrect according to theThis violates the design requirement of (a) therefore HHH must >>>>>>>>> abort the simulation of its input.
The violation simply means that the "hypothetical" HHH is not a >>>>>>>> termination analyzer of partial halt decider in sense (a). What >>>>>>>> it "must" be or do depends on the requirements.
design requirements for HHH that it must halt.
It is also a truism that any input that must be aborted
is a non-halting input.
No, it is not. The "must" and "non-halting" belong to different worlds. >>>>>> The word "must" blongs to requirements. The word "non-halting" is a >>>>>> feature of a program. They are unrelated, so one cannot be inferred >>>>>> from the other.
When-so-ever there are two hypothetical possible way to encode
a simulating halt decider for a specific input
(a) one aborts its simulation of DDD
(b) never aborts its simulation of DDD
Does the simulator that simulates the beginning and end of the
simulated computation but skips a part in ghe middle belong to
class (a) or class (b)?
That is off topic. I am only referring to a sequence of
1 to N x86 machine language instructions simulated according
to the x86 semantic meaning of these instructions.
No, it isn't. Abortion of simulation is a deviation form x86 macine
language semantics. What I ask about does not deviate more.
In other words you are saying that it is absolutely impossible
to make an x86 program that is an x86 emulator that correctly
emulates a finite number of instructions of non-terminating
input x86 machine code.
That seems to be a pretty stupid thing to say when you know
that I have shown you an x86 program that does do those things.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 489 |
Nodes: | 16 (2 / 14) |
Uptime: | 40:25:44 |
Calls: | 9,670 |
Calls today: | 1 |
Files: | 13,716 |
Messages: | 6,169,678 |