On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not mean >>>>>> what you apparently think it means. You seem to think that "DDDIn other words when DDD is defined to have a pathological relationship >>>>> to HHH we can just close our eyes and ignore it and pretend that it
emulated by HHH" means whatever HHH thinks DDD means but it does not. >>>>>> DDD means what it means whether HHH emulates it or not.
doesn't exist?
anything
and can't fulfill that promise. That doesn't mean that DDD is somehow
faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH
that returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not >>>>>>>> meanIn other words when DDD is defined to have a pathological
what you apparently think it means. You seem to think that "DDD >>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does >>>>>>>> not.
DDD means what it means whether HHH emulates it or not.
relationship
to HHH we can just close our eyes and ignore it and pretend that it >>>>>>> doesn't exist?
anything
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH
that returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it
is given, because it aborts its emulation.
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions correctly. In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Ah you are finally beaten so that everyone can tell !!!
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not >>>>>>>> meanIn other words when DDD is defined to have a pathological
what you apparently think it means. You seem to think that "DDD >>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does >>>>>>>> not.
DDD means what it means whether HHH emulates it or not.
relationship
to HHH we can just close our eyes and ignore it and pretend that it >>>>>>> doesn't exist?
anything
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH
that returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it
is given, because it aborts its emulation.
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Everyone can tell that Richard is trying to get way
with disagreeing with a tautology.
No one will accept that when
*zero to infinity instructions are emulated correctly*
"that some instructions are not emulated correctly".
*Richard finally loses*
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not >>>>>>>> meanIn other words when DDD is defined to have a pathological
what you apparently think it means. You seem to think that "DDD >>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does >>>>>>>> not.
DDD means what it means whether HHH emulates it or not.
relationship
to HHH we can just close our eyes and ignore it and pretend that it >>>>>>> doesn't exist?
anything
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH
that returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it
is given, because it aborts its emulation.
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions correctly. In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*]\
Everyone can tell that Richard is trying to get way
with disagreeing with a tautology.
The strawman deception won't work any more Richard!
When you switch from DDD correctly simulated by HHH
everyone can tell.
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not >>>>>>>> meanIn other words when DDD is defined to have a pathological
what you apparently think it means. You seem to think that "DDD >>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does >>>>>>>> not.
DDD means what it means whether HHH emulates it or not.
relationship
to HHH we can just close our eyes and ignore it and pretend that it >>>>>>> doesn't exist?
anything
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH
that returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it
is given, because it aborts its emulation.
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt styate.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Everyone can tell that Richard is trying to get way
with disagreeing with a tautology.
Finally admitting total defeat no more attempts at
contradicting tautologies. They were to easy to spot.
The tgasp of an attempt at saving face is pure ad
hominem personal attacks without even any attempt
at reasoning. *Richard went against the truth and lost*
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide anything
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not mean >>>>>>>> what you apparently think it means. You seem to think that "DDD >>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does not. >>>>>>>> DDD means what it means whether HHH emulates it or not.In other words when DDD is defined to have a pathological relationship >>>>>>> to HHH we can just close our eyes and ignore it and pretend that it >>>>>>> doesn't exist?
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH that >>>> returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it is
given, because it aborts its emulation.
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Everyone can tell that Richard is trying to get way
with disagreeing with a tautology.
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not >>>>>>>> meanIn other words when DDD is defined to have a pathological
what you apparently think it means. You seem to think that "DDD >>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does >>>>>>>> not.
DDD means what it means whether HHH emulates it or not.
relationship
to HHH we can just close our eyes and ignore it and pretend that it >>>>>>> doesn't exist?
anything
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH
that returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it
is given, because it aborts its emulation.
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Everyone can tell that Richard is trying to get way
with disagreeing with a tautology.
The only errors are yours each error was pointed
out separately in the Preceding posts.
On 8/8/2024 3:24 AM, Fred. Zwarts wrote:
Op 07.aug.2024 om 15:01 schreef olcott:
On 8/7/2024 3:16 AM, Fred. Zwarts wrote:Again accusations without evidence.
Op 04.aug.2024 om 15:11 schreef olcott:
On 8/4/2024 1:26 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 17:20 schreef olcott:>>
When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.
Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.
void DDD()
{
HHH(DDD);
return;
}
In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ??? Do you expect it to make a cup of coffee?
Is English too difficult for you. I said HHH cannot do it correctly.
*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*
We proved that HHH deviated from the semantics of the x86 language by
skipping the last few instructions of a halting program.
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
On 8/8/2024 1:44 PM, Fred. Zwarts wrote:
Op 08.aug.2024 om 15:15 schreef olcott:
On 8/8/2024 3:24 AM, Fred. Zwarts wrote:
Op 07.aug.2024 om 15:01 schreef olcott:
On 8/7/2024 3:16 AM, Fred. Zwarts wrote:Again accusations without evidence.
Op 04.aug.2024 om 15:11 schreef olcott:*According to an incorrect criteria of correct*
On 8/4/2024 1:26 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 17:20 schreef olcott:>>
When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.
Fortunately that is not what I try, because I understand that
HHH cannot possibly simulate itself correctly.
void DDD()
{
HHH(DDD);
return;
}
In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ??? Do you expect it to make a cup of coffee?
Is English too difficult for you. I said HHH cannot do it correctly. >>>>>
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*
We proved that HHH deviated from the semantics of the x86 language
by skipping the last few instructions of a halting program.
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Indeed. And this correctly proves that the simulation failed, not
because of an instruction simulated incorrectly, but because
instructions are skipped.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
The return instruction in both cases is unreachable code.
DDD correctly emulated by HHH and Infinite_Recursion
correctly emulated by HHH cannot reach the "return"
instruction.
If you don't know the first thing about programming you
might not notice this.
On 8/8/2024 3:24 AM, Fred. Zwarts wrote:
Op 07.aug.2024 om 15:01 schreef olcott:
On 8/7/2024 3:16 AM, Fred. Zwarts wrote:Again accusations without evidence.
Op 04.aug.2024 om 15:11 schreef olcott:
On 8/4/2024 1:26 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 17:20 schreef olcott:>>
When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.
Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.
void DDD()
{
HHH(DDD);
return;
}
In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ??? Do you expect it to make a cup of coffee?
Is English too difficult for you. I said HHH cannot do it correctly.
*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*
We proved that HHH deviated from the semantics of the x86 language by
skipping the last few instructions of a halting program.
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
On 8/8/2024 2:00 AM, Mikko wrote:
On 2024-08-07 13:07:06 +0000, olcott said:
On 8/7/2024 1:48 AM, Mikko wrote:
On 2024-08-05 15:16:27 +0000, olcott said:
I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.
I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.
Intel 8088 is a variant of 8086 for less expensive computers.
Intel 8086 already exsted when the first 8088 computers were
sold. Later Intel develped 80188, 80186, and other processors
that cold run programs that were written or compiled for 8086,
so someone coined the term x86 for the family.
Can you write programs in this language?
I have written many interrupt intercept TSR
programs in the 8088 versions of the language.
I was doing my own time slicing back in 1987.
I have done that tor 8088 and some other poocessors but not
recently so my skills may be rusty. Only rarely there is any
need for machine language programming.
typedef void (*ptr)();
int HHH(ptr P); // simulating termination analyzer
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
It seems that every rebuttal that anyone can possibly make is
necessarily erroneous because the above paragraph is a tautology.
On 8/8/2024 9:52 PM, Richard Damon wrote:
On 8/8/24 9:15 AM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
Nope, it is a lie based on comfusing the behavior of DDD which is what
"Halting" is.
Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
Until you agree to these two points I will continue to
point out that you are trying to disagree with a tautology.
On 8/8/2024 10:34 PM, Richard Damon wrote:
On 8/8/24 11:03 PM, olcott wrote:Now you have to agree with (a).
On 8/8/2024 9:52 PM, Richard Damon wrote:
On 8/8/24 9:15 AM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
Nope, it is a lie based on comfusing the behavior of DDD which is
what "Halting" is.
Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
Why do I need to agree to a LIE?
*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
WRONG, as proven.
The SIMULATION BY HHH doesn't reach there, but DDD does,
On 8/8/2024 2:04 PM, Fred. Zwarts wrote:
Op 08.aug.2024 om 20:48 schreef olcott:
On 8/8/2024 1:44 PM, Fred. Zwarts wrote:
Op 08.aug.2024 om 15:15 schreef olcott:
On 8/8/2024 3:24 AM, Fred. Zwarts wrote:
Op 07.aug.2024 om 15:01 schreef olcott:
On 8/7/2024 3:16 AM, Fred. Zwarts wrote:Again accusations without evidence.
Op 04.aug.2024 om 15:11 schreef olcott:
On 8/4/2024 1:26 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 17:20 schreef olcott:>>
When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.
Fortunately that is not what I try, because I understand that >>>>>>>>>> HHH cannot possibly simulate itself correctly.
void DDD()
{
HHH(DDD);
return;
}
In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ??? Do you expect it to make a cup of coffee? >>>>>>>>>
Is English too difficult for you. I said HHH cannot do it
correctly.
*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*
We proved that HHH deviated from the semantics of the x86 language >>>>>> by skipping the last few instructions of a halting program.
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Indeed. And this correctly proves that the simulation failed, not
because of an instruction simulated incorrectly, but because
instructions are skipped.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
Dreaming again of an infinite recursion?
The return instruction in both cases is unreachable code.
DDD correctly emulated by HHH and Infinite_Recursion
correctly emulated by HHH cannot reach the "return"
instruction.
It cannot reach it, because it was programmed to abort one cycle
before the program would end.
*Maybe you have ADD like Richard has. I already said this above*
When zero to infinity steps of DDD are correctly emulated by
HHH no DDD ever reaches its own "return" instruction.
Maybe the issue is that you don't know programming well enough
to understand that this is true.
On 8/8/2024 9:52 PM, Richard Damon wrote:There is no correct simulation of HHH by itself. HHH cannot possibly
On 8/8/24 9:15 AM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
Nope, it is a lie based on comfusing the behavior of DDD which is what
"Halting" is.
Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
On 8/8/2024 3:13 AM, Mikko wrote:
On 2024-08-08 04:41:11 +0000, olcott said:
On 8/7/2024 8:22 PM, Richard Damon wrote:
On 8/7/24 9:12 PM, olcott wrote:
On 8/7/2024 8:03 PM, Richard Damon wrote:
On 8/7/24 2:14 PM, olcott wrote:
On 8/7/2024 1:02 PM, joes wrote:
Am Wed, 07 Aug 2024 08:54:41 -0500 schrieb olcott:
On 8/7/2024 2:29 AM, Mikko wrote:It doesn't change anything about DDD. HHH was supposed to decide anything
On 2024-08-05 13:49:44 +0000, olcott said:
I know what it means. But the inflected form "emulated" does not meanIn other words when DDD is defined to have a pathological relationship
what you apparently think it means. You seem to think that "DDD >>>>>>>>>> emulated by HHH" means whatever HHH thinks DDD means but it does not.
DDD means what it means whether HHH emulates it or not.
to HHH we can just close our eyes and ignore it and pretend that it >>>>>>>>> doesn't exist?
and can't fulfill that promise. That doesn't mean that DDD is somehow >>>>>>>> faulty, it's just a counterexample.
void DDD()
{
HHH(DDD);
return;
}
*HHH is required to report on the behavior of DDD*
Anyone that does not understand that HHH meets this criteria
has insufficient understanding.
But it doesn't, as a correct simulation of a DDD that calls an HHH that >>>>>> returns will stop running,
I really think that you must be a liar here because
you have known this for years:
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...
Anyone that knows C knows that DDD correctly simulated
by any HHH cannot possibly reach its "return" {halt state}.
But the problem is that you HHH ODESN'T correctly emulate the DDD it is >>>> given, because it aborts its emulation.
Every one can see that Olcott is trying to get way
with ad-hominem instead of staying on topic.
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
On 8/8/2024 2:59 AM, Mikko wrote:
On 2024-08-07 13:43:09 +0000, olcott said:
On 8/7/2024 2:24 AM, Mikko wrote:
On 2024-08-05 15:01:36 +0000, olcott said:
On 8/5/2024 2:49 AM, Mikko wrote:
On 2024-08-04 12:37:49 +0000, olcott said:
On 8/4/2024 2:18 AM, Mikko wrote:
On 2024-08-03 13:58:07 +0000, olcott said:
On 8/3/2024 3:19 AM, Mikko wrote:
On 2024-08-02 20:57:26 +0000, olcott said:Fred's understanding is worse than that.
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;
}
Everyone here understands that that depends on whther HHH returns. >>>>>>>>>
You don't know whether that is true.
Some have deeper understanding than that.
*Ben has the best understanding of all*
In particular better than you.
*Ben has a deeper agreement with me than anyone else*
Doesn't matter. Points of disagreement, both deep and shallow, are >>>>>> more important than points of agreement.
Not at all.
Most of the reviewers simply don't have a clue that they
don't have a clue. The error is entirely on their side.
Your reviewers don't need a clue. You need. But you don't have.
And you don't know you don't have so you don't seek. As you
don't seek you will never get.
void DDD()
{
HHH(DDD);
return;
}
Any expert in the C language that knows what x86 emulators
are knows that DDD correctly emulated by HHH specifies what
is essentially equivalent to infinite recursion.
No, that requires knowing what does or at least whther it
ever returns. Knowledge of what x86 emulators are does not
help.
x86 machine code is a 100% exact and concrete specification.
C is a little more vague and hides the details.
typedef void (*ptr)();
int HHH(ptr P); // simulating termination analyzer
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the above paragraph is a tautology.
HHH computes the mapping from its finite string of x86 machine
code to the actual behavior that this finite string specifies
which includes recursive emulation.
On 8/9/2024 1:46 AM, Fred. Zwarts wrote:
Op 08.aug.2024 om 21:18 schreef olcott:
On 8/8/2024 2:04 PM, Fred. Zwarts wrote:
Op 08.aug.2024 om 20:48 schreef olcott:
On 8/8/2024 1:44 PM, Fred. Zwarts wrote:
Op 08.aug.2024 om 15:15 schreef olcott:
On 8/8/2024 3:24 AM, Fred. Zwarts wrote:
Op 07.aug.2024 om 15:01 schreef olcott:
On 8/7/2024 3:16 AM, Fred. Zwarts wrote:Again accusations without evidence.
Op 04.aug.2024 om 15:11 schreef olcott:
On 8/4/2024 1:26 AM, Fred. Zwarts wrote:
Op 03.aug.2024 om 17:20 schreef olcott:>>
When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.
Fortunately that is not what I try, because I understand >>>>>>>>>>>> that HHH cannot possibly simulate itself correctly.
void DDD()
{
HHH(DDD);
return;
}
In other words when HHH simulates itself simulating DDD it >>>>>>>>>>> is supposed to do something other than simulating itself >>>>>>>>>>> simulating DDD ??? Do you expect it to make a cup of coffee? >>>>>>>>>>>
Is English too difficult for you. I said HHH cannot do it
correctly.
*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*
We proved that HHH deviated from the semantics of the x86
language by skipping the last few instructions of a halting
program.
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
Indeed. And this correctly proves that the simulation failed, not
because of an instruction simulated incorrectly, but because
instructions are skipped.
void Infinite_Recursion()
{
Infinite_Recursion();
return;
}
Dreaming again of an infinite recursion?
The return instruction in both cases is unreachable code.
DDD correctly emulated by HHH and Infinite_Recursion
correctly emulated by HHH cannot reach the "return"
instruction.
It cannot reach it, because it was programmed to abort one cycle
before the program would end.
*Maybe you have ADD like Richard has. I already said this above*
When zero to infinity steps of DDD are correctly emulated by
HHH no DDD ever reaches its own "return" instruction.
Maybe the issue is that you don't know programming well enough
to understand that this is true.
Maybe you should try to learn English. I confirmed hat HHH cannot
reach the end of the simulation of itself.
Yes and cups of coffee are made from ground coffee beans.
Changing the subject is merely the dishonest dodge of the
strawman deception.
Maybe you should learn to program. When the simulation of a halting
program is unable to reach the end, it proves that the simulation is
incorrect.
void Infinite_Loop()
{
HERE: goto HERE;
}
The correct simulation of the above never halts.
Everybody with sufficient programming knowledge understands that a
simulator cannot possibly simulate itself correctly up to the end,
because either it does not halt, or it misses the last cycle, the
final part of the simulation.
When a simulating termination analyzer is essentially called
in infinite recursion it is smart enough to abort.
On 8/9/2024 1:39 AM, Fred. Zwarts wrote:We proved it many times, but it seems you do not understand it. It is
Op 09.aug.2024 om 05:03 schreef olcott:
On 8/8/2024 9:52 PM, Richard Damon wrote:There is no correct simulation of HHH by itself. HHH cannot possibly
On 8/8/24 9:15 AM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
Nope, it is a lie based on comfusing the behavior of DDD which is
what "Halting" is.
Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
simulate itself correctly. A correct simulation of a halting program
must reach this state.
Try and show how it is incorrect.
On 8/9/2024 10:42 AM, Fred. Zwarts wrote:
Op 09.aug.2024 om 17:04 schreef olcott:
{void Infinite_Loop()
HERE: goto HERE;
}
The correct simulation of the above never halts.
void DDD()
{
HHH(DDD);
return;
}
A correct simulation of N instructions of DDD <is>
A correct simulation of N instructions of DDD.
You are trying to get away with denying a truism.
On 8/9/2024 10:27 AM, Fred. Zwarts wrote:
Op 09.aug.2024 om 15:41 schreef olcott:
On 8/9/2024 1:39 AM, Fred. Zwarts wrote:We proved it many times, but it seems you do not understand it. It is
Op 09.aug.2024 om 05:03 schreef olcott:
On 8/8/2024 9:52 PM, Richard Damon wrote:There is no correct simulation of HHH by itself. HHH cannot possibly
On 8/8/24 9:15 AM, olcott wrote:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.
Nope, it is a lie based on comfusing the behavior of DDD which is
what "Halting" is.
Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.
You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.
*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
simulate itself correctly. A correct simulation of a halting program
must reach this state.
Try and show how it is incorrect.
unclear to me whether you are unable to understand it or unwilling to
understand it. But I will go another mile.
(HHH is required to halt, so we don't need to consider the non-
aborting HHH.)
1) HHH is programmed to abort after N cycles. When HHH simulates
itself, the simulating HHH aborts after N cycles.
That is false. AKA counter-factual.
2) Note, we are looking at the HHH that aborts after N cycles, not the
one that does not abort. Both the simulating and the simulated HHH use
the same algorithm, namely, the algorithm to abort after N cycles.
When we look at every HHH that can possibly exist then we
see that DDD correctly emulated by each one of these cannot
possibly reach its own "return" instruction halt state.
That you can't understand this seems to indicate a lack
of software engineering skills.
On 8/9/2024 2:45 PM, Fred. Zwarts wrote:
Op 09.aug.2024 om 19:02 schreef olcott:
On 8/9/2024 10:42 AM, Fred. Zwarts wrote:
Op 09.aug.2024 om 17:04 schreef olcott:
{void Infinite_Loop()
HERE: goto HERE;
}
The correct simulation of the above never halts.
void DDD()
{
HHH(DDD);
return;
}
A correct simulation of N instructions of DDD <is>
A correct simulation of N instructions of DDD.
Irrelevant.
We are not interested in the simulation of only a few instructions,
but in the simulation of the whole halting program, to determine its
halting behaviour.
That is a pretty stupid requirement for non-halting inputs.
You don't even know what halting is yet.
On 8/9/2024 2:35 PM, Fred. Zwarts wrote:And you don't need to be an expert to see that this proves that all
Op 09.aug.2024 om 18:19 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
"Colorless green ideas sleep furiously"
I defined an infinite set of HHH x86 emulators.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
On 8/9/2024 4:22 AM, Mikko wrote:
On 2024-08-08 18:45:00 +0000, olcott said:
x86 machine code is a 100% exact and concrete specification.
But has too many unimportant details.
*After we get agreement on this*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.
Then we move on to the last step we I prove how important
a 100% concrete specification is.
On 8/10/2024 3:27 AM, Fred. Zwarts wrote:
Op 09.aug.2024 om 22:53 schreef olcott:
On 8/9/2024 2:35 PM, Fred. Zwarts wrote:And you don't need to be an expert to see that this proves that all
Op 09.aug.2024 om 18:19 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
these simulations are incorrect.
In other words you are trying to get away with the lie that
Richard has been persistently pushing:
When N > 0 instructions of DDD are correctly emulated by HHH
then no instructions of DDD have been correctly emulated.
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
When we can see that in none of these cases that
the correctly emulated DDD ever reaches its "return"
instruction halt state.
This entails that each HHH can take a wild guess that
its input does not reach this halt state and necessarily
be correct.
When all X has property Y then each X is necessarily
correct to state that is has property Y.
On 8/10/2024 3:27 AM, Fred. Zwarts wrote:
Op 09.aug.2024 om 22:53 schreef olcott:
On 8/9/2024 2:35 PM, Fred. Zwarts wrote:And you don't need to be an expert to see that this proves that all
Op 09.aug.2024 om 18:19 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
these simulations are incorrect.
In other words you are trying to get away with the lie that
Richard has been persistently pushing:
When N > 0 instructions of DDD are correctly emulated by HHH
then no instructions of DDD have been correctly emulated.
On 8/10/2024 8:08 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 13:34 schreef olcott:
On 8/10/2024 3:27 AM, Fred. Zwarts wrote:
Op 09.aug.2024 om 22:53 schreef olcott:
On 8/9/2024 2:35 PM, Fred. Zwarts wrote:And you don't need to be an expert to see that this proves that all
Op 09.aug.2024 om 18:19 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.
these simulations are incorrect.
In other words you are trying to get away with the lie that
Richard has been persistently pushing:
When N > 0 instructions of DDD are correctly emulated by HHH
then no instructions of DDD have been correctly emulated.
In other words, you believe that only the numbers zero and infinite
exist.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
When we can see that in none of these cases that the
correctly emulated DDD ever reaches its "return" instruction
halt state.
This entails that each HHH can take a wild guess that
its input does not reach this halt state and HHH would
necessarily be correct.
When all X has property Y then each X is necessarily
correct to state that is has property Y.
On 8/10/2024 6:57 AM, Richard Damon wrote:
On 8/10/24 7:30 AM, olcott wrote:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
I thopught HHH was a deider?
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
And only those element of the set that either reach the final state,
or simulate forever are "correct" emulators of the whole program,
suitable to show halting.
void DDD()
{
HHH(DDD);
return;
}
In other words even though it is dead obvious to
us that a complete simulation of DDD simulated by HHH
will never halt algorithms will forever be ridiculously
more stupid and never be able to see this?
On 8/10/2024 8:21 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 14:06 schreef olcott:
On 8/10/2024 6:57 AM, Richard Damon wrote:
On 8/10/24 7:30 AM, olcott wrote:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
I thopught HHH was a deider?
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
And only those element of the set that either reach the final state,
or simulate forever are "correct" emulators of the whole program,
suitable to show halting.
void DDD()
{
HHH(DDD);
return;
}
In other words even though it is dead obvious to
us that a complete simulation of DDD simulated by HHH
is impossible, because HHH is programmed to abort and, therefore, it
is unable to do a complete simulation.
A complete simulation of DDD by a pure x86 emulator
named HHH cannot possibly reach its own "return"
instruction halt state.
We can see this. Do you think that an algorithm
is much more stupid than we are?
On 8/10/2024 9:00 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 15:37 schreef olcott:
On 8/10/2024 8:21 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 14:06 schreef olcott:
On 8/10/2024 6:57 AM, Richard Damon wrote:
On 8/10/24 7:30 AM, olcott wrote:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely >>>>>>>>>>> *emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
I thopught HHH was a deider?
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
And only those element of the set that either reach the final
state, or simulate forever are "correct" emulators of the whole
program, suitable to show halting.
void DDD()
{
HHH(DDD);
return;
}
In other words even though it is dead obvious to
us that a complete simulation of DDD simulated by HHH
is impossible, because HHH is programmed to abort and, therefore, it
is unable to do a complete simulation.
A complete simulation of DDD by a pure x86 emulator
named HHH cannot possibly reach its own "return"
instruction halt state.
Indeed, HHH fails to reach its own halt state. HHH cannot possibly
simulate itself up to its halt state.
Which proves that the simulation is incomplete and, therefore, incorrect.
That an emulation of an input is necessary correct no matter
what-the-Hell it does as long as it conforms to the semantics
of the x86 language is either over your head or you persistently
lie about it.
On 8/10/2024 1:35 PM, Fred. Zwarts wrote:
Op 10.aug.2024 om 16:24 schreef olcott:
On 8/10/2024 9:00 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 15:37 schreef olcott:
On 8/10/2024 8:21 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 14:06 schreef olcott:
On 8/10/2024 6:57 AM, Richard Damon wrote:
On 8/10/24 7:30 AM, olcott wrote:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely >>>>>>>>>>>>> *emulates zero to infinity instructions correctly* In >>>>>>>>>>>>> none of these cases does the emulated DDD ever reach >>>>>>>>>>>>> its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything: >>>>>>>>>>> "0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some >>>>>>>>>> inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience* >>>>>>>>>>> Each element of this set is mapped to one element of the >>>>>>>>>>> set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of >>>>>>>>>> instructions is emulated. But the restriction to DDD does not >>>>>>>>>> seem reasonable.
*The set of HHH x86 emulators are defined such that*
I thopught HHH was a deider?
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
And only those element of the set that either reach the final
state, or simulate forever are "correct" emulators of the whole >>>>>>>> program, suitable to show halting.
void DDD()
{
HHH(DDD);
return;
}
In other words even though it is dead obvious to
us that a complete simulation of DDD simulated by HHH
is impossible, because HHH is programmed to abort and, therefore,
it is unable to do a complete simulation.
A complete simulation of DDD by a pure x86 emulator
named HHH cannot possibly reach its own "return"
instruction halt state.
Indeed, HHH fails to reach its own halt state. HHH cannot possibly
simulate itself up to its halt state.
Which proves that the simulation is incomplete and, therefore,
incorrect.
That an emulation of an input is necessary correct no matter
what-the-Hell it does as long as it conforms to the semantics
of the x86 language is either over your head or you persistently
lie about it.
No evidence for these claims. We know that a simulation of a halting
program is correct only when it reaches the halt state,
void Infinite_Recursion()
{
Infinite_Recursion();
}
void Infinite_Loop()
{
HERE: goto HERE;
}
You seem to be an ignoramus. Ordinary ignorance can be corrected.
On 8/10/2024 1:35 PM, Fred. Zwarts wrote:
Op 10.aug.2024 om 16:24 schreef olcott:
On 8/10/2024 9:00 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 15:37 schreef olcott:
On 8/10/2024 8:21 AM, Fred. Zwarts wrote:
Op 10.aug.2024 om 14:06 schreef olcott:
On 8/10/2024 6:57 AM, Richard Damon wrote:
On 8/10/24 7:30 AM, olcott wrote:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely >>>>>>>>>>>>> *emulates zero to infinity instructions correctly* In >>>>>>>>>>>>> none of these cases does the emulated DDD ever reach >>>>>>>>>>>>> its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything: >>>>>>>>>>> "0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some >>>>>>>>>> inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience* >>>>>>>>>>> Each element of this set is mapped to one element of the >>>>>>>>>>> set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of >>>>>>>>>> instructions is emulated. But the restriction to DDD does not >>>>>>>>>> seem reasonable.
*The set of HHH x86 emulators are defined such that*
I thopught HHH was a deider?
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
And only those element of the set that either reach the final
state, or simulate forever are "correct" emulators of the whole >>>>>>>> program, suitable to show halting.
void DDD()
{
HHH(DDD);
return;
}
In other words even though it is dead obvious to
us that a complete simulation of DDD simulated by HHH
is impossible, because HHH is programmed to abort and, therefore,
it is unable to do a complete simulation.
A complete simulation of DDD by a pure x86 emulator
named HHH cannot possibly reach its own "return"
instruction halt state.
Indeed, HHH fails to reach its own halt state. HHH cannot possibly
simulate itself up to its halt state.
Which proves that the simulation is incomplete and, therefore,
incorrect.
That an emulation of an input is necessary correct no matter
what-the-Hell it does as long as it conforms to the semantics
of the x86 language is either over your head or you persistently
lie about it.
No evidence for these claims. We know that a simulation of a halting
program is correct only when it reaches the halt state,
void Infinite_Recursion()
{
Infinite_Recursion();
}
void Infinite_Loop()
{
HERE: goto HERE;
}
You seem to be an ignoramus. Ordinary ignorance can be corrected.
On 8/10/2024 1:56 PM, Fred. Zwarts wrote:
Op 10.aug.2024 om 20:41 schreef olcott:
On 8/10/2024 1:35 PM, Fred. Zwarts wrote:
No evidence for these claims. We know that a simulation of a halting
program is correct only when it reaches the halt state,
void Infinite_Recursion()
{
Infinite_Recursion();
}
void Infinite_Loop()
{
HERE: goto HERE;
}
You seem to be an ignoramus. Ordinary ignorance can be corrected.
Completely irrelevant. There is no infinite loop in HHH because HHH
aborts after N recursions, not after an Infinite_Recursion.
Thus you already knew that your statement was false before you
said it. Infinite_Loop() need not be emulated to non-existent
completion before HHH recognizes its infinite behavior pattern.
Why say things that you know are false?
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
On 8/10/2024 1:56 PM, Fred. Zwarts wrote:
Op 10.aug.2024 om 20:41 schreef olcott:
On 8/10/2024 1:35 PM, Fred. Zwarts wrote:
No evidence for these claims. We know that a simulation of a halting
program is correct only when it reaches the halt state,
void Infinite_Recursion()
{
Infinite_Recursion();
}
void Infinite_Loop()
{
HERE: goto HERE;
}
You seem to be an ignoramus. Ordinary ignorance can be corrected.
Completely irrelevant. There is no infinite loop in HHH because HHH
aborts after N recursions, not after an Infinite_Recursion.
Thus you already knew that your statement was false before you
said it. Infinite_Loop() need not be emulated to non-existent
completion before HHH recognizes its infinite behavior pattern.
Why say things that you know are false?
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
On 8/11/2024 2:54 PM, Fred. Zwarts wrote:
Op 11.aug.2024 om 13:45 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
Since no DDD is correctly simulated by HHH, we are talking about the
properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt
state. It aborts one cycle before the simulated HHH would reach its
'return' instruction, after which DDD would reach its halt state.
Every C programmer understands that a simulation fails if it does not
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
reach the end of a halting program.
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
On 8/13/2024 2:29 AM, Fred. Zwarts wrote:
Op 12.aug.2024 om 14:42 schreef olcott:
On 8/11/2024 2:54 PM, Fred. Zwarts wrote:
Op 11.aug.2024 om 13:45 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
Since no DDD is correctly simulated by HHH, we are talking about the
properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt
state. It aborts one cycle before the simulated HHH would reach its
'return' instruction, after which DDD would reach its halt state.
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
Every C programmer understands that a simulation fails if it does not >>>> reach the end of a halting program.
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
Many more experts with master degrees tell you that it does halt.
Show evidence instead of authority.
*Every attempt at rebutting this has been*
(a) Denying verified facts
(b) Strawman-deception of changing what I said and rebutting that
(c) Pure ad hominem insults with zero reasoning
Mike is the only one here that seems to have enough technical
skill to understand the verified facts.
Everyone else denies them entirely on the basis of their own ignorance.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
On 8/13/2024 2:29 AM, Fred. Zwarts wrote:
Op 12.aug.2024 om 14:42 schreef olcott:
On 8/11/2024 2:54 PM, Fred. Zwarts wrote:Many more experts with master degrees tell you that it does halt.
Op 11.aug.2024 om 13:45 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
Since no DDD is correctly simulated by HHH, we are talking about the
properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt
state. It aborts one cycle before the simulated HHH would reach its
'return' instruction, after which DDD would reach its halt state.
Every C programmer understands that a simulation fails if it does
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
not reach the end of a halting program.
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
Show evidence instead of authority.
*Every attempt at rebutting this has been*
(a) Denying verified facts
(b) Strawman-deception of changing what I said and rebutting that
(c) Pure ad hominem insults with zero reasoning
Mike is the only one here that seems to have enough technical
skill to understand the verified facts. Everyone else denies them
entirely on the basis of their own ignorance.
Overview of proof that the input to HHH(DDD) specifies non-halting behavior We prove that the simulation is correct.
Then we prove that this simulation cannot possibly
reach its final halt state / ever stop running without being aborted.
The semantics of the x86 language conclusive proves this is true.
Thus when we measure the behavior specified by this finite
string by DDD correctly simulated/emulated by HHH it specifies
non-halting behavior.
On 8/13/2024 6:08 AM, Mikko wrote:
On 2024-08-11 11:45:18 +0000, olcott said:
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
To emulate an infinite set of DDD by infintely manu emulators
is too much to actually do. However, one may pick a HHHᵤ and
DDDᵥ so that HHHᵤ(DDDᵥ) correctly determines that DDDᵥ halts.
Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
Thus when computing the behavior that this finite string
specifies no DDD ever halts.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD always has the exact same finite string of machine
code bytes. This requires each HHH to always be at machine
address 000015d2.
The computation is always reporting whether or not DDD
can possibly reach its c3 "ret" instruction at machine
address [00002183].
When DDD is correctly emulated by each HHHₙ then DDD never
reaches its "return" instruction final halt state.
On 8/13/2024 8:34 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/13/2024 2:29 AM, Fred. Zwarts wrote:
Op 12.aug.2024 om 14:42 schreef olcott:
On 8/11/2024 2:54 PM, Fred. Zwarts wrote:
Op 11.aug.2024 om 13:45 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
Since no DDD is correctly simulated by HHH, we are talking about the >>>>>> properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt
state. It aborts one cycle before the simulated HHH would reach its >>>>>> 'return' instruction, after which DDD would reach its halt state.
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
Your words are understandable; they're just wrong.
Every C programmer understands that a simulation fails if it does not >>>>>> reach the end of a halting program.
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
It's not clear what these "expert programmers" have agreed to. As Fred
has frequently pointed out, your DDD cannot be correctly simulated by
HHH, so you have an empty set about which anything is true.
Many more experts with master degrees tell you that it does halt.
Show evidence instead of authority.
*Every attempt at rebutting this has been*
There's nothing to rebut. You just keep coming out with blatant
falsehoods, as pointed out by the other posters, here.
(a) Denying verified facts
That's a lie. By "verified facts" you just mean "falsehoods PO would
like to be true".
(b) Strawman-deception of changing what I said and rebutting that
That's a lie, too. I've not seen anybody else apart from you doing this. >> Indeed you're doing this as a response to Fred's last post.
(c) Pure ad hominem insults with zero reasoning
That's also false. The insults follow as a result of your falsehoods and >> lies. They are entirely justified. You continually insult other posters >> by several means, including ignoring what they write. If you would
actually treat them with respect, the insults against you would cease.
Mike is the only one here that seems to have enough technical
skill to understand the verified facts.
You mean agree with your falsehoods. Mike doesn't do this. You wouldn't >> know technical skill if it bit you on the nose.
Everyone else denies them entirely on the basis of their own ignorance.
You're the ignorant poster here, nobody else. You've taken a small part
of an undergraduate mathematics or computer science course, something the
typcial student would master in a few hours at most, spent 20 years on
it, and you still don't get it.
[ .... ]
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
void DDD()
{
HHH(DDD);
return;
}
Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
HHH is only required to predict whether or not an unlimited
emulation of DDD would ever halt.
Thus when computing the behavior that this finite string
specifies DDD never halts.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD always has the exact same finite string of machine
code bytes. This requires each HHH to always be at machine
address 000015d2.
The computation is always reporting whether or not DDD
can possibly reach its c3 "ret" instruction at machine
address [00002183].
On 8/13/2024 2:29 AM, Fred. Zwarts wrote:
Op 12.aug.2024 om 14:42 schreef olcott:
On 8/11/2024 2:54 PM, Fred. Zwarts wrote:Many more experts with master degrees tell you that it does halt.
Op 11.aug.2024 om 13:45 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
Since no DDD is correctly simulated by HHH, we are talking about the
properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt
state. It aborts one cycle before the simulated HHH would reach its
'return' instruction, after which DDD would reach its halt state.
Every C programmer understands that a simulation fails if it does
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
not reach the end of a halting program.
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
Show evidence instead of authority.
*Every attempt at rebutting this has been*
(a) Denying verified facts
(b) Strawman-deception of changing what I said and rebutting that
(c) Pure ad hominem insults with zero reasoning
Mike is the only one here that seems to have enough technical
skill to understand the verified facts. Everyone else denies them
entirely on the basis of their own ignorance.
Overview of proof that the input to HHH(DDD) specifies non-halting behavior We prove that the simulation is correct.
Then we prove that this simulation cannot possibly
reach its final halt state / ever stop running without being aborted.
The semantics of the x86 language conclusive proves this is true.
Thus when we measure the behavior specified by this finite
string by DDD correctly simulated/emulated by HHH it specifies
non-halting behavior.
On 8/13/2024 8:34 AM, Alan Mackenzie wrote:
olcott <polcott333@gmail.com> wrote:
On 8/13/2024 2:29 AM, Fred. Zwarts wrote:
Op 12.aug.2024 om 14:42 schreef olcott:
On 8/11/2024 2:54 PM, Fred. Zwarts wrote:
Op 11.aug.2024 om 13:45 schreef olcott:
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
Since no DDD is correctly simulated by HHH, we are talking about the >>>>>> properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt
state. It aborts one cycle before the simulated HHH would reach its >>>>>> 'return' instruction, after which DDD would reach its halt state.
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
Your words are understandable; they're just wrong.
Every C programmer understands that a simulation fails if it does not >>>>>> reach the end of a halting program.
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
It's not clear what these "expert programmers" have agreed to. As Fred
has frequently pointed out, your DDD cannot be correctly simulated by
HHH, so you have an empty set about which anything is true.
Many more experts with master degrees tell you that it does halt.
Show evidence instead of authority.
*Every attempt at rebutting this has been*
There's nothing to rebut. You just keep coming out with blatant
falsehoods, as pointed out by the other posters, here.
(a) Denying verified facts
That's a lie. By "verified facts" you just mean "falsehoods PO would
like to be true".
(b) Strawman-deception of changing what I said and rebutting that
That's a lie, too. I've not seen anybody else apart from you doing this. >> Indeed you're doing this as a response to Fred's last post.
(c) Pure ad hominem insults with zero reasoning
That's also false. The insults follow as a result of your falsehoods and >> lies. They are entirely justified. You continually insult other posters >> by several means, including ignoring what they write. If you would
actually treat them with respect, the insults against you would cease.
Mike is the only one here that seems to have enough technical
skill to understand the verified facts.
You mean agree with your falsehoods. Mike doesn't do this. You wouldn't >> know technical skill if it bit you on the nose.
Everyone else denies them entirely on the basis of their own ignorance.
You're the ignorant poster here, nobody else. You've taken a small part
of an undergraduate mathematics or computer science course, something the
typcial student would master in a few hours at most, spent 20 years on
it, and you still don't get it.
[ .... ]
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
void DDD()
{
HHH(DDD);
return;
}
Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
HHH is only required to predict whether or not an unlimited
emulation of DDD would ever halt.
Thus when computing the behavior that this finite string
specifies DDD never halts.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
DDD always has the exact same finite string of machine
code bytes. This requires each HHH to always be at machine
address 000015d2.
The computation is always reporting whether or not DDD
can possibly reach its c3 "ret" instruction at machine
address [00002183].
On 8/13/2024 6:08 AM, Mikko wrote:
On 2024-08-11 11:45:18 +0000, olcott said:
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
To emulate an infinite set of DDD by infintely manu emulators
is too much to actually do. However, one may pick a HHHᵤ and
DDDᵥ so that HHHᵤ(DDDᵥ) correctly determines that DDDᵥ halts.
Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
On 8/14/2024 2:41 AM, Mikko wrote:
On 2024-08-13 13:21:32 +0000, olcott said:
On 8/13/2024 6:08 AM, Mikko wrote:
On 2024-08-11 11:45:18 +0000, olcott said:
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely >>>>>>>>>>> *emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
To emulate an infinite set of DDD by infintely manu emulators
is too much to actually do. However, one may pick a HHHᵤ and
DDDᵥ so that HHHᵤ(DDDᵥ) correctly determines that DDDᵥ halts.
Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
No, we don't see, at least as long as you don't show.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
The impossibility of DDD emulated by HHH
(according to the semantics of the x86 language)
to reach its own machine address [00002183] is
compete proof.
We don't even need an actual HHH we only need
to imagine that HHH is a pure x86 emulator and
then anyone with sufficient expertise in the x86
language can see that DDD correctly emulated by
HHH never reaches machine address [00002183].
On 8/14/2024 2:41 AM, Mikko wrote:The impossibility [...] is proof that DDD doesn't return? Wow.
On 2024-08-13 13:21:32 +0000, olcott said:The impossibility of DDD emulated by HHH (according to the semantics of
On 8/13/2024 6:08 AM, Mikko wrote:
On 2024-08-11 11:45:18 +0000, olcott said:
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:void DDD()
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:*The set of HHH x86 emulators are defined such that*
On 8/9/2024 4:03 AM, Mikko wrote:Looks like encrypted text that might mean something.
On 2024-08-08 13:18:34 +0000, olcott said:
Each HHH of every HHH that can possibly exist definitely >>>>>>>>>>> *emulates zero to infinity instructions correctly* In none of >>>>>>>>>>> these cases does the emulated DDD ever reach its "return" >>>>>>>>>>> instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
"Colorless green ideas sleep furiously"This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates zero toThat doesn't restrict much.
infinity instructions of DDD.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the set of >>>>>>>>> non-negative integers indicating the number of x86 instructions >>>>>>>>> of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of the set >>>>>>>>> of positive integers indicating the number of x86 instructions >>>>>>>>> of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
Each element of this set corresponds to one element of the set of >>>>>>> positive integers indicating the number of x86 instructions of DDD >>>>>>> that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article that uses
the same name for a specific program and a set.
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite set
DDD correctly emulated by each element of that set never reaches its >>>>> own "return" instruction halt state.
To emulate an infinite set of DDD by infintely manu emulators is too
much to actually do. However, one may pick a HHHᵤ and DDDᵥ so that >>>> HHHᵤ(DDDᵥ) correctly determines that DDDᵥ halts.
Through something like mathematical induction we can directly see that
DDD correctly emulated by any HHH cannot possibly reach its "return"
instruction final halt state.
No, we don't see, at least as long as you don't show.
the x86 language) to reach its own machine address [00002183] is compete proof.
We don't even need an actual HHH we only need to imagine that HHH is aHHH is not a pure simulator, because it aborts.
pure x86 emulator and then anyone with sufficient expertise in the x86 language can see that DDD correctly emulated by HHH never reaches
machine address [00002183].
On 8/14/2024 2:41 AM, Mikko wrote:
On 2024-08-13 13:21:32 +0000, olcott said:
On 8/13/2024 6:08 AM, Mikko wrote:
On 2024-08-11 11:45:18 +0000, olcott said:
On 8/11/2024 1:30 AM, Mikko wrote:
On 2024-08-10 11:30:34 +0000, olcott said:
On 8/10/2024 3:29 AM, Mikko wrote:
On 2024-08-09 14:51:51 +0000, olcott said:
On 8/9/2024 4:03 AM, Mikko wrote:
On 2024-08-08 13:18:34 +0000, olcott said:
void DDD()
{
HHH(DDD);
return;
}
Each HHH of every HHH that can possibly exist definitely >>>>>>>>>>> *emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.
The ranges of "each HHH" and "every HHH" are not defined above >>>>>>>>>> so that does not really mean anything.
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU I*(ubn)I*054 gfdpodf["
Looks like encrypted text that might mean something.
"Colorless green ideas sleep furiously"
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
I defined an infinite set of HHH x86 emulators.
Maybe somewnete but not in the message I commented.
I stipulated that each member of this set emulates
zero to infinity instructions of DDD.
That doesn't restrict much.
*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.
It is easier to talk about mapping if is given a name.
*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
*The set of HHH x86 emulators are defined such that*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.
As we onece observed, this would be clearer with incdices.
No journal woth of consideration will accept an article
that uses the same name for a specific program and a set.
void DDD()
{
HHH(DDD);
return;
}
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.
To emulate an infinite set of DDD by infintely manu emulators
is too much to actually do. However, one may pick a HHHᵤ and
DDDᵥ so that HHHᵤ(DDDᵥ) correctly determines that DDDᵥ halts.
Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
No, we don't see, at least as long as you don't show.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
The impossibility of DDD emulated by HHH
(according to the semantics of the x86 language)
to reach its own machine address [00002183] is
compete proof.
On 8/15/2024 3:52 AM, Mikko wrote:
On 2024-08-14 13:47:16 +0000, olcott said:
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
The impossibility of DDD emulated by HHH
(according to the semantics of the x86 language)
to reach its own machine address [00002183] is
compete proof.
No, it is not. Nothing is a proof except a proof.
An inductive proof of the execution trace shows that
DDD emulated according to the semantics of the x86
language cannot possibly reach machine address 00002183.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 493 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 180:53:57 |
| Calls: | 9,705 |
| Files: | 13,737 |
| Messages: | 6,179,422 |