On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people. One of
them, by accident, drops some beetroot on Olcott's back. Now we can ask
all people: "Does Olcott have a red stain on his back?". They will all
say: "yes he has a red stain on his back.". But what happens when we
would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct measure. >>> I cannot report on what other people see. I must report on my own back,
other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the input for
my eyes. The correct measure for a red stain is that my eyes are
reachable for the red light. Since the light from my back cannot
possible reach my eyes, the input for my eyes does not specify a red
stain. Therefore, I have 100% proven that the input specifies that there >>> is no red stain on my back. When somebody says that I am wrong to claim
that there is no red stain on my back, he is a liar and does not pay
enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad.

/Flibble

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

I think that the issue with Fred and Joes is that they
lack sufficient technical competence to directly see
that HHH does correctly simulate itself simulating
DD until HHH correctly sees that neither DDD nor itself
would ever stop running unless HHH(DD) aborts the
simulation of its input.

No, it shows that you don't understand the meaning of correct simulation
as a term of art.

Sorry, this is the point you have proven MANY times, that you just don't
know the meaning of the words you use, or the rules of the logic system.
and thus all your arguement as just unsound and invalid.

You have admitted to the facts that proves you are just a pathological
lier and your argument is just a big fat category error, that you are
just too stupid to understand.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 22.jul.2025 om 20:05 schreef olcott:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people. One of
them, by accident, drops some beetroot on Olcott's back. Now we can ask
all people: "Does Olcott have a red stain on his back?". They will all
say: "yes he has a red stain on his back.". But what happens when we
would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct measure. >>> I cannot report on what other people see. I must report on my own back,
other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the input for
my eyes. The correct measure for a red stain is that my eyes are
reachable for the red light. Since the light from my back cannot
possible reach my eyes, the input for my eyes does not specify a red
stain. Therefore, I have 100% proven that the input specifies that there >>> is no red stain on my back. When somebody says that I am wrong to claim
that there is no red stain on my back, he is a liar and does not pay
enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad.

/Flibble

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

I think that the issue with Fred and Joes is that they
lack sufficient technical competence to directly see
that HHH does correctly simulate itself simulating
DD until HHH correctly sees that neither DDD nor itself
would ever stop running unless HHH(DD) aborts the
simulation of its input.

As usual counter-factual claims without evidence.

The problem is that Olcott does not see that the simulated HHH that is programmed to abort after a finite recursion, does not need to be
aborted when simulated.
He can hold his claim only by cheating with the Root variable, which
causes that the simulated HHH is different from the simulating HHH.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 23.jul.2025 om 05:59 schreef olcott:

On 7/22/2025 9:20 PM, Richard Damon wrote:

On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people. One of >>>>> them, by accident, drops some beetroot on Olcott's back. Now we can
ask
all people: "Does Olcott have a red stain on his back?". They will all >>>>> say: "yes he has a red stain on his back.". But what happens when we >>>>> would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct
measure.
I cannot report on what other people see. I must report on my own
back,
other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the input for >>>>> my eyes. The correct measure for a red stain is that my eyes are
reachable for the red light. Since the light from my back cannot
possible reach my eyes, the input for my eyes does not specify a red >>>>> stain. Therefore, I have 100% proven that the input specifies that
there
is no red stain on my back. When somebody says that I am wrong to
claim
that there is no red stain on my back, he is a liar and does not pay >>>>> enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad.

/Flibble

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

I think that the issue with Fred and Joes is that they
lack sufficient technical competence to directly see
that HHH does correctly simulate itself simulating
DD until HHH correctly sees that neither DDD nor itself
would ever stop running unless HHH(DD) aborts the
simulation of its input.

No, it shows that you don't understand the meaning of correct
simulation as a term of art.

Sorry, this is the point you have proven MANY times, that you just
don't know the meaning of the words you use, or the rules of the logic
system. and thus all your arguement as just unsound and invalid.

You have admitted to the facts that proves you are just a pathological
lier and your argument is just a big fat category error, that you are
just too stupid to understand.

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

I challenged you to find an emulation of DDD
by HHH (according to the semantics of the x86
language) where the simulated DDD reaches its
"return" statement final halt state.

Irrelevant challenge, it makes no sense to search for a solution for a
problem for which it has already be proven that no solution exists.
You could as well challenge to draw a square circle.
World class simulators have no problem to reach the final halt state of
exactly the same input, which is a 100% proof that the final halt state
exists.
But no simulator can possibly simulate itself correctly up to the end,
which shows that simulation is not always the correct tool to analyse
the halting behaviour of all possible inputs.

Like TACO (Trump always chickens out) you always
chicken out.

The call from DDD to HHH(DDD) does emulate HHH
emulating its own DDD until this emulated emulated
DDD calls yet another HHH(DDD).

In a finite recursion, as shown by world class simulators. But HHH
aborts this simulation before it can see that.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Tue, 22 Jul 2025 22:20:24 -0400, Richard Damon wrote:

On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people. One
of them, by accident, drops some beetroot on Olcott's back. Now we
can ask all people: "Does Olcott have a red stain on his back?". They
will all say: "yes he has a red stain on his back.". But what happens
when we would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct
measure.
I cannot report on what other people see. I must report on my own
back, other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the input
for my eyes. The correct measure for a red stain is that my eyes are
reachable for the red light. Since the light from my back cannot
possible reach my eyes, the input for my eyes does not specify a red
stain. Therefore, I have 100% proven that the input specifies that
there is no red stain on my back. When somebody says that I am wrong
to claim that there is no red stain on my back, he is a liar and does
not pay enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad.

/Flibble

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

I think that the issue with Fred and Joes is that they lack sufficient
technical competence to directly see that HHH does correctly simulate
itself simulating DD until HHH correctly sees that neither DDD nor
itself would ever stop running unless HHH(DD) aborts the simulation of
its input.

No, it shows that you don't understand the meaning of correct simulation
as a term of art.

Sorry, this is the point you have proven MANY times, that you just don't
know the meaning of the words you use, or the rules of the logic system.
and thus all your arguement as just unsound and invalid.

You have admitted to the facts that proves you are just a pathological
lier and your argument is just a big fat category error, that you are
just too stupid to understand.

Another ad hominem attack; your failure at debate/argumentation would be extremely embarassing if it wasn't for your lack of insight into your own ineptitude, Damon.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On Thu, 24 Jul 2025 08:15:12 +0800, wij wrote:

On Wed, 2025-07-23 at 23:54 +0000, Mr Flibble wrote:

On Tue, 22 Jul 2025 22:20:24 -0400, Richard Damon wrote:

On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people.
One of them, by accident, drops some beetroot on Olcott's back.
Now we can ask all people: "Does Olcott have a red stain on his
back?". They will all say: "yes he has a red stain on his
back.". But what happens when we would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct
measure.
I cannot report on what other people see. I must report on my
own back, other people are not reporting on there own back, so
we are not reporting on the same back. What other people see is
not the input for my eyes. The correct measure for a red stain
is that my eyes are reachable for the red light. Since the
light from my back cannot possible reach my eyes, the input for
my eyes does not specify a red stain. Therefore, I have 100%
proven that the input specifies that there is no red stain on
my back. When somebody says that I am wrong to claim that there
is no red stain on my back, he is a liar and does not pay
enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly
bad.

/Flibble

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

I think that the issue with Fred and Joes is that they lack
sufficient technical competence to directly see that HHH does
correctly simulate itself simulating DD until HHH correctly sees
that neither DDD nor itself would ever stop running unless HHH(DD)
aborts the simulation of its input.

No, it shows that you don't understand the meaning of correct
simulation as a term of art.

Sorry, this is the point you have proven MANY times, that you just
don't know the meaning of the words you use, or the rules of the
logic system.
and thus all your arguement as just unsound and invalid.

You have admitted to the facts that proves you are just a
pathological lier and your argument is just a big fat category error,
that you are just too stupid to understand.

Another ad hominem attack; your failure at debate/argumentation would
be extremely embarassing if it wasn't for your lack of insight into
your own ineptitude, Damon.

/Flibble

You have the similar problem as olcott has with HP. HP does not have self-reference issue.

Yes, it does.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2025-07-24 18:36, olcott wrote:

On 7/24/2025 7:14 PM, wij wrote:

On Thu, 2025-07-24 at 07:45 -0500, olcott wrote:

On 7/23/2025 11:58 PM, wij wrote:

I am talking about basic logic. It seems you cannot even recognize it!
P1= A AND B
P2= IF A THEN B
What does ~P1,~P2 mean?

I have been a professional programmer since 1984.
I have been a C++ software engineer since 2001.

Who cares? What does this have to do with logic?

Here is a list of the logic symbols. https://en.wikipedia.org/wiki/List_of_logic_symbols
I refer to it often so that I can cut-and-paste them.

I hate to break it to you, but your ability to cut-and-past symbols from
a list on wikipedia says nothing about your logical abilities. And it
doesn't matter how often you refer to that list since that list isn't
going to teach you anything about how these symbols are actually used.
That would require you to study actual logic.

What is the logic error here: G := ⊬G (Prolog knows)

That's simply an abuse of symbols. It isn't a logical statement or even
a coherent metalogical statement.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/22/25 11:59 PM, olcott wrote:

On 7/22/2025 9:20 PM, Richard Damon wrote:

On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people. One of >>>>> them, by accident, drops some beetroot on Olcott's back. Now we can
ask
all people: "Does Olcott have a red stain on his back?". They will all >>>>> say: "yes he has a red stain on his back.". But what happens when we >>>>> would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct
measure.
I cannot report on what other people see. I must report on my own
back,
other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the input for >>>>> my eyes. The correct measure for a red stain is that my eyes are
reachable for the red light. Since the light from my back cannot
possible reach my eyes, the input for my eyes does not specify a red >>>>> stain. Therefore, I have 100% proven that the input specifies that
there
is no red stain on my back. When somebody says that I am wrong to
claim
that there is no red stain on my back, he is a liar and does not pay >>>>> enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad.

/Flibble

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

I think that the issue with Fred and Joes is that they
lack sufficient technical competence to directly see
that HHH does correctly simulate itself simulating
DD until HHH correctly sees that neither DDD nor itself
would ever stop running unless HHH(DD) aborts the
simulation of its input.

No, it shows that you don't understand the meaning of correct
simulation as a term of art.

Sorry, this is the point you have proven MANY times, that you just
don't know the meaning of the words you use, or the rules of the logic
system. and thus all your arguement as just unsound and invalid.

You have admitted to the facts that proves you are just a pathological
lier and your argument is just a big fat category error, that you are
just too stupid to understand.

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

I challenged you to find an emulation of DDD
by HHH (according to the semantics of the x86
language) where the simulated DDD reaches its
"return" statement final halt state.

But that is just a strawman, as your HHH doesn't do that.

HHH1 shows that the correct simulation of the input (which includes all
of the memory of the program since that is needed to make DDD actually simulatable) will reach a final state, and the only HHH that can exist
aborts too soon.

Like TACO (Trump always chickens out) you always
chicken out.

Nope, I show the correct answer, but you dodge, dip, duck, dive and
dodge, to avoid your error.

The call from DDD to HHH(DDD) does emulate HHH
emulating its own DDD until this emulated emulated
DDD calls yet another HHH(DDD).

Right, which isn't far enough, as the correct simulation of that input,
which HHH doesn't do, when continued for one more iteration through
would see that the first HHH being emulated ALSO aborts its simulation
and returns to DDD and thus it halts.

Your problem is you keep on working off of self-contradictory
statements, which you have stated is just not allowed, so you have
declared your own argument invalid.

You can't have two different HHHs at once, and the HHH that answers
doesn't do a correct simulation, so it can't look at the results of the different input based on the different HHH.

That is just admitting that you are just a pathological liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 25.jul.2025 om 05:56 schreef olcott:

On 7/24/2025 10:05 PM, Richard Damon wrote:

On 7/22/25 11:59 PM, olcott wrote:

On 7/22/2025 9:20 PM, Richard Damon wrote:

On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people.
One of
them, by accident, drops some beetroot on Olcott's back. Now we
can ask
all people: "Does Olcott have a red stain on his back?". They
will all
say: "yes he has a red stain on his back.". But what happens when we >>>>>>> would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct
measure.
I cannot report on what other people see. I must report on my own >>>>>>> back,
other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the
input for
my eyes. The correct measure for a red stain is that my eyes are >>>>>>> reachable for the red light. Since the light from my back cannot >>>>>>> possible reach my eyes, the input for my eyes does not specify a red >>>>>>> stain. Therefore, I have 100% proven that the input specifies
that there
is no red stain on my back. When somebody says that I am wrong to >>>>>>> claim
that there is no red stain on my back, he is a liar and does not pay >>>>>>> enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad. >>>>>>
/Flibble

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

I think that the issue with Fred and Joes is that they
lack sufficient technical competence to directly see
that HHH does correctly simulate itself simulating
DD until HHH correctly sees that neither DDD nor itself
would ever stop running unless HHH(DD) aborts the
simulation of its input.

No, it shows that you don't understand the meaning of correct
simulation as a term of art.

Sorry, this is the point you have proven MANY times, that you just
don't know the meaning of the words you use, or the rules of the
logic system. and thus all your arguement as just unsound and invalid. >>>>
You have admitted to the facts that proves you are just a
pathological lier and your argument is just a big fat category
error, that you are just too stupid to understand.

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

I challenged you to find an emulation of DDD
by HHH (according to the semantics of the x86
language) where the simulated DDD reaches its
"return" statement final halt state.

But that is just a strawman, as your HHH doesn't do that.

Great then you are agreeing that it is impossible.

Yes it is impossible to fix HHH.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/24/25 11:56 PM, olcott wrote:

On 7/24/2025 10:05 PM, Richard Damon wrote:

On 7/22/25 11:59 PM, olcott wrote:

On 7/22/2025 9:20 PM, Richard Damon wrote:

On 7/22/25 2:05 PM, olcott wrote:

On 7/22/2025 12:54 PM, Mr Flibble wrote:

On Tue, 22 Jul 2025 12:58:49 +0200, Fred. Zwarts wrote:

;-)

Suppose Olcott is visiting a restaurant with many other people.
One of
them, by accident, drops some beetroot on Olcott's back. Now we
can ask
all people: "Does Olcott have a red stain on his back?". They
will all
say: "yes he has a red stain on his back.". But what happens when we >>>>>>> would ask it Olcott himself:
I think he will say:
"That all others see a red stain on may back is not the correct
measure.
I cannot report on what other people see. I must report on my own >>>>>>> back,
other people are not reporting on there own back, so we are not
reporting on the same back. What other people see is not the
input for
my eyes. The correct measure for a red stain is that my eyes are >>>>>>> reachable for the red light. Since the light from my back cannot >>>>>>> possible reach my eyes, the input for my eyes does not specify a red >>>>>>> stain. Therefore, I have 100% proven that the input specifies
that there
is no red stain on my back. When somebody says that I am wrong to >>>>>>> claim
that there is no red stain on my back, he is a liar and does not pay >>>>>>> enough attention to what I say."

;-)

Some analogies are worse than others; this one is particularly bad. >>>>>>
/Flibble

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

I think that the issue with Fred and Joes is that they
lack sufficient technical competence to directly see
that HHH does correctly simulate itself simulating
DD until HHH correctly sees that neither DDD nor itself
would ever stop running unless HHH(DD) aborts the
simulation of its input.

No, it shows that you don't understand the meaning of correct
simulation as a term of art.

Sorry, this is the point you have proven MANY times, that you just
don't know the meaning of the words you use, or the rules of the
logic system. and thus all your arguement as just unsound and invalid. >>>>
You have admitted to the facts that proves you are just a
pathological lier and your argument is just a big fat category
error, that you are just too stupid to understand.

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

I challenged you to find an emulation of DDD
by HHH (according to the semantics of the x86
language) where the simulated DDD reaches its
"return" statement final halt state.

But that is just a strawman, as your HHH doesn't do that.

Great then you are agreeing that it is impossible.

Right, but not for the reason you think, HHH can't emulate DDD to the
return because it always does an incorrect emulation by aborting before
it gets there.

The CORRECT emulation of DDD will always reach the return statement,
because by your definitions, the HHH that DDD calls will always abort
and return 0, thus DDD always Halts.

The fact that HHH nevers sees that and foolishly thinks that because it
hasn't seen it means it can't have happened just makes it wrong.

Just like that fact that you have proven yourself to be a stupid and
ignorant pathetic pathological liar isn't negated by the fact that you
are too stupid and ignorant to see that fact. It just makes you wrong
when you claim to be right.

Not knowing something is not the same as know that it is not.

That is part of your failed logic.

HHH1 shows that the correct simulation of the input (which includes
all of the memory of the program since that is needed to make DDD
actually simulatable) will reach a final state, and the only HHH that
can exist aborts too soon.

Like TACO (Trump always chickens out) you always
chicken out.

Nope, I show the correct answer, but you dodge, dip, duck, dive and
dodge, to avoid your error.

The call from DDD to HHH(DDD) does emulate HHH
emulating its own DDD until this emulated emulated
DDD calls yet another HHH(DDD).

Right, which isn't far enough, as the correct simulation of that
input, which HHH doesn't do, when continued for one more iteration
through would see that the first HHH being emulated ALSO aborts its
simulation and returns to DDD and thus it halts.

Your problem is you keep on working off of self-contradictory
statements, which you have stated is just not allowed, so you have
declared your own argument invalid.

You can't have two different HHHs at once, and the HHH that answers
doesn't do a correct simulation, so it can't look at the results of
the different input based on the different HHH.

That is just admitting that you are just a pathological liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/25/25 10:49 AM, olcott wrote:

On 7/25/2025 1:44 AM, Fred. Zwarts wrote:

Op 25.jul.2025 om 05:56 schreef olcott:

On 7/24/2025 10:05 PM, Richard Damon wrote:

On 7/22/25 11:59 PM, olcott wrote:

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

I challenged you to find an emulation of DDD
by HHH (according to the semantics of the x86
language) where the simulated DDD reaches its
"return" statement final halt state.

But that is just a strawman, as your HHH doesn't do that.

Great then you are agreeing that it is impossible.

Yes it is impossible to fix HHH.

HHH has been proven to emulate DDD and after this
DDD calls HHH(DDD) emulate itself emulating DDD
until this DDD calls HHH(DDD) again.

But only PARTIALLY, and thus can't define non-halting.

And it INCORRECTLY determines the behavior of HHH(DDD), so it can't have
been correct.

At that point HHH (and all the chat bots) see that
HHH recognizes the recursive simulation non-halting
behavior pattern.

Because you LIE to them.

I don't even tell these chat bots that DDD doesn't halt.
They figure out that DDD doesn't halt because of recursive
simulation on their own.

Yes you do, you say that HHH SEES the non-halting pattern.

I guess you are just admitting that you don't know the meaning of your word.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

Op 25.jul.2025 om 16:49 schreef olcott:

On 7/25/2025 1:44 AM, Fred. Zwarts wrote:

Op 25.jul.2025 om 05:56 schreef olcott:

On 7/24/2025 10:05 PM, Richard Damon wrote:

On 7/22/25 11:59 PM, olcott wrote:

_DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]

I challenged you to find an emulation of DDD
by HHH (according to the semantics of the x86
language) where the simulated DDD reaches its
"return" statement final halt state.

But that is just a strawman, as your HHH doesn't do that.

Great then you are agreeing that it is impossible.

Yes it is impossible to fix HHH.

HHH has been proven to emulate DDD and after this
DDD calls HHH(DDD) emulate itself emulating DDD
until this DDD calls HHH(DDD) again.

And after that HHH fails, because it stops the simulation and does not
complete it up to the end.

At that point HHH (and all the chat bots) see that
HHH recognizes the recursive simulation non-halting
behavior pattern.

No, the chat-boxes are indoctrinated that there is a non-halting pattern.
But other tools, such as world-class simulators show that when the x86 language is not violated with an abort, but continued, the final halt
state is reachable.

I don't even tell these chat bots that DDD doesn't halt.
They figure out that DDD doesn't halt because of recursive
simulation on their own.

No, you told them that HHH aborts because it sees a non-halting pattern.
That is the input, not the conclusion.

Fortunately, experts in this field are not so easy to mislead by claims
without evidence. They see, what even beginner can see, that a finite
recursion is no indication for non-halting behaviour.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)