XPost: comp.theory, sci.logic

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus there
is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

Partial simulation NEVER "define" an input to be non-halting, and the
only way for it to give the answer that you claim means that since it
*DOES* abort, the "hypothetical" HHH that you are thinking of that
doesn't, isn't actually the HHH that is here, and the input that it
would look at is different, so irrelevent,.

The same thing applies to these two, yet they may be
too difficult for a first year CS student.

int Sipser_D()
{
  if (HHH(Sipser_D) == 1)
    return 0;
  return 1;
}

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

And the same comment applies here.

Since you are admitting that you HHH returns 0 in all these cases, *ALL*
of these input are halting (and Sipser_D returns 1) so your HHH is just incorrect in every case.

All you are doing is proving that you are nothing but a stupid liar.

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

XPost: comp.theory, sci.logic

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus there
is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?

We agree that the non-existing hypothetical HHH seen only in your dreams
that does not abort will never stop running.
But simulation of the actual HHH specified in the input for the
simulator, that has code to abort and halt does not need to be aborted.

Sum(2,3) should calculate the sum of its input 2 and 3, not of the
non-existing hypothetical inputs 7 and 9.

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

XPost: comp.theory, sci.logic

On 6/17/25 9:54 PM, olcott wrote:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus there
is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

*none of them ever stop running unless aborted*
*none of them ever stop running unless aborted*
*none of them ever stop running unless aborted*

Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?

How about the fact that if they abort, they never did a correct
simulation, and every HHH gets a diffent PROGRAM DDD, so "none of them"
is a meaningless term for any of them.

You are just showing that you don't undertstand what you are talking
about becuase you made yourself stupid.

Your argument begins with the equivalent of saying if 1 is equal to 2,
then ...

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

XPost: comp.theory, sci.logic

On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:

On 6/18/2025 6:01 AM, Richard Damon wrote:

On 6/17/25 9:54 PM, olcott wrote:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself simulating DDD
then any first year CS student knows that when each of the above are >>>>> correctly simulated by HHH that none of them ever stop running
unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

*none of them ever stop running unless aborted* *none of them ever
stop running unless aborted* *none of them ever stop running unless
aborted*

Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?

How about the fact that if they abort, they never did a correct
simulation,

*You are not addressing THE EXACT POINT*

*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.

You need to be clear that you are not making a claim about general undecidability but a claim about the SPECIFIC CASE of pathological self reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.

/Flibble

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

XPost: comp.theory, sci.logic

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give different DDD
so you can't compare their behavior.

The HHH that aborts, doesn't actually have proof that its input doesn't
halt, and it has been shown that it does.

The HHH that doesn't abort, never answers.

So both of them are just wrong.

Also, youj *HAVE* defined what HHH *IS* as you claim Halt7.c is part of
the memory, and that DEFINES what HHH MUST BE.


Your logic is just like saying a one mile road is infinite in length,
just because you turned off it after walking on it 100 feet and then
getting off it.

Sorry, but you are just showing that you are a stupid liar.

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

XPost: comp.theory, sci.logic

On 6/18/25 12:01 PM, olcott wrote:

On 6/18/2025 10:50 AM, joes wrote:

Am Wed, 18 Jun 2025 09:50:18 -0500 schrieb olcott:

On 6/18/2025 9:05 AM, joes wrote:

Am Wed, 18 Jun 2025 08:46:16 -0500 schrieb olcott:

*It is not given that any of them abort*

Huh? They contain the code to abort, even if it is not simulated.

*none of them ever stop running unless aborted* yes or no?

If HHH(DDD), where DDD() only calls HHH(DDD), is simulated by a pure
simulator such as HHH1 (not by itself, which aborts), it stops running
by aborting (the simulator also terminates). All inner invocations of
HHH would have stopped running had the outermost one (which is still
only simulated by the real HHH1) not stopped simulating.
HHH1 simulating HHH1 of course doesn't stop running, but we don't have
HHH1 involved in either role here. (For completeness, HHH1(HHH) and
HHH(HHH1) also halt.)

*That is a great answer to the wrong question*
*Here is the original question again*

No. the REAL original question is:

Does the machine described by the input halt when run?


Your STRAWMAN just shows your brain is made of straw.

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

Can any of the above functions correctly simulated
by HHH ever stop running without ever being aborted?

Since HHH never correctly simulated DDD, your statement is just in error.

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

XPost: comp.theory, sci.logic

On 6/18/25 9:53 AM, olcott wrote:

On 6/18/2025 6:01 AM, Richard Damon wrote:

On 6/17/25 9:54 PM, olcott wrote:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

*none of them ever stop running unless aborted*
*none of them ever stop running unless aborted*
*none of them ever stop running unless aborted*

Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?

How about the fact that if they abort, they never did a correct
simulation,

*You are not addressing THE EXACT POINT*

*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.

Which is a DIFFERENT DDD, so just a strawman.

I guess you think that no man went to the moon, because John Glenn
didn't get to it.

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

XPost: comp.theory, sci.logic

On 6/18/25 3:09 PM, olcott wrote:

On 6/18/2025 1:28 PM, Mr Flibble wrote:

On Wed, 18 Jun 2025 08:53:07 -0500, olcott wrote:

On 6/18/2025 6:01 AM, Richard Damon wrote:

On 6/17/25 9:54 PM, olcott wrote:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself simulating DDD >>>>>>> then any first year CS student knows that when each of the above are >>>>>>> correctly simulated by HHH that none of them ever stop running
unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you >>>>>> claim, you are just lying that it did a correct simulation (which in >>>>>> this context means complete)

*none of them ever stop running unless aborted* *none of them ever
stop running unless aborted* *none of them ever stop running unless
aborted*

Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?
Do you agree or can you refute THIS EXACT POINT?

How about the fact that if they abort, they never did a correct
simulation,

*You are not addressing THE EXACT POINT*

*When HHH never aborts any of the above functions then*
(a) None of the functions ever stops running.
(b) Each of the above functions stops running anyway.

You need to be clear that you are not making a claim about general
undecidability but a claim about the SPECIFIC CASE of pathological self
reference present in the classic Halting Problem definition .. the trolls
here (especially Damon and Mikko) like to ignore that you are doing that.

/Flibble

Yes that is what I am doing here.
If my reviewers would not dishonestly change the
subject as the basis of their rebuttal they would
know that I am correct.

But your "LOGIC" is based on the LIE that you are actually working with PROGRAMS, as required by the proof.

Once you force HHH to be a defined program, ALL your logic falls apart,
as it becomes clear that your "DDD" isn't just one input. but an
different input for each HHH, and thus your non HHH can simulate to the
end is just an unsound arguement. Its invalid anyway, but you can make
it not so clear with your obfuscation.

Sorry, you are just proving your stupidity

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

XPost: comp.theory, sci.logic

Op 19.jun.2025 om 04:11 schreef olcott:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that
you claim, you are just lying that it did a correct simulation
(which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give different
DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.

A vacuous statement because no such termination analyser exist.
The candidate you present does abort, so it does not need to be aborted
when simulated.

*No one has ever been able to refute this*

No need to refute a vacuous statement.
This has been presented to you many times, but you close your eyes and
pretend that it did not happen. Very childish.

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

XPost: comp.theory, sci.logic

Op 18.jun.2025 om 15:46 schreef olcott:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that you
claim, you are just lying that it did a correct simulation (which in
this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

At least it is true for all aborting ones, such as the one you presented
in Halt7.c.

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

XPost: comp.theory, sci.logic

On 6/19/25 11:13 AM, olcott wrote:

On 6/19/2025 4:13 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 04:11 schreef olcott:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus >>>>>>>> there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that >>>>>>>> you claim, you are just lying that it did a correct simulation >>>>>>>> (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give different
DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.

A vacuous statement because no such termination analyser exist.

The above set of every termination analyzer HHH includes
those that get the wrong answer and those that never stop
running.

The candidate you present

*Is each element of this infinite set*

Processos only one element of the infinte set of inputs.

My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?

But since no input is both "Correctly Simulated" and "Decided" by the
ONE HHH that processed it, you claim is just a lie.

You just ignore that DDD includes in its definition, the HHH that it calls.

That or you are admitting that you are working in some undefined logic
system that has no connection to the computation theory you claim to be
talking about. But since you have shown you don't understand that
theory, this is at least partially the case too.

Sorry, you are just proving that you are just a stupid liar that doesn't
know what he is talking about, and LIES about being an "expert".

Sorry, these are the facts just proven by your own words.

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

XPost: comp.theory, sci.logic

On 6/18/25 10:11 PM, olcott wrote:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that
you claim, you are just lying that it did a correct simulation
(which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give different
DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.
*No one has ever been able to refute this*

But the only HHH that DOES simulate any part of THIS DDD, is THIS HHH,
and if it aborts to answer, it doesn't correctly simulate this input, so
you LIE that it does.

If this HHH DOES correct simulate this DDD, then it can't abort, and
thus doesn't give the answer.

The problem is you logic just LIES about what HHH and DDD are, because
they CAN NOT be the programs of the proof and do what you claim, as you
claim can only work if they are not programs,

Thus, all you are doing is proving that you are just a liar, and just
don't know what you are talking about.

So, WHICH lie are you going to admit to, our, are you just admitting
that you logic is based on lying?

Sorry, those are the only options you have.

SInce only ONE HHH simulates the DDD that THIS HHH is simulating (since
you have admitted that the code for this HHH is in the memory that this
HHH is seeing when it simulates this DDD, and thus that is part of the
input).

Either this HHH:

1) Correctly Simulates the input as you claim asserts, at which point it
CAN'T abort or you are admitting to ly9ing about it "correctly
simulating" the input. And thus it just never returns an answer, or

2) IT does abort its simulation, and thus you LIE that some HHH
correctly simulated it, since it doesn't, and no other HHH simulates
this exact input, or

3) you are just admitting that yoru logic system thinks that DIFFERENT
programs are the same, and thus based on LYING.

So, which lie are you admitting to, or by your silence admit that you do
all of them (since you keep on changing your story, a common trait of
liars).

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

XPost: comp.theory, sci.logic

Op 19.jun.2025 om 17:17 schreef olcott:

On 6/19/2025 4:21 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 15:46 schreef olcott:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus
there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that
you claim, you are just lying that it did a correct simulation
(which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

At least it is true for all aborting ones, such as the one you
presented in Halt7.c.

My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?

Yes, I confirmed many times that we can confirm this vacuous claim,
because no such HHH exists. All of them fail to do a correct simulation
up to the point where they can see whether the input specifies a halting program.

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

XPost: comp.theory, sci.logic

Op 20.jun.2025 om 02:13 schreef olcott:

On 6/19/2025 6:40 PM, Richard Damon wrote:

On 6/18/25 10:11 PM, olcott wrote:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus >>>>>>>> there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that >>>>>>>> you claim, you are just lying that it did a correct simulation >>>>>>>> (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give different
DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.
*No one has ever been able to refute this*

But the only HHH that DOES simulate any part of THIS DDD, is THIS HHH,
and if it aborts to answer, it doesn't correctly simulate this input,
so you LIE that it does.

The only rebuttal to my actual point would be to
show how DDD simulated by any simulating termination
analyzer HHH would stop running if never aborted.
*Everything else is a dishonest*

Wrong. There is another rebuttal.
It has been proven by world-class simulators that a correct simulation
of exactly the same input reaches a natural end without an abort.
It has been proven also that no correct simulation of HHH by itself
exists. Therefore, asking to correct an incorrect HHH is like asking to
draw a square circle.
It is dishonest to ask for the impossible, in particular when this has
been pointed out to you many times.
Not knowing something does not make your stupid. he resistance against
learning from your errors, however, does.

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

XPost: comp.theory, sci.logic

Op 19.jun.2025 om 17:13 schreef olcott:

On 6/19/2025 4:13 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 04:11 schreef olcott:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus >>>>>>>> there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that >>>>>>>> you claim, you are just lying that it did a correct simulation >>>>>>>> (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give different
DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.

A vacuous statement because no such termination analyser exist.

The above set of every termination analyzer HHH includes
those that get the wrong answer and those that never stop
running.

That is not the meaning of the words 'correctly simulated'.
None of them does a correct simulation.

The candidate you present

*Is each element of this infinite set*
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?

The words 'correctly simulated' makes this a vacuous statement. There is
no HHH that can correctly simulate itself.
It makes no sense to affirm or refute a vacuous statement.
This has been pointed out to you many times.
Not understanding something does not make you stupid. The resistance
against learning from errors, however, does.

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

XPost: comp.theory, sci.logic

On 6/20/25 10:42 AM, olcott wrote:

On 6/20/2025 4:35 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 17:13 schreef olcott:

On 6/19/2025 4:13 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 04:11 schreef olcott:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted. >>>>>>>>>>

WHich means that the code for HHH is part of the input, and >>>>>>>>>> thus there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer >>>>>>>>>> that you claim, you are just lying that it did a correct
simulation (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort. >>>>>>>>

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give
different DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.

A vacuous statement because no such termination analyser exist.

The above set of every termination analyzer HHH includes
those that get the wrong answer and those that never stop
running.

That is not the meaning of the words 'correctly simulated'.
None of them does a correct simulation.

Every instruction of DDD emulated by HHH is emulated correctly.

Nope, not the last one, Since the last part of EVERY instruction (other
than Halt) is to then run/simulate the next one.

Sorry, ERROR is error even if you don't want it to be,

HHH only PARTIALLY simulates, which is NOT "correct"

You need to remember to tell the WHOLE truth, not just the LIE of a
partial truth.

(That is a favorite method of your spiritual father).

The candidate you present

*Is each element of this infinite set*
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?

The words 'correctly simulated' makes this a vacuous statement. There
is no HHH that can correctly simulate itself.

You say this only because you lack the technical competence
to verify that HHH does correctly emulate itself emulating DDD. https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which just proves that HHH FAILS to do a correct simulation, since it
*DOES* abort its simulation, proving that it only does a PARTIAL
simulation, which is not a "Correct Simulation" by the term-of-art
meaning of the words, and trying to use any other meaning just becomes a
LIE.

It makes no sense to affirm or refute a vacuous statement.
This has been pointed out to you many times.
Not understanding something does not make you stupid. The resistance
against learning from errors, however, does.

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

XPost: comp.theory, sci.logic

On 6/20/25 9:59 AM, olcott wrote:

On 6/20/2025 4:20 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 17:17 schreef olcott:

On 6/19/2025 4:21 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 15:46 schreef olcott:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted.

WHich means that the code for HHH is part of the input, and thus >>>>>>>> there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer that >>>>>>>> you claim, you are just lying that it did a correct simulation >>>>>>>> (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort.

*It is not given that any of them abort*

At least it is true for all aborting ones, such as the one you
presented in Halt7.c.

My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?

Yes, I confirmed many times that we can confirm this vacuous claim,
because no such HHH exists. All of them fail to do a correct
simulation up to the point where they can see whether the input
specifies a halting program.

if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
(a) DDD simulated by HHH never stops running.
(b) Directly executed HHH() never stops running.
(c) Directly executed DDD() never stops running.

And thus that HHH isn't a correct Halt decider.

Since DDD changes ad becomes a different program if you change the HHH
that it calls, those results can't be used with a different HHH that aborts.

That is just unsound logic, as most of your logic is.

That is how you build your lies.

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

XPost: comp.theory, sci.logic

On 6/20/25 10:08 AM, olcott wrote:

On 6/20/2025 4:29 AM, Fred. Zwarts wrote:

Op 20.jun.2025 om 02:13 schreef olcott:

On 6/19/2025 6:40 PM, Richard Damon wrote:

On 6/18/25 10:11 PM, olcott wrote:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted. >>>>>>>>>>

WHich means that the code for HHH is part of the input, and >>>>>>>>>> thus there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer >>>>>>>>>> that you claim, you are just lying that it did a correct
simulation (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort. >>>>>>>>

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give
different DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.
*No one has ever been able to refute this*

But the only HHH that DOES simulate any part of THIS DDD, is THIS
HHH, and if it aborts to answer, it doesn't correctly simulate this
input, so you LIE that it does.

The only rebuttal to my actual point would be to
show how DDD simulated by any simulating termination
analyzer HHH would stop running if never aborted.
*Everything else is a dishonest*

Wrong. There is another rebuttal.
It has been proven by world-class simulators that a correct simulation
of exactly the same input reaches a natural end without an abort.

Counter-factual

if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
(a) DDD simulated by HHH never stops running.
(b) Directly executed HHH() never stops running.
(c) Directly executed DDD() never stops running.
(d) DDD correctly simulated by HHH1 never stops running.

And thus, if HHH correctly simulates its input. it never answers.

Thus, the HHH that you claim to be answering correctly, and that the
input will be calling, doesn't behave that way.

You don't seem to understand that you get DIFFERENT input DDD when you
change HHH, as you are trying to pull a fast one with using inconsistant definitions (which is just one of the forms of lying).

It has been proven also that no correct simulation of HHH by itself
exists.

*Every instruction that HHH emulates is emulated correctly*

Nope, not the last, since it aborted.

You like that LIE, just like your spiritual daddy.

Therefore, asking to correct an incorrect HHH is like asking to draw a
square circle.
It is dishonest to ask for the impossible, in particular when this has
been pointed out to you many times.
Not knowing something does not make your stupid. he resistance against
learning from your errors, however, does.

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

XPost: comp.theory, sci.logic

Op 20.jun.2025 om 16:08 schreef olcott:

On 6/20/2025 4:29 AM, Fred. Zwarts wrote:

Op 20.jun.2025 om 02:13 schreef olcott:

On 6/19/2025 6:40 PM, Richard Damon wrote:

On 6/18/25 10:11 PM, olcott wrote:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted. >>>>>>>>>>

WHich means that the code for HHH is part of the input, and >>>>>>>>>> thus there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer >>>>>>>>>> that you claim, you are just lying that it did a correct
simulation (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort. >>>>>>>>

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give
different DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.
*No one has ever been able to refute this*

But the only HHH that DOES simulate any part of THIS DDD, is THIS
HHH, and if it aborts to answer, it doesn't correctly simulate this
input, so you LIE that it does.

The only rebuttal to my actual point would be to
show how DDD simulated by any simulating termination
analyzer HHH would stop running if never aborted.
*Everything else is a dishonest*

Wrong. There is another rebuttal.
It has been proven by world-class simulators that a correct simulation
of exactly the same input reaches a natural end without an abort.

Counter-factual

Again changing the meaning of words. This time of 'counter-factual'.

if DDD correctly simulated by any simulating termination
analyzer HHH never aborts its simulation of DDD then
(a) DDD simulated by HHH never stops running.
(b) Directly executed HHH() never stops running.
(c) Directly executed DDD() never stops running.
(d) DDD correctly simulated by HHH1 never stops running.

That are not the facts, but your dreams. The non-aborting HHH is a
hypothetical HHH that does not exists. If it would exists, it would
never report.
The HHH that does report, aborts and halts and its fails with an
incorrect report. The DDD that calls this HHH will also halt when HHH
returns.
Those are the facts.

It has been proven also that no correct simulation of HHH by itself
exists.

*Every instruction that HHH emulates is emulated correctly*

Except the last one, because the semantics of the x86 language does not
allow to halt at that point.
Closing your eyes for the behaviour of the instructions following the
last one simulating, does not mean that such behaviour does not exists.
It is childish to close your eyes and pretend that thing you do not see
do not exist.

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

XPost: comp.theory, sci.logic

Op 20.jun.2025 om 16:42 schreef olcott:

On 6/20/2025 4:35 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 17:13 schreef olcott:

On 6/19/2025 4:13 AM, Fred. Zwarts wrote:

Op 19.jun.2025 om 04:11 schreef olcott:

On 6/18/2025 8:20 PM, Richard Damon wrote:

On 6/18/25 9:46 AM, olcott wrote:

On 6/18/2025 5:12 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 03:54 schreef olcott:

On 6/17/2025 8:19 PM, Richard Damon wrote:

On 6/17/25 4:34 PM, olcott wrote:

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

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

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

When it is understood that HHH does simulate itself
simulating DDD then any first year CS student knows
that when each of the above are correctly simulated
by HHH that none of them ever stop running unless aborted. >>>>>>>>>>

WHich means that the code for HHH is part of the input, and >>>>>>>>>> thus there is just ONE HHH in existance at this time.

Since that code aborts its simulation to return the answer >>>>>>>>>> that you claim, you are just lying that it did a correct
simulation (which in this context means complete)

*none of them ever stop running unless aborted*

All of them do abort and their simulation does not need an abort. >>>>>>>>

*It is not given that any of them abort*

But it either does or it doesn't, and different HHHs give
different DDD so you can't compare their behavior.

My claim is that DDD correctly simulated by any
termination analyzer HHH that can possibly exist
will never stop running unless aborted.

A vacuous statement because no such termination analyser exist.

The above set of every termination analyzer HHH includes
those that get the wrong answer and those that never stop
running.

That is not the meaning of the words 'correctly simulated'.
None of them does a correct simulation.

Every instruction of DDD emulated by HHH is emulated correctly.

A simulator that simulates only one instruction also correctly simulates
every instruction simulated. That does not mean that it is a correct simulation of the input.
Is even that too difficult for you?

The candidate you present

*Is each element of this infinite set*
My claim is that each of the above functions correctly
simulated by any termination analyzer HHH that can possibly
exist will never stop running unless aborted by HHH.
Can you affirm or correctly refute this?

The words 'correctly simulated' makes this a vacuous statement. There
is no HHH that can correctly simulate itself.

You say this only because you lack the technical competence
to verify that HHH does correctly emulate itself emulating DDD. https://github.com/plolcott/x86utm/blob/master/Halt7.c

Again a claim without evidence.

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