Op 01.jul.2024 om 17:56 schreef olcott:

On 7/1/2024 10:52 AM, joes wrote:

Am Mon, 01 Jul 2024 09:35:54 -0500 schrieb olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

Unless the outer HHH aborts its simulation after some fixed number of >>>>> correct emulations or none of the HHH ever aborts and HHH never stops >>>>> running.

But that does not make the result of the abort correct.
Not aborting will loop infinitely.

      If simulating halt decider H correctly simulates its input D until
      H correctly determines that its simulated D would never stop
      running unless aborted

If. D does stop running though, because the H that it calls aborts the
recursive emulation in order to be a decider.

*In each of the following cases the abort criteria has been met*

Again a claim without evidence.
If true, the abort criteria are incorrect.
The last one does not need to be aborted, because it returns after N
cycles of simulations, when the simulated HHH aborts and returns.
Only infinite simulations need to be aborted.
Is that too difficult to understand?
Your thinking is running in void circles:
Because HHH aborts you think it is an infinite recursion and because you
think HHH is doing an infinite recursion you think it needs to be aborted.
But that is incorrect. The correct reasoning is:
Because HHH aborts, it is not an infinite recursion and because there is
no infinite recursion no abort is needed.
The simulation of an aborting HHH does not need to be aborted. Only the simulation of a non-aborting HHH needs to be aborted.
This proves that neither an aborting HHH, not a non-aborting HHH is able
to correctly simulate itself. (Although they might simulate each other.)

void Infinite_Loop()
{
  HERE: goto HERE;
}

void Infinite_Recursion()
{
  Infinite_Recursion();
}

void DDD()
{
  HHH(DDD);
}

int main()
{
  HHH(Infinite_Loop);
  HHH(Infinite_Recursion);
  HHH(DDD);
}

void Finite_Recursion (int N) {
if (N != 0) Finite_Recursion (N - 1);
}

This is equivalent to you HHH that simulates N cycles.
No abort needed.

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

Op 01.jul.2024 om 17:15 schreef olcott:

On 7/1/2024 10:02 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:35 schreef olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

No, I mean: why does the inner simulator repeat instead of
aborting,
the same as the outer one does?

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and
detect
a repeating state.

The inner ones always see one less execution trace
than the next outer one, thus could only meet their
abort criteria after they have already been aborted.

Which indicates that they were aborted too soon, showing that the
emulation was incorrect.

Unless the outer HHH aborts its simulation after some
fixed number of correct emulations or none of the HHH
ever aborts and HHH never stops running.

But that does not make the result of the abort correct.

Not aborting will loop infinitely.

     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted

THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT

It is inevitable to abort, but that does not make the simulation
correct, because:

Of every possibility that can possibly be is is absolutely
not inevitable to abort.

DDD correctly emulated by HHH is either aborted at some point
or crashes due to out-of-memory error.

Which shows that both simulations are incorrect. The aborted one and the crashed one.

You just aren't very good at these things are you?

Even here your opinion is incorrect.

It seems that you do not quite understand the theory. When talking about correct simulation, we can ignore memory limits.
That may be too complex for you already.

It is not relevant whether HHH must abort, but it is relevant that HHH
*does* abort and halt.
Therefore, a correct simulation of HHH, should not abort. This proves
that HHH is unable to simulate itself, because it does abort (too soon).

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

On 7/1/24 10:31 AM, olcott wrote:

On 7/1/2024 9:25 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:59 schreef olcott:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle too
early, showing that the emulation is incorrect. If that is over your
head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping >>> [00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

... aborted one cycle too soon. One cycle later HHH would return and
DDD would return.

What you say is counter-factual.

No, your claim is counter-factual based on the idea that fixed things
are not fixed, which is just a LIE.

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

On 7/1/24 9:39 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:57 AM, olcott wrote:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

No, I mean: why does the inner simulator repeat instead of aborting, >>>>>> the same as the outer one does?

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and detect >>>>>> a repeating state.

The inner ones always see one less execution trace
than the next outer one, thus could only meet their
abort criteria after they have already been aborted.

Which indicates that they were aborted too soon, showing that the
emulation was incorrect.

Unless the outer HHH aborts its simulation after some
fixed number of correct emulations or none of the HHH
ever aborts and HHH never stops running.

But the outer HHH DOES abort its simulation, since you have said it
did (and it either does or it doesn't).

That means that the simulation of DDD stops, but not the behavior of
the machine that it is simulating.

x86 code remains a static string and thus not a dynamic process
when it is no longer simulated. If you never heard of those two
terms before then you do not have the equivalent of a BSCS.

Nope. Not when you define that it is by the semantics of the x86
instruction set. At that point, its behavior becomes FULLY DEFINED even
if never run or simulated.

YOU don't seem to understand the basics of programming.

You can show behavior of a program without ever actually simulating it.

In fact, "Termination Anaylsys" is based on that, as without having an
actual input (since it asks about for ALL inputs) there isn't an ability
to actually run or simulate the code, just analyize it for executional invariants and cases to see what it might be able to do.

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

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle too
early, showing that the emulation is incorrect. If that is over your
head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping >>> [00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as the
program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do
that. Everyone with the equivalent of a BSCS would know that
what I said is true.

Why do you say that? That is EXACTLY the definition of Correct
Emulation. You need to EXACTLY EMULATE EACH AND EVERY instrucgtion , in
the order they will be executed when the program is run.

That WILL produce the exact behavior of running the program.

The PARTIAL emulation done by the decider only show SOME of the behavior
that is in the input.

You have been asked, and still fail to point out, which instruction when correctly emulated exactly by the semantics of the x86 language result
in a difference between the correct emulation by HHH and the actual
exectuion of DDD?

The answer, NONE of them. HHH Just need to stop emulating, and not see
the full behavior, or it will form a DIFFERENT input that makes that HHH
not halt.

You don't even seem to understand the determinism of program behavior.

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

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle too >>>>>> early, showing that the emulation is incorrect. If that is over
your head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as the
program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do
that. Everyone with the equivalent of a BSCS would know that
what I said is true.

Why do you say that? That is EXACTLY the definition of Correct Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

void Infinite_Loop()
{
  HERE: goto HERE;
}

void Infinite_Recursion()
{
  Infinite_Recursion();
}

void DDD()
{
  HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns.

The fact that HHH need to abort its emulation to be a decider doesn't
mean it gets to be wrong about the question put to it as a halt decider.

It just shows that Halting is not Computable.

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

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle >>>>>>>> too early, showing that the emulation is incorrect. If that is >>>>>>>> over your head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as the
program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do
that. Everyone with the equivalent of a BSCS would know that
what I said is true.

Why do you say that? That is EXACTLY the definition of Correct
Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

WHAT "Verified facts".

THe fact that DDD will halt since your HHH(DDD) retuns?

Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

Nope, but failure to follow the defined rules gets you kick out of the club.

If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

But THEY Lied, and to could be shown so,

Just like your statements.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns.

That is the same nutty bullshit as Gödel's 1931 incompleteness
theorem. If there are no truth preserving operations in PA to
either G or ~G then G has no truthmaker in PA making G not a
truth-bearer in PA.

But there ARE a set of truth preserving operations in PA to show G, it
is just that it takes an infinite number of them, so they don't
constitute a proof.

Something you don't seem to understand.

We can say that this makes PA incomplete yet PA would be
incomplete in the same way that dogs do not climb trees
or lay eggs.

Nope, it is incomplete, because there is a truth established by an
infinite number of steps, that can not be proven in a finite number of
steps.

that you can't count, doesn't make it false, it makes you stupid.

And by repeating your stupid remarks after being corrected, a LIAR.

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

On 2024-07-02 01:36:51 +0000, olcott said:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle too
early, showing that the emulation is incorrect. If that is over your
head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping >>> [00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as the
program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language.

Whenever you say anything about the x86 semantics you should include a
pointer to the relevant point in Intel's documentation.

--
Mikko

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

On 2024-07-02 03:14:20 +0000, olcott said:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle too >>>>>>>> early, showing that the emulation is incorrect. If that is over your >>>>>>>> head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping >>>>>>> [00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as the
program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do
that. Everyone with the equivalent of a BSCS would know that
what I said is true.

Why do you say that? That is EXACTLY the definition of Correct Emulation. >>>

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

You have never proven that that definition be contradicted by
verified (or claimed or assumed) facts.

--
Mikko

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

Am Mon, 01 Jul 2024 21:34:43 -0500 schrieb olcott:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

A "Correct Emulation" is one that produces the same result as the
program at the input.

Which can only possibly occur be disregarding the semantics of the x86
language. Liars would do that ignoramuses would do that. Everyone with
the equivalent of a BSCS would know that what I said is true.

Therefore, HHH can’t be simulated by itself.

Why do you say that? That is EXACTLY the definition of Correct
Emulation.

Every C programmer that knows what an x86 emulator is knows that when
HHH emulates the machine language of Infinite_Loop, Infinite_Recursion,
and DDD that it must abort these emulations so that itself can terminate normally.

An emulator does not need to abort. In fact, it should emulate infinite
loops faithfully.

SO THESE THREE INPUTS DO NOT FREAKING HALT

Why does the emulator halt then?

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

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

Op 01.jul.2024 om 20:25 schreef olcott:

On 7/1/2024 1:01 PM, Fred. Zwarts wrote:

Op 01.jul.2024 om 17:15 schreef olcott:

On 7/1/2024 10:02 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:35 schreef olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

No, I mean: why does the inner simulator repeat instead of >>>>>>>>>> aborting,
the same as the outer one does?

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and >>>>>>>>>> detect
a repeating state.

The inner ones always see one less execution trace
than the next outer one, thus could only meet their
abort criteria after they have already been aborted.

Which indicates that they were aborted too soon, showing that
the emulation was incorrect.

Unless the outer HHH aborts its simulation after some
fixed number of correct emulations or none of the HHH
ever aborts and HHH never stops running.

But that does not make the result of the abort correct.

Not aborting will loop infinitely.

     If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would never >>>>>      stop running unless aborted

THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT

It is inevitable to abort, but that does not make the simulation
correct, because:

Of every possibility that can possibly be is is absolutely
not inevitable to abort.

DDD correctly emulated by HHH is either aborted at some point
or crashes due to out-of-memory error.

Which shows that both simulations are incorrect. The aborted one and
the crashed one.

You just aren't very good at these things are you?

Even here your opinion is incorrect.

It seems that you do not quite understand the theory. When talking
about correct simulation, we can ignore memory limits.
That may be too complex for you already.

It is not relevant whether HHH must abort, but it is relevant that HHH
*does* abort and halt.

*YOU ARE NOT ALLOWED TO CHANGE THE MEANING OF THESE WORDS*

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Therefore, a correct simulation of HHH, should not abort. This proves
that HHH is unable to simulate itself, because it does abort (too soon).

Another way to distract from the fact that you are proved to be incorrect. Repeating the same irrelevant words does not help.
Since your simulation is incorrect, Sipser's opinion does not apply
here, because that is about a correct simulation.

We are talking about an HHH that *does* abort and therefore cannot
simulate itself up to its simulated return, which makes the simulation incorrect.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

HHH aborts after two cycles, therefore, it is equivalent to
Finite_Recursion (2).
I would not be surprised if you (or your simulator) do not see the
difference between Finite_Recursion and Infinite_Recursion. Since you
seem to think that two equals infinity.

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

Op 01.jul.2024 om 20:29 schreef olcott:

On 7/1/2024 1:14 PM, Fred. Zwarts wrote:

Op 01.jul.2024 om 17:56 schreef olcott:

On 7/1/2024 10:52 AM, joes wrote:

Am Mon, 01 Jul 2024 09:35:54 -0500 schrieb olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

Unless the outer HHH aborts its simulation after some fixed
number of
correct emulations or none of the HHH ever aborts and HHH never
stops
running.

But that does not make the result of the abort correct.
Not aborting will loop infinitely.

      If simulating halt decider H correctly simulates its input D >>>>> until
      H correctly determines that its simulated D would never stop >>>>>       running unless aborted

If. D does stop running though, because the H that it calls aborts the >>>> recursive emulation in order to be a decider.

*In each of the following cases the abort criteria has been met*

Again a claim without evidence.
If true, the abort criteria are incorrect.

The #1 best selling author of theory of computation textbooks is wrong?
The #1 best selling author of theory of computation textbooks is wrong?
The #1 best selling author of theory of computation textbooks is wrong?

No, *you* are wrong because you cite Sipser talking about a correct
simulation, whereas your simulation is incorrect, so his words do not
apply here. This has been pointed out already many times to you. You
seem to be a slow learner.

https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X/

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its input D
    until H correctly determines that its simulated D would never
    stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

So you don't even know what an infinite loop is?

I do, but since you think that two equals infinite, it is clear that you
do not understand it.
HHH simulates only two cycles. Two does not equal infinite.
This has been pointed out to you many times, as well.
You seem to be a slow learner, forgetting many verified facts.

void Finite_Recursion (int N) {
if (N != 0) Finite_Recursion (N - 1);
}

This is equivalent to you HHH that simulates N cycles.
No abort needed.
But you keep saying that it is an infinite loop.

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

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one cycle >>>>>>>>>> too early, showing that the emulation is incorrect. If that is >>>>>>>>>> over your head, try to learn how x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as
the program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do
that. Everyone with the equivalent of a BSCS would know that
what I said is true.

Why do you say that? That is EXACTLY the definition of Correct
Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

WHAT "Verified facts".

THe fact that DDD will halt since your HHH(DDD) retuns?

Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

Nope, but failure to follow the defined rules gets you kick out of the
club.

If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

But THEY Lied, and to could be shown so,

Just like your statements.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns.

That is the same nutty bullshit as Gödel's 1931 incompleteness
theorem. If there are no truth preserving operations in PA to
either G or ~G then G has no truthmaker in PA making G not a
truth-bearer in PA.

But there ARE a set of truth preserving operations in PA to show G, it
is just that it takes an infinite number of them, so they don't
constitute a proof.

Diagonalization conclusively proves otherwise and you know it.
Maybe the issue is that you are fundamentally a liar.

How?

I call your bluff, show your "cards" or FOLD.

(My guess is you will just ignore this as the multitude of claims you
find untenable to continue to talk about because your lie was revealed)

This isn't a problem for "Diagonalization" and it seems you are just
trying to use a fancy word to make a claim.

That just shows you are just being dishonest.

Remember the question you are taking about.

G is the proposition that there does not exist any number g (from the
natural numbers) such that it satisfies the particular primative
recursive relationship that Godel developed in the meta-theory of PA,
based on the enumeration of the primative truth bearers of PA.

That no number g can exist, is testable in countably infinite times,
since by the nature of the PRR each number's failure to meet the
relation ship is decidable in a finite number of steps, so we just need
to test all the natural numbers, which is an infinite, but countable, task.

That no natural number g will satisfy that relationship can be shown in
the meta-theory (but not PA) because we understand from the meta-theory
that any number g that satisfies the relationship is an encoding of the
proof that no number g meets the requreiment, so if a number g existed,
then G is false, but we have a proof that no such number exists.

Thus, we can prove in the meta-theory that no natural number exists, and
that fact is transferable to PA, since it doesn't have any meta-facts in it.

So, TRY to show that we can't test every natural number by
Diagonalization, that just isn't the sort of thing it shows.

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

On 7/2/24 8:39 AM, olcott wrote:

On 7/2/2024 6:30 AM, Richard Damon wrote:

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one >>>>>>>>>>>> cycle too early, showing that the emulation is incorrect. If >>>>>>>>>>>> that is over your head, try to learn how x86 instructions work. >>>>>>>>>>>

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.

CAN'T BE.

A "Correct Emulation" is one that produces the same result as >>>>>>>>>> the program at the input.

Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do >>>>>>>>> that. Everyone with the equivalent of a BSCS would know that >>>>>>>>> what I said is true.

Why do you say that? That is EXACTLY the definition of Correct >>>>>>>> Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

WHAT "Verified facts".

THe fact that DDD will halt since your HHH(DDD) retuns?

Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

Nope, but failure to follow the defined rules gets you kick out of
the club.

If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

But THEY Lied, and to could be shown so,

Just like your statements.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns.

That is the same nutty bullshit as Gödel's 1931 incompleteness
theorem. If there are no truth preserving operations in PA to
either G or ~G then G has no truthmaker in PA making G not a
truth-bearer in PA.

But there ARE a set of truth preserving operations in PA to show G,
it is just that it takes an infinite number of them, so they don't
constitute a proof.

Diagonalization conclusively proves otherwise and you know it.
Maybe the issue is that you are fundamentally a liar.

How?

I call your bluff, show your "cards" or FOLD.

That is not the way it works, you made a false claim and I
call your bluff on this false claim. You must provide a linked
source that agrees.

Of course that is the way it works.

You claim you can show something, and I ask you to show it.

Failure just means you admit to being a liar.

You need to show your proof, that you can form a "Diagonalization" proof
that Godel's sentence is not true.

You need to either present the proof, admit you lied that you had one,
or keep being reminded that you have been a liar and can't provide the
proof you claimed you had.

But there ARE a set of truth preserving operations in PA to show G,
it is just that it takes an infinite number of them, so they don't
constitute a proof.

*This source says nothing like what you claim* https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom

Because they aren't using that terminology. That doesn't make the
statement not true.

Note, they do talk about how the sentence, if it were false, could be
shown false by just showing the number that satisfies it. So, one way to demonstrate that it IS true, is to just test EVERY number (all countable infinite number of them) and show that none make the counter example.

Most papers don't talk like that as we can't actually do it that way,
but it is the simple explanation that should be able to sink into your
head. If you want to show how that DOESN'T provide an infinite chain of
steps to the truth of the statement, go ahead and try.

Your problem is you like to quote from things that you don't understand.

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

On 7/2/24 6:58 PM, olcott wrote:

On 7/2/2024 5:44 PM, Richard Damon wrote:

On 7/2/24 8:39 AM, olcott wrote:

On 7/2/2024 6:30 AM, Richard Damon wrote:

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404           add esp,+04 >>>>>>>>>>>>>>> [00002182] 5d               pop ebp >>>>>>>>>>>>>>> [00002183] c3               ret
Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one >>>>>>>>>>>>>> cycle too early, showing that the emulation is incorrect. >>>>>>>>>>>>>> If that is over your head, try to learn how x86
instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>> [0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted. >>>>>>>>>>>>>

CAN'T BE.

A "Correct Emulation" is one that produces the same result >>>>>>>>>>>> as the program at the input.

Which can only possibly occur be disregarding the semantics >>>>>>>>>>> of the x86 language. Liars would do that ignoramuses would do >>>>>>>>>>> that. Everyone with the equivalent of a BSCS would know that >>>>>>>>>>> what I said is true.

Why do you say that? That is EXACTLY the definition of Correct >>>>>>>>>> Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

WHAT "Verified facts".

THe fact that DDD will halt since your HHH(DDD) retuns?

Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

Nope, but failure to follow the defined rules gets you kick out of >>>>>> the club.

If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

But THEY Lied, and to could be shown so,

Just like your statements.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>> so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns.

That is the same nutty bullshit as Gödel's 1931 incompleteness
theorem. If there are no truth preserving operations in PA to
either G or ~G then G has no truthmaker in PA making G not a
truth-bearer in PA.

But there ARE a set of truth preserving operations in PA to show
G, it is just that it takes an infinite number of them, so they
don't constitute a proof.

Diagonalization conclusively proves otherwise and you know it.
Maybe the issue is that you are fundamentally a liar.

How?

I call your bluff, show your "cards" or FOLD.

That is not the way it works, you made a false claim and I
call your bluff on this false claim. You must provide a linked
source that agrees.

Of course that is the way it works.

You claim you can show something, and I ask you to show it.

Failure just means you admit to being a liar.

You need to show your proof, that you can form a "Diagonalization"
proof that Godel's sentence is not true.

You need to either present the proof, admit you lied that you had one,
or keep being reminded that you have been a liar and can't provide the
proof you claimed you had.

But there ARE a set of truth preserving operations in PA to show G, >>>  >>> it is just that it takes an infinite number of them, so they don't >>>  >>> constitute a proof.

*This source says nothing like what you claim*
https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom

Because they aren't using that terminology. That doesn't make the
statement not true.

Note, they do talk about how the sentence, if it were false, could be
shown false by just showing the number that satisfies it. So, one way
to demonstrate that it IS true, is to just test EVERY number (all
countable infinite number of them) and show that none make the counter
example.

Most papers don't talk like that as we can't actually do it that way,
but it is the simple explanation that should be able to sink into your
head. If you want to show how that DOESN'T provide an infinite chain
of steps to the truth of the statement, go ahead and try.

Your problem is you like to quote from things that you don't understand.

You have no source that validates this
On 7/1/2024 10:21 PM, Richard Damon wrote:

But there ARE a set of truth preserving operations
in PA to show G, it is just that it takes an infinite number
of them, so they don't constitute a proof.

Every source says that G is proved outside of PA
and none says there are any infinite sequence of
steps in PA that derive G.

So, you just don't understand what the proof say then do you.

Since it is proven outside of PA to be true IN PA, then the chain must
exist.

The chain I described DOES exist in PA, and unless you can show which
step of that chain is incorrect, you are just a liar.

So, Where is that Diagonalization proof, or are you just admitting you
lied about having one.

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

On 7/2/24 7:09 PM, olcott wrote:

On 7/2/2024 6:03 PM, Richard Damon wrote:

On 7/2/24 6:58 PM, olcott wrote:

On 7/2/2024 5:44 PM, Richard Damon wrote:

On 7/2/24 8:39 AM, olcott wrote:

On 7/2/2024 6:30 AM, Richard Damon wrote:

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04 >>>>>>>>>>>>>>>>> [00002182] 5d               pop ebp >>>>>>>>>>>>>>>>> [00002183] c3               ret >>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself one >>>>>>>>>>>>>>>> cycle too early, showing that the emulation is >>>>>>>>>>>>>>>> incorrect. If that is over your head, try to learn how >>>>>>>>>>>>>>>> x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD) >>>>>>>>>>>>>>> [0000217f] 83c404           add esp,+04 >>>>>>>>>>>>>>> [00002182] 5d               pop ebp >>>>>>>>>>>>>>> [00002183] c3               ret
Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted. >>>>>>>>>>>>>>>

CAN'T BE.

A "Correct Emulation" is one that produces the same result >>>>>>>>>>>>>> as the program at the input.

Which can only possibly occur be disregarding the semantics >>>>>>>>>>>>> of the x86 language. Liars would do that ignoramuses would do >>>>>>>>>>>>> that. Everyone with the equivalent of a BSCS would know that >>>>>>>>>>>>> what I said is true.

Why do you say that? That is EXACTLY the definition of >>>>>>>>>>>> Correct Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

WHAT "Verified facts".

THe fact that DDD will halt since your HHH(DDD) retuns?

Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

Nope, but failure to follow the defined rules gets you kick out >>>>>>>> of the club.

If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

But THEY Lied, and to could be shown so,

Just like your statements.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>> that when HHH emulates the machine language of Infinite_Loop, >>>>>>>>>>> Infinite_Recursion, and DDD that it must abort these emulations >>>>>>>>>>> so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns. >>>>>>>>>>

That is the same nutty bullshit as Gödel's 1931 incompleteness >>>>>>>>> theorem. If there are no truth preserving operations in PA to >>>>>>>>> either G or ~G then G has no truthmaker in PA making G not a >>>>>>>>> truth-bearer in PA.

But there ARE a set of truth preserving operations in PA to show >>>>>>>> G, it is just that it takes an infinite number of them, so they >>>>>>>> don't constitute a proof.

Diagonalization conclusively proves otherwise and you know it.
Maybe the issue is that you are fundamentally a liar.

How?

I call your bluff, show your "cards" or FOLD.

That is not the way it works, you made a false claim and I
call your bluff on this false claim. You must provide a linked
source that agrees.

Of course that is the way it works.

You claim you can show something, and I ask you to show it.

Failure just means you admit to being a liar.

You need to show your proof, that you can form a "Diagonalization"
proof that Godel's sentence is not true.

You need to either present the proof, admit you lied that you had
one, or keep being reminded that you have been a liar and can't
provide the proof you claimed you had.

But there ARE a set of truth preserving operations in PA to

show G,

it is just that it takes an infinite number of them, so they

don't

constitute a proof.

*This source says nothing like what you claim*
https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom >>>>>

Because they aren't using that terminology. That doesn't make the
statement not true.

Note, they do talk about how the sentence, if it were false, could
be shown false by just showing the number that satisfies it. So, one
way to demonstrate that it IS true, is to just test EVERY number
(all countable infinite number of them) and show that none make the
counter example.

Most papers don't talk like that as we can't actually do it that
way, but it is the simple explanation that should be able to sink
into your head. If you want to show how that DOESN'T provide an
infinite chain of steps to the truth of the statement, go ahead and
try.

Your problem is you like to quote from things that you don't
understand.

You have no source that validates this
On 7/1/2024 10:21 PM, Richard Damon wrote:

But there ARE a set of truth preserving operations
in PA to show G, it is just that it takes an infinite number
of them, so they don't constitute a proof.

Every source says that G is proved outside of PA
and none says there are any infinite sequence of
steps in PA that derive G.

So, you just don't understand what the proof say then do you.

Since it is proven outside of PA to be true IN PA, then the chain must
exist.

No one else shares this correct understanding.
They all go by if it is true anywhere then it
is true everywhere.

No, either you read very poor works, or (more likely) you don't
understand what you are reading.

Note, a lot of these proofs are about a system and a meta-system based
on it, and the meta-system has been carefully constructed so that Truths
in the meta-system, that don't refernce things just in the meta system,
ARE true in the original system.

The chain I described DOES exist in PA, and unless you can show which
step of that chain is incorrect, you are just a liar.

You are asking me to show which the step of the proof
that squares are round is incorrect.

You could say that, and if the proof is wrong, it should be easy to find.

If you can't find an error in any of the steps, then you have no grounds
to say it is incorrect.

So, Where is that Diagonalization proof, or are you just admitting you
lied about having one.

The key issue with all of these diagonalization
proofs is that they prove the self-contradictory
expressions cannot be proven never noticing that
the reason that cannot be proven is that they are
self-contradictory.

So, are you going to show the diagonalization proof you claimed to have?

Or, are you admiting that you just LIED with that claim.

And, it seems, you don't understand what the proof is about.

This is like proving and X cannot do a Y without
knowing that the X is a dog and the Y is give birth
to kittens.

So you are agreeing with the statements that you are trying to prove wrong?

If the statement of the proof were REALLY as self-contradictory as you
claim, you could actually SHOW the contradiction IN THE SYSTEM and not
needing your unusual definitions (that often are themselves
probelmatic).Your problem is you just don't understand what you are
talking about, because you failed to actually spend effort to learn the
basics. Sometimes it seems like your fear the basics, becuase the Truth
might brainwash you (when actually it might help you break out of your
own brainwashing).

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

XPost: sci.logic

On 7/2/24 9:42 PM, olcott wrote:

On 7/2/2024 8:32 PM, Richard Damon wrote:

On 7/2/24 9:28 PM, olcott wrote:

On 7/2/2024 8:07 PM, Richard Damon wrote:

Note, a lot of these proofs are about a system and a meta-system
based on it, and the meta-system has been carefully constructed so
that Truths in the meta-system, that don't refernce things just in
the meta system, ARE true in the original system.

No that is merely a false assumption.
Tarski tries to get away with this exact same thing
and his proof is 100,000-fold easier to understand.

Nope, you just don't understand what Tarski is saying,

https://liarparadox.org/Tarski_247_248.pdf
https://liarparadox.org/Tarski_275_276.pdf

To the best of my current knowledge it can be
accurately summed up as this:

This sentence is not true: "This sentence is not true"

Nope.

The outer sentence in his meta-theory is true because
the inner sentence in his theory is not a truth-bearer.

I have never encountered any logician that pays any heed
what-so-ever to the notion of truth-bearer or truth-maker.

It is as if they take their incorrect foundations of logic
as inherently infallible making no attempt what-so-ever to
double check this false assumption.

The fact that you need to try to "reduce" statements, and get the
meaning wrong, just shows you lack the necessary prerequisites to
understand the logic.

It is as simple as this with Gödelization and diagonalization
if is 100% impossible to see the inference steps thus making
analysis of these steps impossible.

That isn't a PROOF, just an admission of your own stupidity.

And where is that Diagonalization proof that shows Godel wrong, or are
you admitting you are just a LIAR and never had one?

The Tarski proof directly provides the detailed inference steps.
So it is not that I do under understand the Gödel proof it is that
this proof is opaque completely hiding all of the important details.

No, you miss the fact that you are starting in the MIDDLE of an
arguement, and that what you are thinking as a assumption is a proven
statement (which you don't understand)

So, where is that Diagonalization proof you said you had.

I think that Diagonalization is nonsense yet it is the basis that
everyone else uses. No one else finds that there is an infinite
sequence of steps in PA that does not count as a proof because
it is not finite. There simply are no steps in PA so they go to MM.

So, then why did you claim to have a diagonalization proof?

I guess you are just admitting you are nothing but a damned liar.

You are making that very clear, so we should beleive ANYTHING you say.

Until you provide it, or admit you lied about it, I won't help you
with your other misunderstandings.

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

XPost: sci.logic

On 7/2/24 9:28 PM, olcott wrote:

On 7/2/2024 8:07 PM, Richard Damon wrote:

On 7/2/24 7:09 PM, olcott wrote:

On 7/2/2024 6:03 PM, Richard Damon wrote:

On 7/2/24 6:58 PM, olcott wrote:

On 7/2/2024 5:44 PM, Richard Damon wrote:

On 7/2/24 8:39 AM, olcott wrote:

On 7/2/2024 6:30 AM, Richard Damon wrote:

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call >>>>>>>>>>>>>>>>>>> HHH(DDD)
[0000217f] 83c404           add esp,+04 >>>>>>>>>>>>>>>>>>> [00002182] 5d               pop ebp >>>>>>>>>>>>>>>>>>> [00002183] c3               ret >>>>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183]

It cannot possibly return, because HHH aborts itself >>>>>>>>>>>>>>>>>> one cycle too early, showing that the emulation is >>>>>>>>>>>>>>>>>> incorrect. If that is over your head, try to learn how >>>>>>>>>>>>>>>>>> x86 instructions work.

_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD >>>>>>>>>>>>>>>>> [0000217a] e853f4ffff       call 000015d2 ; call HHH(DDD)
[0000217f] 83c404           add esp,+04 >>>>>>>>>>>>>>>>> [00002182] 5d               pop ebp >>>>>>>>>>>>>>>>> [00002183] c3               ret >>>>>>>>>>>>>>>>> Size in bytes:(0018) [00002183]

DDD is correctly emulated by HHH which calls an >>>>>>>>>>>>>>>>> emulated HHH(DDD) to repeat the process until aborted. >>>>>>>>>>>>>>>>>

CAN'T BE.

A "Correct Emulation" is one that produces the same >>>>>>>>>>>>>>>> result as the program at the input.

Which can only possibly occur be disregarding the semantics >>>>>>>>>>>>>>> of the x86 language. Liars would do that ignoramuses >>>>>>>>>>>>>>> would do
that. Everyone with the equivalent of a BSCS would know that >>>>>>>>>>>>>>> what I said is true.

Why do you say that? That is EXACTLY the definition of >>>>>>>>>>>>>> Correct Emulation.

WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

And denying definitions is just lying.

It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

WHAT "Verified facts".

THe fact that DDD will halt since your HHH(DDD) retuns?

Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

Nope, but failure to follow the defined rules gets you kick >>>>>>>>>> out of the club.

If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

But THEY Lied, and to could be shown so,

Just like your statements.

void Infinite_Loop()
{
   HERE: goto HERE;
}

void Infinite_Recursion()
{
   Infinite_Recursion();
}

void DDD()
{
   HHH(DDD);
}

Every C programmer that knows what an x86 emulator is knows >>>>>>>>>>>>> that when HHH emulates the machine language of
Infinite_Loop, Infinite_Recursion, and DDD that it must >>>>>>>>>>>>> abort these emulations
so that itself can terminate normally.

SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT

No, DDD does halt if HHH is a decider and HHH(DDD) returns. >>>>>>>>>>>>

That is the same nutty bullshit as Gödel's 1931 incompleteness >>>>>>>>>>> theorem. If there are no truth preserving operations in PA to >>>>>>>>>>> either G or ~G then G has no truthmaker in PA making G not a >>>>>>>>>>> truth-bearer in PA.

But there ARE a set of truth preserving operations in PA to >>>>>>>>>> show G, it is just that it takes an infinite number of them, >>>>>>>>>> so they don't constitute a proof.

Diagonalization conclusively proves otherwise and you know it. >>>>>>>>> Maybe the issue is that you are fundamentally a liar.

How?

I call your bluff, show your "cards" or FOLD.

That is not the way it works, you made a false claim and I
call your bluff on this false claim. You must provide a linked
source that agrees.

Of course that is the way it works.

You claim you can show something, and I ask you to show it.

Failure just means you admit to being a liar.

You need to show your proof, that you can form a "Diagonalization" >>>>>> proof that Godel's sentence is not true.

You need to either present the proof, admit you lied that you had
one, or keep being reminded that you have been a liar and can't
provide the proof you claimed you had.

But there ARE a set of truth preserving operations in PA to >>>>>>> show G,
it is just that it takes an infinite number of them, so they >>>>>>> don't
constitute a proof.

*This source says nothing like what you claim*
https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom >>>>>>>

Because they aren't using that terminology. That doesn't make the
statement not true.

Note, they do talk about how the sentence, if it were false, could >>>>>> be shown false by just showing the number that satisfies it. So,
one way to demonstrate that it IS true, is to just test EVERY
number (all countable infinite number of them) and show that none
make the counter example.

Most papers don't talk like that as we can't actually do it that
way, but it is the simple explanation that should be able to sink
into your head. If you want to show how that DOESN'T provide an
infinite chain of steps to the truth of the statement, go ahead
and try.

Your problem is you like to quote from things that you don't
understand.

You have no source that validates this
On 7/1/2024 10:21 PM, Richard Damon wrote:

But there ARE a set of truth preserving operations
in PA to show G, it is just that it takes an infinite number
of them, so they don't constitute a proof.

Every source says that G is proved outside of PA
and none says there are any infinite sequence of
steps in PA that derive G.

So, you just don't understand what the proof say then do you.

Since it is proven outside of PA to be true IN PA, then the chain
must exist.

No one else shares this correct understanding.
They all go by if it is true anywhere then it
is true everywhere.

No, either you read very poor works, or (more likely) you don't
understand what you are reading.

Note, a lot of these proofs are about a system and a meta-system based
on it, and the meta-system has been carefully constructed so that
Truths in the meta-system, that don't refernce things just in the meta
system, ARE true in the original system.

No that is merely a false assumption.
Tarski tries to get away with this exact same thing
and his proof is 100,000-fold easier to understand.

Nope, you just don't understand what Tarski is saying,

https://liarparadox.org/Tarski_247_248.pdf https://liarparadox.org/Tarski_275_276.pdf

To the best of my current knowledge it can be
accurately summed up as this:

This sentence is not true: "This sentence is not true"

Nope.

The outer sentence in his meta-theory is true because
the inner sentence in his theory is not a truth-bearer.

I have never encountered any logician that pays any heed
what-so-ever to the notion of truth-bearer or truth-maker.

It is as if they take their incorrect foundations of logic
as inherently infallible making no attempt what-so-ever to
double check this false assumption.

The fact that you need to try to "reduce" statements, and get the
meaning wrong, just shows you lack the necessary prerequisites to
understand the logic.

So, where is that Diagonalization proof you said you had.

Until you provide it, or admit you lied about it, I won't help you with
your other misunderstandings.

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

Am Tue, 02 Jul 2024 17:58:55 -0500 schrieb olcott:

On 7/2/2024 5:44 PM, Richard Damon wrote:

On 7/2/24 8:39 AM, olcott wrote:

On 7/2/2024 6:30 AM, Richard Damon wrote:

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

It cannot possibly return, because HHH aborts itself one >>>>>>>>>>>>>> cycle too early, showing that the emulation is incorrect. >>>>>>>>>>>>>> If that is over your head, try to learn how x86
instructions work.

A "Correct Emulation" is one that produces the same result as >>>>>>>>>>>> the program at the input.

Which can only possibly occur be disregarding the semantics of >>>>>>>>>>> the x86 language. Liars would do that ignoramuses would do >>>>>>>>>>> that. Everyone with the equivalent of a BSCS would know that >>>>>>>>>>> what I said is true.

Why do you say that? That is EXACTLY the definition of Correct >>>>>>>>>> Emulation.

It may seem that way when you don't bother to pay attention that >>>>>>> this definition is contradicted by verified facts.

WHAT "Verified facts".
THe fact that DDD will halt since your HHH(DDD) retuns?

No, DDD does halt if HHH is a decider and HHH(DDD) returns.

That is the same nutty bullshit as Gödel's 1931 incompleteness
theorem. If there are no truth preserving operations in PA to
either G or ~G then G has no truthmaker in PA making G not a
truth-bearer in PA.

Diagonalization conclusively proves otherwise and you know it.
Maybe the issue is that you are fundamentally a liar.

You need to show your proof, that you can form a "Diagonalization"
proof that Godel's sentence is not true.

*This source says nothing like what you claim*
https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom

Because they aren't using that terminology. That doesn't make the
statement not true.

Note, they do talk about how the sentence, if it were false, could be
shown false by just showing the number that satisfies it. So, one way
to demonstrate that it IS true, is to just test EVERY number (all
countable infinite number of them) and show that none make the counter
example.

Most papers don't talk like that as we can't actually do it that way,
but it is the simple explanation that should be able to sink into your
head. If you want to show how that DOESN'T provide an infinite chain of
steps to the truth of the statement, go ahead and try.

Your problem is you like to quote from things that you don't
understand.

You have no source that validates this On 7/1/2024 10:21 PM, Richard
Damon wrote:

But there ARE a set of truth preserving operations in PA to show G,
it is just that it takes an infinite number of them, so they don't constitute a proof.

Every source says that G is proved outside of PA and none says there are
any infinite sequence of steps in PA that derive G.

IIRC you can enumerate the sentences that say „I don’t prove G”, of which there are infinitely many. Together they say there is no proof.

--
Am Fri, 28 Jun 2024 16:52:17 -0500 schrieb olcott:
Objectively I am a genius.

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

On 7/1/24 11:15 AM, olcott wrote:

On 7/1/2024 10:02 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:35 schreef olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

No, I mean: why does the inner simulator repeat instead of
aborting,
the same as the outer one does?

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and
detect
a repeating state.

The inner ones always see one less execution trace
than the next outer one, thus could only meet their
abort criteria after they have already been aborted.

Which indicates that they were aborted too soon, showing that the
emulation was incorrect.

Unless the outer HHH aborts its simulation after some
fixed number of correct emulations or none of the HHH
ever aborts and HHH never stops running.

But that does not make the result of the abort correct.

Not aborting will loop infinitely.

     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted

THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT
THEN H IS NECESSARILY CORRECT TO ABORT

It is inevitable to abort, but that does not make the simulation
correct, because:

Of every possibility that can possibly be is is absolutely
not inevitable to abort.

But only ONE *IS* the HHH that is in Halt7.c

Without that definition, DDD can't exist.

DDD correctly emulated by HHH is either aborted at some point
or crashes due to out-of-memory error.

But for DDD to exist to be correctly simulated, a SPECIFIC HHH needs to
be defined, That is the HHH In Halt7.c per you own stipulation. Since
that aborts, that is what HHH does, or you are just admitting to being a
liar.

Of course, you also contradict yourself, by also saying that DDD isn't a program, because you can't let it include that code of HHH limiting what
HHH can be, in which case NO HHH can correct simulate that which isn't a program.

You just aren't very good at these things are you?

It seems the problem is at Peter's end, as he has broken his system with conttadiction, becuase he has refused to learn the meaning of the words,
lie Program, or correct simulation.

Aborting will abort too soon. Both cases are incorrect.

It doesn't seem like you care about the truth.

There is no passing the guy in front of you if you both
continue to run at the exact same speed, he will always
be ahead of you.

But shooting his tyres is also incorrect.

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

On Sat, 24 May 2025 08:21:53 -0400, Richard Damon wrote:

On 7/1/24 11:15 AM, olcott wrote:

On 7/1/2024 10:02 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:35 schreef olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

No, I mean: why does the inner simulator repeat instead of
aborting,
the same as the outer one does?

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and >>>>>>>>> detect a repeating state.

The inner ones always see one less execution trace than the next >>>>>>>> outer one, thus could only meet their abort criteria after they >>>>>>>> have already been aborted.

Which indicates that they were aborted too soon, showing that the >>>>>>> emulation was incorrect.

Unless the outer HHH aborts its simulation after some fixed number >>>>>> of correct emulations or none of the HHH ever aborts and HHH never >>>>>> stops running.

But that does not make the result of the abort correct.

Not aborting will loop infinitely.

     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would
     never stop running unless aborted

THEN H IS NECESSARILY CORRECT TO ABORT THEN H IS NECESSARILY CORRECT
TO ABORT THEN H IS NECESSARILY CORRECT TO ABORT

It is inevitable to abort, but that does not make the simulation
correct, because:

Of every possibility that can possibly be is is absolutely not
inevitable to abort.

But only ONE *IS* the HHH that is in Halt7.c

Without that definition, DDD can't exist.

DDD correctly emulated by HHH is either aborted at some point or
crashes due to out-of-memory error.

But for DDD to exist to be correctly simulated, a SPECIFIC HHH needs to
be defined, That is the HHH In Halt7.c per you own stipulation. Since
that aborts, that is what HHH does, or you are just admitting to being a liar.

Of course, you also contradict yourself, by also saying that DDD isn't a program, because you can't let it include that code of HHH limiting what
HHH can be, in which case NO HHH can correct simulate that which isn't a program.

You just aren't very good at these things are you?

It seems the problem is at Peter's end, as he has broken his system with conttadiction, becuase he has refused to learn the meaning of the words,
lie Program, or correct simulation.

Aborting will abort too soon. Both cases are incorrect.

It doesn't seem like you care about the truth.

There is no passing the guy in front of you if you both continue to >>>>>> run at the exact same speed, he will always be ahead of you.

But shooting his tyres is also incorrect.

Why are you replying to a post from January 2024? You have lost the plot,
mate -- get a proper fucking hobby already.

/Flibble

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

On 5/24/25 9:31 AM, Mr Flibble wrote:

On Sat, 24 May 2025 08:21:53 -0400, Richard Damon wrote:

On 7/1/24 11:15 AM, olcott wrote:

On 7/1/2024 10:02 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 16:35 schreef olcott:

On 7/1/2024 9:27 AM, Fred. Zwarts wrote:

Op 01.jul.2024 om 14:57 schreef olcott:

On 7/1/2024 3:27 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:25 schreef olcott:

On 6/30/2024 3:42 AM, joes wrote:

No, I mean: why does the inner simulator repeat instead of >>>>>>>>>> aborting,
the same as the outer one does?

Technically it is called detecting a repeating state.

Yeah, I know. My point is: all recursive calls both enter and >>>>>>>>>> detect a repeating state.

The inner ones always see one less execution trace than the next >>>>>>>>> outer one, thus could only meet their abort criteria after they >>>>>>>>> have already been aborted.

Which indicates that they were aborted too soon, showing that the >>>>>>>> emulation was incorrect.

Unless the outer HHH aborts its simulation after some fixed number >>>>>>> of correct emulations or none of the HHH ever aborts and HHH never >>>>>>> stops running.

But that does not make the result of the abort correct.

Not aborting will loop infinitely.

     If simulating halt decider H correctly simulates its input D >>>>>      until H correctly determines that its simulated D would
     never stop running unless aborted

THEN H IS NECESSARILY CORRECT TO ABORT THEN H IS NECESSARILY CORRECT >>>>> TO ABORT THEN H IS NECESSARILY CORRECT TO ABORT

It is inevitable to abort, but that does not make the simulation
correct, because:

Of every possibility that can possibly be is is absolutely not
inevitable to abort.

But only ONE *IS* the HHH that is in Halt7.c

Without that definition, DDD can't exist.

DDD correctly emulated by HHH is either aborted at some point or
crashes due to out-of-memory error.

But for DDD to exist to be correctly simulated, a SPECIFIC HHH needs to
be defined, That is the HHH In Halt7.c per you own stipulation. Since
that aborts, that is what HHH does, or you are just admitting to being a
liar.

Of course, you also contradict yourself, by also saying that DDD isn't a
program, because you can't let it include that code of HHH limiting what
HHH can be, in which case NO HHH can correct simulate that which isn't a
program.

You just aren't very good at these things are you?

It seems the problem is at Peter's end, as he has broken his system with
conttadiction, becuase he has refused to learn the meaning of the words,
lie Program, or correct simulation.

Aborting will abort too soon. Both cases are incorrect.

It doesn't seem like you care about the truth.

There is no passing the guy in front of you if you both continue to >>>>>>> run at the exact same speed, he will always be ahead of you.

But shooting his tyres is also incorrect.

Why are you replying to a post from January 2024? You have lost the plot, mate -- get a proper fucking hobby already.

/Flibble

Because it got fresh on my feed. Likely because of some server glitch.

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