XPost: comp.theory, sci.logic

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation >>>>>> would reach the final halt state in a finite number of steps, as proven >>>>>> by world-class simulators using exactly the same input. The infinity is >>>>>> only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT >>>>> CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to >>>> call anybody else here a liar. Glass house inhabitants, throwing stones, >>>> and all that.

And you used to distinguish yourself from other cranks by sticking to
decorous language, and generally being courteous. Not any more. That is >>>> a most unwelcome change.

void DDD()
{
HHH(DDD);
return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part. It can be attributed to your lack of
self awareness and lack of technical ability. Everybody here but you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable to judge
whether such a correct simulation is possible. Everybody else sees that
it is not, so further questions about it are non-sensical.

Instead of addressing this you used the dishonest dodge
of ad hominem attack. It is for this exact same reason
that I am justified in calling out liars.

For calling you the liar that you've been shown to be on this very
thread? That makes it doubly nauseating that you have the hypocrisy
(falsely) to accuse others of being liars.

As soon as the first person utterly gives up dishonestly
trolling me and gives my work an actual fair review I
will treat that person with kindness and respect.

Nobody's "dishonestly trolling" you. You wouldn't know a fair review if
it bit you on the nose. By "fair review" what you really mean is
somebody accepting your views. Other people here are too careful about
telling the truth to do that.

I tried kindness and respect for many years and the trolls
took this as weakness to be exploited.

Not at all. There's been the odd troll here over the years, Mr. Flibble probably being the latest of these, but in the main people have been
sincere and truthful. That appears to be something you can't deal with.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--
Alan Mackenzie (Nuremberg, Germany).

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

XPost: comp.theory, sci.logic

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation >>>>>>>> would reach the final halt state in a finite number of steps, as >>>>>>>> proven
by world-class simulators using exactly the same input. The
infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls
HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD
DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no
position to
call anybody else here a liar.  Glass house inhabitants, throwing >>>>>> stones,
and all that.

And you used to distinguish yourself from other cranks by sticking to >>>>>> decorous language, and generally being courteous.  Not any more.
That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to your lack of >>>> self awareness and lack of technical ability.  Everybody here but
you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable to judge
whether such a correct simulation is possible.  Everybody else sees that
it is not, so further questions about it are non-sensical.

void DDD()
{
  HHH(DDD);
  return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole simulation
correct. In contrast, the failure to simulate a single instruction
correctly, makes the whole simulation incorrect.
In this case it is the failure to simulate the call instruction. The
simulation aborts at this point, where the semantics of the x86 language requires the execution of the next instruction.
This premature abort, based on the incorrect assumption that a finite
recursion specifies non-halting, makes the whole simulation incorrect
and, what is worse, the conclusion of non-halting behaviour fails.

Further irrelevant claims without evidence ignored.

Perhaps you have an ACM email address and don't
know very much about programming?

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

XPost: comp.theory, sci.logic

On 7/30/25 1:00 AM, olcott wrote:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation >>>>>>>> would reach the final halt state in a finite number of steps, as >>>>>>>> proven
by world-class simulators using exactly the same input. The
infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls
HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD
DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no
position to
call anybody else here a liar.  Glass house inhabitants, throwing >>>>>> stones,
and all that.

And you used to distinguish yourself from other cranks by sticking to >>>>>> decorous language, and generally being courteous.  Not any more.
That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to your lack of >>>> self awareness and lack of technical ability.  Everybody here but
you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable to judge
whether such a correct simulation is possible.  Everybody else sees that
it is not, so further questions about it are non-sensical.

void DDD()
{
  HHH(DDD);
  return;
}

_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]

Not a valid input, as not a complete program.

This is IMPOSSIBE to correctly simulate without an addition to this input.

I have no idea why are are saying the something
that is trivial is impossible.

You can't use information that isn't given to you.

This seems to be one of your basic problems, you assume that you can
"guess" as to what something you don't look at will do

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

And NOT correctly emulated the program the input is supposed to have represented.

Your claim is that a part of a truth is truth, but it isn't.

Perhaps you have an ACM email address and don't
know very much about programming?

No, it is YOU that shows you don't know about programming, since you
clearly don't know what a PROGRAM is.

You seem to think that programs have free will and can decide to do what
they want, rather than being the deterministic algorithms they are.

You seem to think that fragments can be considered as programs, when
they can not.

It seems you couldn't pass a first years computer science course due to
your stupidity.

Maybe you can qualify as a junior coder, as you can throw together
pieces of code, but it seems you don't know why or how they work.

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

XPost: comp.theory, sci.logic

On 7/30/25 10:12 AM, olcott wrote:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the
simulation
would reach the final halt state in a finite number of steps, >>>>>>>>>> as proven
by world-class simulators using exactly the same input. The >>>>>>>>>> infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls >>>>>>>>> HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD >>>>>>>>> DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no
position to
call anybody else here a liar.  Glass house inhabitants,
throwing stones,
and all that.

And you used to distinguish yourself from other cranks by
sticking to
decorous language, and generally being courteous.  Not any more. >>>>>>>> That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to your
lack of
self awareness and lack of technical ability.  Everybody here but >>>>>> you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable to judge >>>> whether such a correct simulation is possible.  Everybody else sees
that
it is not, so further questions about it are non-sensical.

void DDD()
{
   HHH(DDD);
   return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole simulation correct.

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

But not that *ALL* of it was simulated correctly.

You seem to think answering the first couple of questions on the test
and then stoping deserves a 100 on the test.

In contrast, the failure to simulate a single instruction correctly,
makes the whole simulation incorrect.
In this case it is the failure to simulate the call instruction.

My code conclusively proves that HHH does simulate
itself simulating DDD. That you do not understand
this code well enough to understand that is less
than no rebuttal at all.

But not CORRECTLY, which means COMPLETELY.

In fact, the code proves that HHH doesn't CORRECTLY simulate the whole
input, and thus can not be a source to define that the input doesn't halt.

The simulation aborts at this point, where the semantics of the x86
language requires the execution of the next instruction.

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its simulation and returns 0,

But you HHH failed here, as the pattern is NOT a "no-terminating
behavior pattern", as the halting DDD has that pattern in it and still
halts.

The problem is you think the HHH is the non-aborting HHH, but that isn't
the HHH that is in the memory, so that thought is just a LIE.

Your HHH is just WRONG, and thus you LIE when you claim it to be correct.

(b) Its simulated input reaches its simulated "return" statement then it returns 1.

My code conclusively proves that HHH does simulate itself
simulating DDD until any sufficiently competent person can
correctly determine a repeating pattern that cannot possibly
reach its own "return" statement final halt state even with
an infinite simulation.

No, it simulates until you can lie to yourself that it seems to be
non-halting.

That you do not understand this code well enough to
understand that is less than no rebuttal at all. https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which can be used to prove that DDD will halt, and thus the pattern it
detects is incorrect.

When it does detect this pattern then it kills the
whole DDD process so that there is no stack unwinding.

It may stop that process, but not the behavior of the PROGRAM that it represents. This just shows you have a wrong view of what you are
supposed to be looking at. We aren't talking about an instance of
simulation, but the actual DEFINED behavior, what happens when the
program is allowed to behave.

; This premature abort, based on the incorrect assumption that a finite
recursion specifies non-halting, makes the whole simulation incorrect
and, what is worse, the conclusion of non-halting behaviour fails.

HHH uses exactly same process on this function.

But those DO run forever, so that comparison doesn't prove anything
except that you think different things are the same,

One sign of insanity.

void Infinite_Recursion()
{
  Infinite_Recursion();
  return;
}

as it does this function.

void DDD()
{
  HHH(DDD);
  return;
}

Except they are different, and behave differently.

HHH has no idea that DDD is calling itself.

Then why do it assume it? If it doesn't know that it is itself, how does
it know it will "simulate" the input?

And that would be a wrong definition of the HHH that it calls, as it
actually simulates that input till it detects what it thinks is a
non-halting pattern and then returns 0.

Why did you lie to HHH about what was in the memory?

Only because if you told the truth to HHH, it would show that you
statement about HHH being correct was a lie.

HHH just sees that DDD is calling the same function
with the same parameter twice in sequence, just like
Infinite_Recursion().

But the problem is HHH thinks that HHH isn't part of HHH, which would be
like saying the recursed call to Infinite_Reursion isn't part of that
program.

Since the HHH that DDD calls is part of it, HHH needs to simulate AND
SHOW that. And since that HHH has conditionals in it, you can't just
assume the loop is infinite.

Thus, your pattern is just not correct, because you lied to yourself
about what you were doing.

Further irrelevant claims without evidence ignored.

Perhaps you have an ACM email address and don't
know very much about programming?

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

XPost: comp.theory, sci.logic

On 7/30/25 7:46 PM, olcott wrote:

On 7/30/2025 6:26 PM, Richard Damon wrote:

On 7/30/25 10:12 AM, olcott wrote:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the >>>>>>>>>>>> simulation
would reach the final halt state in a finite number of >>>>>>>>>>>> steps, as proven
by world-class simulators using exactly the same input. The >>>>>>>>>>>> infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD >>>>>>>>>>> calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD >>>>>>>>>>> DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no >>>>>>>>>> position to
call anybody else here a liar.  Glass house inhabitants,
throwing stones,
and all that.

And you used to distinguish yourself from other cranks by
sticking to
decorous language, and generally being courteous.  Not any >>>>>>>>>> more. That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to your >>>>>>>> lack of
self awareness and lack of technical ability.  Everybody here >>>>>>>> but you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable to
judge
whether such a correct simulation is possible.  Everybody else
sees that
it is not, so further questions about it are non-sensical.

void DDD()
{
   HHH(DDD);
   return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole simulation
correct.

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

But not that *ALL* of it was simulated correctly.

void Infinite_Recursion()
{
  Infinite_Recursion();
  return;
}

void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}

Neither was all of the instructions of the above
simulated correctly. When N instructions are simulated
correctly the repeating pattern emerges.

So?

void DDD()
{
  HHH(DDD);
  return;
}

executed HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)

Nope, the first HHH simulated will abort the simulation before we get
here.>

and then HHH finally aborts its simulation.

Your HHH doesn't wait that long, so you lie.

If you make it do that, then one more cycle of CORRECT simulation would
show that the first simulated HHH will ALSO abort is simulation at the
next cycle and return to DDD which will halt.

Since the Halting Problem is about the DIRECT EXECUTION of the program represented by the input, or equivalently a CORRECT (and complete)
simulation of the input by a machine that DOES a complete simulation, we
see that HHH is just wrong,

And that you just don't know the meaning of your words, because you
chose to not learn them, even when the error has been pointed out,
making you just a pathological liar.

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

XPost: comp.theory, sci.logic

On 7/30/25 9:00 PM, olcott wrote:

On 7/30/2025 7:07 PM, Richard Damon wrote:

On 7/30/25 7:46 PM, olcott wrote:

On 7/30/2025 6:26 PM, Richard Damon wrote:

On 7/30/25 10:12 AM, olcott wrote:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the >>>>>>>>>>>>>> simulation
would reach the final halt state in a finite number of >>>>>>>>>>>>>> steps, as proven
by world-class simulators using exactly the same input. >>>>>>>>>>>>>> The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD >>>>>>>>>>>>> calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because >>>>>>>>>>>>> DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no >>>>>>>>>>>> position to
call anybody else here a liar.  Glass house inhabitants, >>>>>>>>>>>> throwing stones,
and all that.

And you used to distinguish yourself from other cranks by >>>>>>>>>>>> sticking to
decorous language, and generally being courteous.  Not any >>>>>>>>>>>> more. That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to your >>>>>>>>>> lack of
self awareness and lack of technical ability.  Everybody here >>>>>>>>>> but you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable >>>>>>>> to judge
whether such a correct simulation is possible.  Everybody else >>>>>>>> sees that
it is not, so further questions about it are non-sensical.

void DDD()
{
   HHH(DDD);
   return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole simulation
correct.

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

But not that *ALL* of it was simulated correctly.

void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Neither was all of the instructions of the above
simulated correctly. When N instructions are simulated
correctly the repeating pattern emerges.

So?

void DDD()
{
   HHH(DDD);
   return;
}

executed HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)

Nope, the first HHH simulated will abort the simulation before we get
here.

Not at all. My encoded HHH aborts as soon as it
sees the pattern repeat once. It could have been
encoded to wait until it sees this same pattern
repeat ten times. That you keep pretending to never
see the pattern is quite dishonest. This might
cost your own soul. I would never risk this.

Right, so you LIED about what happens.

And the first simulated HHH, when correctly (and thus completely
simulated) WILL abort when I said.

Again, all you are doing is proving your logic is based on LIES

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

XPost: comp.theory, sci.logic

Op 30.jul.2025 om 16:12 schreef olcott:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the
simulation
would reach the final halt state in a finite number of steps, >>>>>>>>>> as proven
by world-class simulators using exactly the same input. The >>>>>>>>>> infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls >>>>>>>>> HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD >>>>>>>>> DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no
position to
call anybody else here a liar.  Glass house inhabitants,
throwing stones,
and all that.

And you used to distinguish yourself from other cranks by
sticking to
decorous language, and generally being courteous.  Not any more. >>>>>>>> That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to your
lack of
self awareness and lack of technical ability.  Everybody here but >>>>>> you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state.

It is a lack of technical ability on your part which is unable to judge >>>> whether such a correct simulation is possible.  Everybody else sees
that
it is not, so further questions about it are non-sensical.

void DDD()
{
   HHH(DDD);
   return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole simulation correct.

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

Nobody denies that, but it does not make te whole simulation correct.>

In contrast, the failure to simulate a single instruction correctly,
makes the whole simulation incorrect.
In this case it is the failure to simulate the call instruction.

My code conclusively proves that HHH does simulate
itself simulating DDD. That you do not understand
this code well enough to understand that is less
than no rebuttal at all.

Incorrect claims, as usual.
I do understand it and in fact better that you do. You do not understand
that the simulation is not correct when the simulation is not completed.
You also do not understand that a finite recursion does not imply
non-halting.

The simulation aborts at this point, where the semantics of the x86
language requires the execution of the next instruction.

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its simulation and returns 0,

Incorrect. It aborts when it sees a finite recursion. The programmer
forgot to cont the conditional branch instruction, so that it
incorrectly reports non-halting.

(b) Its simulated input reaches its simulated "return" statement then it returns 1.

My code conclusively proves that HHH does simulate itself
simulating DDD until any sufficiently competent person can
correctly determine a repeating pattern that cannot possibly
reach its own "return" statement final halt state even with
an infinite simulation.

Incorrect repeated claim, as usual. Any competent person knows that a
finite recursion, or a finite repeating pattern, does not mean
non-termination.
Better simulators also show that after the finite recursion, the final
halt state is reachable.
That HHH is unable to reach the final halt state, therefore, is a
failure of HHH.

That you do not understand this code well enough to
understand that is less than no rebuttal at all.

As usual, incorrect repeated claim, without any evidence.

https://github.com/plolcott/x86utm/blob/master/Halt7.c

The HHH that is called by DDD in the simulation, is the HHH that aborts
and returns. So, the input for the simulation specifies a halting program.
That HHH fails to see the whole specification, does not change the specification.
Your huge mistake is that you think that what HHH does not see, does not
exist.

When it does detect this pattern then it kills the
whole DDD process so that there is no stack unwinding.

But there was no need to do so. Other simulators show that when the
simulation is not killed, the final halt state is reached.

; This premature abort, based on the incorrect assumption that a finite
recursion specifies non-halting, makes the whole simulation incorrect
and, what is worse, the conclusion of non-halting behaviour fails.

HHH uses exactly same process on this function.

void Infinite_Recursion()
{
  Infinite_Recursion();
  return;
}

as it does this function.

Incorrect, it more like:

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
printf ("Olcott thinks this is never printed.\n");
}

Because we know that HHH, also the simulated HHH, is programmed to abort
after a few cycles.

void DDD()
{
  HHH(DDD);
  return;
}

HHH has no idea that DDD is calling itself.

Programs have no ideas. They do what is coded.
When you still want to think about ideas: DDD has no idea that HHH will simulate itself recursively. It expects HHH to return.

HHH just sees that DDD is calling the same function
with the same parameter twice in sequence,

but a good simulator would see that the internal state of HHH has been
changed, which would influence the conditional branch instructions.

just like

Finite_Recursion, not like:

Infinite_Recursion().

Further irrelevant claims without evidence ignored.

Perhaps you have an ACM email address and don't
know very much about programming?

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

XPost: comp.theory, sci.logic

On 7/31/25 12:15 PM, olcott wrote:

On 7/30/2025 9:18 PM, Richard Damon wrote:

On 7/30/25 9:00 PM, olcott wrote:

On 7/30/2025 7:07 PM, Richard Damon wrote:

On 7/30/25 7:46 PM, olcott wrote:

On 7/30/2025 6:26 PM, Richard Damon wrote:

On 7/30/25 10:12 AM, olcott wrote:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote: >>>>>>>>>>>>>>> On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the >>>>>>>>>>>>>>>> simulation
would reach the final halt state in a finite number of >>>>>>>>>>>>>>>> steps, as proven
by world-class simulators using exactly the same input. >>>>>>>>>>>>>>>> The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD >>>>>>>>>>>>>>> calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because >>>>>>>>>>>>>>> DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are >>>>>>>>>>>>>> no position to
call anybody else here a liar.  Glass house inhabitants, >>>>>>>>>>>>>> throwing stones,
and all that.

And you used to distinguish yourself from other cranks by >>>>>>>>>>>>>> sticking to
decorous language, and generally being courteous.  Not any >>>>>>>>>>>>>> more. That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.

Foul mouthed lying on your part.  It can be attributed to >>>>>>>>>>>> your lack of
self awareness and lack of technical ability.  Everybody >>>>>>>>>>>> here but you can
see that.

It is not any lack of technical ability that determines
whether or not DDD correctly simulated by HHH can or
cannot reach its own "return" instruction final halt state. >>>>>>>>>>

It is a lack of technical ability on your part which is unable >>>>>>>>>> to judge
whether such a correct simulation is possible.  Everybody else >>>>>>>>>> sees that
it is not, so further questions about it are non-sensical. >>>>>>>>>>

void DDD()
{
   HHH(DDD);
   return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole simulation >>>>>>>> correct.

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

But not that *ALL* of it was simulated correctly.

void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Neither was all of the instructions of the above
simulated correctly. When N instructions are simulated
correctly the repeating pattern emerges.

So?

void DDD()
{
   HHH(DDD);
   return;
}

executed HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)

Nope, the first HHH simulated will abort the simulation before we
get here.

Not at all. My encoded HHH aborts as soon as it
sees the pattern repeat once. It could have been
encoded to wait until it sees this same pattern
repeat ten times. That you keep pretending to never
see the pattern is quite dishonest. This might
cost your own soul. I would never risk this.

Right, so you LIED about what happens.

I had to emphasize the repeating pattern enough
so that you could see it. When I only show you
a little bit of it you pretend that it does not exist.

In other words, you are just admitting that you think LYING is
appropriate when making an arguement.

My answer still applies. SInce HHH aborts is simulation and returns 0,
the correct simultion of its input will simulate an HHH that also aborts
its simulation and returns to the simulated DDD which will halt. It is
just this occurs after HHH has INCORRECTLY decided that it will never
halt and aborts its simulation.

And the first simulated HHH, when correctly (and thus completely
simulated) WILL abort when I said.

Again, all you are doing is proving your logic is based on LIES

That you call me a liar may by itself condemn you to Hell.

Nope, since it is a true statement, something you don't seem to
understand, which just makes you stupid.

The fact that you keep on repeating the same errors over and over and
never point out an error in what I say, except to repeat you same error
that has been pointed out, shows you have no grounds for you claims.

The form of your argument, where you claim to be able to change
definitions just shows that you don't understand that you don't get to
do that, and thus are just a liar.

You have two choice, work WITH the definitions, as defined in the
system. to be able to make a claim in the system, or

TOTALLY define your new system (something I am not sure you know how to)
and prove that in your system those theorys don't hold. Which does
nothing about the theories in the original syatem. Unless you can
persuade a number of people that you system is some how "better" those
claims won't mean much.

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

XPost: comp.theory, sci.logic

On 7/31/25 7:58 PM, olcott wrote:

On 7/31/2025 6:41 PM, Richard Damon wrote:

On 7/31/25 12:15 PM, olcott wrote:

On 7/30/2025 9:18 PM, Richard Damon wrote:

On 7/30/25 9:00 PM, olcott wrote:

On 7/30/2025 7:07 PM, Richard Damon wrote:

On 7/30/25 7:46 PM, olcott wrote:

On 7/30/2025 6:26 PM, Richard Damon wrote:

On 7/30/25 10:12 AM, olcott wrote:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 07:00 schreef olcott:

On 7/29/2025 11:22 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <[email protected]> wrote:

On 7/29/2025 9:35 PM, Alan Mackenzie wrote:

olcott <[email protected]> wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

In comp.theory olcott <[email protected]> wrote: >>>>>>>>>>>>>>>>> On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence. >>>>>>>>>>>>>>>>>> Your dreams are no verified facts. HHH aborts before >>>>>>>>>>>>>>>>>> the simulation
would reach the final halt state in a finite number of >>>>>>>>>>>>>>>>>> steps, as proven
by world-class simulators using exactly the same >>>>>>>>>>>>>>>>>> input. The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because >>>>>>>>>>>>>>>>> DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD >>>>>>>>>>>>>>>>> because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar. >>>>>>>>>>>>

As has been established elsewhere in this thread, you >>>>>>>>>>>>>>>> are no position to
call anybody else here a liar.  Glass house inhabitants, >>>>>>>>>>>>>>>> throwing stones,
and all that.

And you used to distinguish yourself from other cranks >>>>>>>>>>>>>>>> by sticking to
decorous language, and generally being courteous.  Not >>>>>>>>>>>>>>>> any more. That is
a most unwelcome change.

void DDD()
{
    HHH(DDD);
    return;
}

*That not one single person here*
(besides those that I invited from the C groups) >>>>>>>>>>>>>>> acknowledges that DDD simulated by HHH specifies >>>>>>>>>>>>>>> recursive simulation

cannot be reasonably attributed to anything besides >>>>>>>>>>>>>>> willful deception.

Foul mouthed lying on your part.  It can be attributed to >>>>>>>>>>>>>> your lack of
self awareness and lack of technical ability.  Everybody >>>>>>>>>>>>>> here but you can
see that.

It is not any lack of technical ability that determines >>>>>>>>>>>>> whether or not DDD correctly simulated by HHH can or >>>>>>>>>>>>> cannot reach its own "return" instruction final halt state. >>>>>>>>>>>>

It is a lack of technical ability on your part which is >>>>>>>>>>>> unable to judge
whether such a correct simulation is possible.  Everybody >>>>>>>>>>>> else sees that
it is not, so further questions about it are non-sensical. >>>>>>>>>>>>

void DDD()
{
   HHH(DDD);
   return;
}

_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 have no idea why are are saying the something
that is trivial is impossible.

When HHH emulates: "push ebp" then HHH has correctly
emulated the first instruction of DDD correctly.

Simulating a few instructions does not make the whole
simulation correct.

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

But not that *ALL* of it was simulated correctly.

void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}

void Infinite_Loop()
{
   HERE: goto HERE;
   return;
}

Neither was all of the instructions of the above
simulated correctly. When N instructions are simulated
correctly the repeating pattern emerges.

So?

void DDD()
{
   HHH(DDD);
   return;
}

executed HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)

Nope, the first HHH simulated will abort the simulation before we
get here.

Not at all. My encoded HHH aborts as soon as it
sees the pattern repeat once. It could have been
encoded to wait until it sees this same pattern
repeat ten times. That you keep pretending to never
see the pattern is quite dishonest. This might
cost your own soul. I would never risk this.

Right, so you LIED about what happens.

I had to emphasize the repeating pattern enough
so that you could see it. When I only show you
a little bit of it you pretend that it does not exist.

In other words, you are just admitting that you think LYING is
appropriate when making an arguement.

Of every HHH that can possibly exist one of them does
not stop simulating until after ten recursive simulations.
*That you cannot possibly imagine this DOES NOT MAKE ME A LIAR*

There is only ONE HHH at any instance, and you have defined which one
you are talking about, and your infinite set of HHHs all see different
input.

Every HHH that aborts its simulaiton to return non-halting creates a DDD
that when fully simulated, will hatl, and thus those HHHs are wrobg.

ANy HHH that you might imagine that doesn't abort, does create a
non-halting DDD, diffferent from all of those others, but none of these
HHH report an answer.

Your problem is you insanity make you think that all those different
DDEs are the same, because you don;t understand the requirements on the
system.

If DDD includes the code of HHH, they are all different.

if DDD doesn't include the code of HHH, then HHH can't simulate its
input past the call HHH instruciton without failing to meet the
requirements of a decider, which is only allowed to look at its input,
so looking at other memory makes it part of its input, and thus the
inputs are different.

Sorry, you are just proving you are a liar.

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

XPost: comp.theory, sci.logic

Op 31.jul.2025 om 09:28 schreef olcott:

On 7/31/2025 2:20 AM, Fred. Zwarts wrote:

Op 30.jul.2025 om 16:12 schreef olcott:

On 7/30/2025 4:09 AM, Fred. Zwarts wrote:

Simulating N instructions correctly does mean that
these N instructions were simulated correctly.

Nobody denies that, but it does not make te whole simulation correct.

In contrast, the failure to simulate a single instruction correctly,
makes the whole simulation incorrect.
In this case it is the failure to simulate the call instruction.

My code conclusively proves that HHH does simulate
itself simulating DDD. That you do not understand
this code well enough to understand that is less
than no rebuttal at all.

Incorrect claims, as usual.
I do understand it and in fact better that you do. You do not
understand that the simulation is not correct when the simulation is
not completed.
You also do not understand that a finite recursion does not imply non-
halting.

The simulation aborts at this point, where the semantics of the x86
language requires the execution of the next instruction.

Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) It detects a non-terminating behavior pattern then it aborts its
simulation and returns 0,

Incorrect. It aborts when it sees a finite recursion.

It sees recursive simulation that can never reach the halt state.

Incorrect wording. It sees a finite recursion, but it is unable to
determine that it is a finite recursion because of a programming error.
The reason is:

The programmer forgot to count the conditional branch instruction, so
that it incorrectly reports non-halting.

(b) Its simulated input reaches its simulated "return" statement then
it returns 1.

My code conclusively proves that HHH does simulate itself
simulating DDD until any sufficiently competent person can
correctly determine a repeating pattern that cannot possibly
reach its own "return" statement final halt state even with
an infinite simulation.

Incorrect repeated claim, as usual. Any competent person knows that a
finite recursion, or a finite repeating pattern, does not mean non-
termination.
Better simulators also show that after the finite recursion, the final
halt state is reachable.
That HHH is unable to reach the final halt state, therefore, is a
failure of HHH.

That you do not understand this code well enough to
understand that is less than no rebuttal at all.

As usual, incorrect repeated claim, without any evidence.

https://github.com/plolcott/x86utm/blob/master/Halt7.c

The HHH that is called by DDD in the simulation, is the HHH that
aborts and returns. So, the input for the simulation specifies a
halting program.
That HHH fails to see the whole specification, does not change the
specification.
Your huge mistake is that you think that what HHH does not see, does
not exist.

When it does detect this pattern then it kills the
whole DDD process so that there is no stack unwinding.

But there was no need to do so. Other simulators show that when the
simulation is not killed, the final halt state is reached.

  > This premature abort, based on the incorrect assumption that a
finite

recursion specifies non-halting, makes the whole simulation
incorrect and, what is worse, the conclusion of non-halting
behaviour fails.

HHH uses exactly same process on this function.

void Infinite_Recursion()
{
   Infinite_Recursion();
   return;
}

as it does this function.

Incorrect, it more like:

void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
   printf ("Olcott thinks this is never printed.\n");
}

Because we know that HHH, also the simulated HHH, is programmed to
abort after a few cycles.

void DDD()
{
   HHH(DDD);
   return;
}

HHH has no idea that DDD is calling itself.

Programs have no ideas. They do what is coded.
When you still want to think about ideas: DDD has no idea that HHH
will simulate itself recursively. It expects HHH to return.

HHH just sees that DDD is calling the same function
with the same parameter twice in sequence,

but a good simulator would see that the internal state of HHH has been
changed, which would influence the conditional branch instructions.

just like

Finite_Recursion, not like:

Infinite_Recursion().

Further irrelevant claims without evidence ignored.

Perhaps you have an ACM email address and don't
know very much about programming?

--
Paradoxes in the relation between Creator and creature. <http://www.wirholt.nl/English>.

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