XPost: comp.theory, sci.logic

On 6/21/25 11:38 AM, olcott wrote:

On 6/20/2025 7:13 PM, Richard Damon wrote:

On 6/20/25 1:09 PM, olcott wrote:

On 6/20/2025 10:27 AM, joes wrote:

Am Fri, 20 Jun 2025 09:53:41 -0500 schrieb olcott:

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

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

On 6/19/2025 3:55 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 17:41 schreef olcott:

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

Op 17.jun.2025 om 16:36 schreef olcott:

Indeed, HHH fails to reach the end of the simulation, even though >>>>>>>>>> the end is only one cycle further from the point where it gave up >>>>>>>>>> the simulation.

That is counter-factual and over-your-head.

It was an agreement.

No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort and >>>>>>>> halt,
the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>>>> away from the same point.

Proving that you do not understand what unreachable code is.

Even a beginner understands that when HHH has code to abort and halt, >>>>>> the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>> away from the same point.

Yes this is factual.

Lol, that was the same paragraph.

Every simulated HHH remains one cycle behind its simulator no
matter how
deep the recursive simulations go. This means that the outermost
directly executed HHH reaches its abort criteria first.

Yes, no simulator can proceed past a call to itself.

That is counter-factual and it you knew c well
enough you could verify that is counter-factual.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which shows that HHH never correctly simulates its input, as it always
will abort its simulation, and a partial simulation is never a correct
simulation by the term-of-art definition.

HHH emulates N x86 machine language instructions of
DDD according to the semantics of the x86 language,
thus necessarily emulates these N instructions correctly.
This also requires HHH to emulate itself emulating DDD
at least once.

Which isn't the definition of "Correct Emulation", and thus is just a
lie of equivocation.

Since the last instruction it emuated wasn't a "final state", the act of stoppoing the emulation makes it NOT a "Correct Emulation", just a
PARTIAL EMULATION.

The main computer science definition of halting is
reaching a final halt state, anyone disagreeing is
incorrect. An alternative definition that is easier
for programmers to understand is never stop running.
Any disagreement with these is incorrect.

Right. but youy don't understand the "of what".

It is the PROGRAM (when executed) that reaches the final state.

It

When there are no N instructions of DDD correctly
simulated by HHH that can possibly reach their final
halt state then it is a verified fact that the input to
HHH(DDD) specifies a non-halting sequence of
configurations. The directly executed DDD() is the
caller of HHH(DDD) thus not its input.

No, since every HHH creates a different DDD.

For Every DDD based on ITS HHH, if it returns an answer, there exists a
finite number N instructions that when correctly emulated, that DDD will
halt.

This value N is just bigger then the number n that that HHH emulated
befor aborting,

Sorry, you logic is just based on lies, equivocations, and deceptions.

For your "proof" to be correct, it would be the same as finding a value
of N that was greater than N+10

Note, if you claim that the directly executed DDD is NOT what the input
to HHH of HHH(DDD) is asking about, you are just admitting that your
whole proof is base on a lie, as the semantic meaniing of the proof
program specifies that it asks the decider to decide on the behavior of
the direct execution of itself (based on being given a correct
representation of itself).

If you are now stating that HHH(DDD) doesn't mean that, then you "proof programs equivalents" just are not that, and you are admitting that your
whole work is based on LYING,

You can't claim to follow the rules, and then say that the input you
give doesn't mean what it was required to mean.

Sorry, you are just caught in your own lies.

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

XPost: comp.theory, sci.logic

On 6/21/25 5:28 PM, olcott wrote:

On 6/21/2025 3:54 PM, Richard Damon wrote:

On 6/21/25 11:38 AM, olcott wrote:

On 6/20/2025 7:13 PM, Richard Damon wrote:

On 6/20/25 1:09 PM, olcott wrote:

On 6/20/2025 10:27 AM, joes wrote:

Am Fri, 20 Jun 2025 09:53:41 -0500 schrieb olcott:

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

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

On 6/19/2025 3:55 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 17:41 schreef olcott:

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

Op 17.jun.2025 om 16:36 schreef olcott:

Indeed, HHH fails to reach the end of the simulation, even >>>>>>>>>>>> though
the end is only one cycle further from the point where it >>>>>>>>>>>> gave up
the simulation.

That is counter-factual and over-your-head.

It was an agreement.

No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort >>>>>>>>>> and halt,
the simulated HHH runs one cycle behind the simulating HHH, so >>>>>>>>>> that
when the simulating HHH aborts, the simulated HHH is only one >>>>>>>>>> cycle
away from the same point.

Proving that you do not understand what unreachable code is.

Even a beginner understands that when HHH has code to abort and >>>>>>>> halt,
the simulated HHH runs one cycle behind the simulating HHH, so that >>>>>>>> when the simulating HHH aborts, the simulated HHH is only one cycle >>>>>>>> away from the same point.

Yes this is factual.

Lol, that was the same paragraph.

Every simulated HHH remains one cycle behind its simulator no
matter how
deep the recursive simulations go. This means that the outermost >>>>>>> directly executed HHH reaches its abort criteria first.

Yes, no simulator can proceed past a call to itself.

That is counter-factual and it you knew c well
enough you could verify that is counter-factual.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which shows that HHH never correctly simulates its input, as it
always will abort its simulation, and a partial simulation is never
a correct simulation by the term-of-art definition.

HHH emulates N x86 machine language instructions of
DDD according to the semantics of the x86 language,
thus necessarily emulates these N instructions correctly.
This also requires HHH to emulate itself emulating DDD
at least once.

Which isn't the definition of "Correct Emulation",

*It is the definition of a correct emulation of N instructions*
That you believe that a correct emulation is a complete emulation
of a non terminating input is self-contradictory. Even my close
friend with a 73 IQ knows that contradiction proves falsity.

Which isn't the correct simulation of the input.

Sorry, you are just admitting to using a strawman, and believing your
own lies.

What is contradictory of my definition? it just means that the correct simulation of a non-halting input is also non-halting and doesn't finish
in finite number of steps.

Your definitions says that for ANY input (except maybe one that
immediately stops) there exists a correct simulation of N steps that
shows that it is non-halting.

Your problem is that either you input isn't emualtable past the call instruction as it doesn't contain that data, or every DDD is just a
different input (even though the code for the FUNCTION DDD doesn't
change, the code for the PROGRAM/INPUT DDD does) and thus your "every N" doesn't apply to any one input.

Sorry, you are just proving how much your "logic" is built on lying
about thing, and how little you understand of the actual meaning of the
terms you are using.

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

XPost: comp.theory, sci.logic

On 6/22/25 11:07 AM, olcott wrote:

On 6/22/2025 6:31 AM, Richard Damon wrote:

On 6/21/25 5:28 PM, olcott wrote:

On 6/21/2025 3:54 PM, Richard Damon wrote:

On 6/21/25 11:38 AM, olcott wrote:

On 6/20/2025 7:13 PM, Richard Damon wrote:

On 6/20/25 1:09 PM, olcott wrote:

On 6/20/2025 10:27 AM, joes wrote:

Am Fri, 20 Jun 2025 09:53:41 -0500 schrieb olcott:

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

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

On 6/19/2025 3:55 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 17:41 schreef olcott:

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

Op 17.jun.2025 om 16:36 schreef olcott:

Indeed, HHH fails to reach the end of the simulation, even >>>>>>>>>>>>>> though
the end is only one cycle further from the point where it >>>>>>>>>>>>>> gave up
the simulation.

That is counter-factual and over-your-head.

It was an agreement.

No evidence presented for this claim. Dreaming again?
Even a beginner understands that when HHH has code to abort >>>>>>>>>>>> and halt,
the simulated HHH runs one cycle behind the simulating HHH, >>>>>>>>>>>> so that
when the simulating HHH aborts, the simulated HHH is only >>>>>>>>>>>> one cycle
away from the same point.

Proving that you do not understand what unreachable code is. >>>>>>>>>>

Even a beginner understands that when HHH has code to abort >>>>>>>>>> and halt,
the simulated HHH runs one cycle behind the simulating HHH, so >>>>>>>>>> that
when the simulating HHH aborts, the simulated HHH is only one >>>>>>>>>> cycle
away from the same point.

Yes this is factual.

Lol, that was the same paragraph.

Every simulated HHH remains one cycle behind its simulator no >>>>>>>>> matter how
deep the recursive simulations go. This means that the outermost >>>>>>>>> directly executed HHH reaches its abort criteria first.

Yes, no simulator can proceed past a call to itself.

That is counter-factual and it you knew c well
enough you could verify that is counter-factual.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which shows that HHH never correctly simulates its input, as it
always will abort its simulation, and a partial simulation is
never a correct simulation by the term-of-art definition.

HHH emulates N x86 machine language instructions of
DDD according to the semantics of the x86 language,
thus necessarily emulates these N instructions correctly.
This also requires HHH to emulate itself emulating DDD
at least once.

Which isn't the definition of "Correct Emulation",

*It is the definition of a correct emulation of N instructions*
That you believe that a correct emulation is a complete emulation
of a non terminating input is self-contradictory. Even my close
friend with a 73 IQ knows that contradiction proves falsity.

Which isn't the correct simulation of the input.

A correct simulation of N instructions is
A correct simulation of N instructions
in the same way that 1 == 1.

ChatGPT itself recognizes the repeating pattern
shown in N steps of DD correctly simulated by HHH.

I never have been able to understand how refusing
to acknowledge this was anything other than dishonesty.

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

Anyone that knows what infinite recursion is should
be able to immediately see that DDD correctly simulated
by HHH cannot possibly reach its own "return" statement
final halt state.

But it is *NOT* a correct simulation of ALL, or even an unbounded number
of instrucgtions, and thus does not show non-halting.

Since every HHH sees a DIFFERENT program DDD (or it can't emulate it
past the call instruction) every DDD in your set is only emulated of ONE
finite number of steps.

And, for all of those, there is a larger number M, where if this input (including the HHH that it does include) is given to a correct simulator
that simulated for M steps, it will reach an end.

Your problem is you are trying to get away with an equivical definition
for HHH, which is just a form of lying.

It either does a correct simulation, and thus never answers, or it
answers, having aborted its simulation, and a longer correct simulation
finds that the input is halting.

Thus, you are just shown to be a stupid liar, likely either deliberate
or due to extreme mental deficiency that prevents you from understand
the basic meaning of the terms.

Sorry, you are just admitting to using a strawman, and believing your
own lies.

What is contradictory of my definition? it just means that the correct
simulation of a non-halting input is also non-halting and doesn't
finish in finite number of steps.

Your definitions says that for ANY input (except maybe one that
immediately stops) there exists a correct simulation of N steps that
shows that it is non-halting.

Your problem is that either you input isn't emualtable past the call
instruction as it doesn't contain that data, or every DDD is just a
different input (even though the code for the FUNCTION DDD doesn't
change, the code for the PROGRAM/INPUT DDD does) and thus your "every
N" doesn't apply to any one input.

Sorry, you are just proving how much your "logic" is built on lying
about thing, and how little you understand of the actual meaning of
the terms you are using.

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

XPost: comp.theory, sci.logic

On 6/22/25 5:38 PM, olcott wrote:

On 6/22/2025 4:18 PM, Richard Damon wrote:

On 6/22/25 11:07 AM, olcott wrote:

On 6/22/2025 6:31 AM, Richard Damon wrote:

On 6/21/25 5:28 PM, olcott wrote:

On 6/21/2025 3:54 PM, Richard Damon wrote:

On 6/21/25 11:38 AM, olcott wrote:

On 6/20/2025 7:13 PM, Richard Damon wrote:

On 6/20/25 1:09 PM, olcott wrote:

On 6/20/2025 10:27 AM, joes wrote:

Am Fri, 20 Jun 2025 09:53:41 -0500 schrieb olcott:

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

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

On 6/19/2025 3:55 AM, Fred. Zwarts wrote:

Op 18.jun.2025 om 17:41 schreef olcott:

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

Op 17.jun.2025 om 16:36 schreef olcott:

Indeed, HHH fails to reach the end of the simulation, >>>>>>>>>>>>>>>> even though
the end is only one cycle further from the point where >>>>>>>>>>>>>>>> it gave up
the simulation.

That is counter-factual and over-your-head.

It was an agreement.

No evidence presented for this claim. Dreaming again? >>>>>>>>>>>>>> Even a beginner understands that when HHH has code to >>>>>>>>>>>>>> abort and halt,
the simulated HHH runs one cycle behind the simulating >>>>>>>>>>>>>> HHH, so that
when the simulating HHH aborts, the simulated HHH is only >>>>>>>>>>>>>> one cycle
away from the same point.

Proving that you do not understand what unreachable code is. >>>>>>>>>>>>

Even a beginner understands that when HHH has code to abort >>>>>>>>>>>> and halt,
the simulated HHH runs one cycle behind the simulating HHH, >>>>>>>>>>>> so that
when the simulating HHH aborts, the simulated HHH is only >>>>>>>>>>>> one cycle
away from the same point.

Yes this is factual.

Lol, that was the same paragraph.

Every simulated HHH remains one cycle behind its simulator no >>>>>>>>>>> matter how
deep the recursive simulations go. This means that the outermost >>>>>>>>>>> directly executed HHH reaches its abort criteria first.

Yes, no simulator can proceed past a call to itself.

That is counter-factual and it you knew c well
enough you could verify that is counter-factual.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which shows that HHH never correctly simulates its input, as it >>>>>>>> always will abort its simulation, and a partial simulation is
never a correct simulation by the term-of-art definition.

HHH emulates N x86 machine language instructions of
DDD according to the semantics of the x86 language,
thus necessarily emulates these N instructions correctly.
This also requires HHH to emulate itself emulating DDD
at least once.

Which isn't the definition of "Correct Emulation",

*It is the definition of a correct emulation of N instructions*
That you believe that a correct emulation is a complete emulation
of a non terminating input is self-contradictory. Even my close
friend with a 73 IQ knows that contradiction proves falsity.

Which isn't the correct simulation of the input.

A correct simulation of N instructions is
A correct simulation of N instructions
in the same way that 1 == 1.

ChatGPT itself recognizes the repeating pattern
shown in N steps of DD correctly simulated by HHH.

I never have been able to understand how refusing
to acknowledge this was anything other than dishonesty.

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

Anyone that knows what infinite recursion is should
be able to immediately see that DDD correctly simulated
by HHH cannot possibly reach its own "return" statement
final halt state.

But it is *NOT* a correct simulation of ALL,

Richard is such a liar that he disagrees that when HHH
correctly simulates N instructions of DDD this does not
mean that N instructions of DDD were correctly simulated.

Really, Where did I say that LIAR!

No one here is stupid enough to reject the law of identity: https://en.wikipedia.org/wiki/Law_of_identity
thus Richard must be lying.

So, you think Partial == Complete?

A "Correct Simulation" without a modifier must be completely correct to
the end, which your PARTIAL simulation is not.

As I have said, your logic says that if you get off a 1 mile road after
walking 50 feet, your logic says you can claim the road is without end
since you didn't reach the end of it.

You can then go to a 2 mile road, and walk 100 feet, a 3 mile road and
walk 150 feet, and so on.

None of the roads that you only walked part, did you reach the end, so
all of them must be unending.

You problem is that you "conviently" forget that each DDD Input, either
doesn't contain the HHH that it uses, at which point the simulation of
the input can't be performed past the call instruction, as the input
doesn't have that data, or it contains the code of the HHH that it uses,
and every one is different.,

Your "logic" says that even though they include diffferent HHHs, they
are the same as the "C function" is the same, but you can't simulate
just the C function as the input.

Sorry, you are just proving that you logic is based on stupid deceptions.

It is hard to believe that you really are just that ignorant, as you
should have learned something from all the comments, so it seems you
must have some form of mental pathology that either make you just not understand the nature of truth, or make you unable to learn this material.

It is really starting to sound lie you may have a pathological
personality that it might be worth pointing out the the athorities.

After all, you ARE On record as claiming to be God, and thus not bound
to normal human laws.

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