XPost: sci.logic

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not give the
Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it?

You keep trying to get away with saying that the simulation is
incorrect when the semantics of the x86 language conclusively
proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues to the
final end. An aborts emulation only provide PARTIAL information and not
about anything after the point the emulation was stop.

Please show a reference that indicates that a normal x86 instrucitons
will just stop running on its own.

You are just repeating a lie like you "Diagonalaization" lie. You think something must be true, but don't actually understand it.

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

And we will presume that the code for HHH and everything it calls is
included by reference, or your question is just invalid as HHH can not
possible corrrectly emulate that which is not given.

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

At no point in this emulation does the call from DDD correctly
emulated by HHH to HHH(DDD) ever return.

So, DDD will not be EMULATED BY HHH to the return, but that doesn't say
that DDD will not return, or even that a complete emulation of the input
will not return.

Since "The Emulation by HHH" requires information not in the input, that
means that it can not be the "behavior of the input" any more than the
question "What is two plus?" a valid addition question.

YOU keep on trying to pass off your illogic as having meaning, but all
it shows is your stupidity.

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

XPost: sci.logic

On 7/2/24 11:07 PM, olcott wrote:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not give
the Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it?

You keep trying to get away with saying that the simulation is
incorrect when the semantics of the x86 language conclusively
proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues to the
final end.

void Infinite_Loop()
{
  HERE: goto HERE;
}

Why do you say such ridiculously stupid things that you are are false?

And the only CORRECT EMULATION of that program is to infiniately loop in
the emulation.

Nothing says that you can't make a halt decider work with partial
emulation for SOME inputs. But the halt Decider just isn't itself a
fully correct emulator.

You don't seem to understand the difference between EMULATING something,
and deciding on its behavior.

I can add 1 + 2 + 3 + 4 + 5 + ... + 99 + 100 and get the answer without
needing to actually add all the numbers up.

But if I have a program DEFINED to add the input numbers, in order, then
it needs to do that, and do all 99 seperate additions.

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

XPost: sci.logic

Op 03.jul.2024 om 05:07 schreef olcott:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not give
the Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it?

You keep trying to get away with saying that the simulation is
incorrect when the semantics of the x86 language conclusively
proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues to the
final end.

void Infinite_Loop()
{
  HERE: goto HERE;
}

Why do you say such ridiculously stupid things that you are are false?

Your Infinite_Loop does not apply. For a two cycle recursive simulation

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

is a better example. This runs for N cycles. When aborted after N-1
cycles there is no reason to think that it specifies an infinite loop.
The abort was only too soon.

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

XPost: sci.logic

Op 03.jul.2024 om 15:22 schreef olcott:

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

Op 03.jul.2024 om 05:07 schreef olcott:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language.
Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not give >>>>>>>> the Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it?

You keep trying to get away with saying that the simulation is
incorrect when the semantics of the x86 language conclusively
proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues to
the final end.

void Infinite_Loop()
{
   HERE: goto HERE;
}

Why do you say such ridiculously stupid things that you are are false?

Your Infinite_Loop does not apply. For a two cycle recursive simulation

This says nothing about two cycles nitwit.

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

You told us that HHH aborts its simulation after two cycles. This means
that the simulated HHH, when properly simulated, also returns. Indeed
another simulator will show that the simulation of HHH returns.
But HHH does not do that. It aborts its own simulation when the
simulated HHH has only one cycle to go.
Comparable to:

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


But we know that you think that two equals infinite.
Maybe your simulator also thinks that Finite_Recursion (3) has an
infinite recursion.

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

XPost: sci.logic

Op 03.jul.2024 om 17:53 schreef olcott:

On 7/3/2024 10:44 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 15:22 schreef olcott:

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

Op 03.jul.2024 om 05:07 schreef olcott:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language. >>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not >>>>>>>>>> give the Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it?

You keep trying to get away with saying that the simulation is
incorrect when the semantics of the x86 language conclusively
proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues to
the final end.

void Infinite_Loop()
{
   HERE: goto HERE;
}

Why do you say such ridiculously stupid things that you are are false? >>>>>

Your Infinite_Loop does not apply. For a two cycle recursive simulation >>>>

This says nothing about two cycles nitwit.

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

You told us that HHH aborts its simulation after two cycles.

The above HHH refers to every pure function that correctly
emulates one of more steps of DDD.

As long as there are a finite number of steps, there is no infinite
recursion. The problem remains that HHH cannot simulate itself correctly.

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

XPost: sci.logic

Op 03.jul.2024 om 18:11 schreef olcott:

On 7/3/2024 11:05 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 17:53 schreef olcott:

On 7/3/2024 10:44 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 15:22 schreef olcott:

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

Op 03.jul.2024 om 05:07 schreef olcott:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language. >>>>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>>>

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not >>>>>>>>>>>> give the Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it? >>>>>>>>>>

You keep trying to get away with saying that the simulation is >>>>>>>>> incorrect when the semantics of the x86 language conclusively >>>>>>>>> proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues >>>>>>>> to the final end.

void Infinite_Loop()
{
   HERE: goto HERE;
}

Why do you say such ridiculously stupid things that you are are
false?

Your Infinite_Loop does not apply. For a two cycle recursive
simulation

This says nothing about two cycles nitwit.

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

You told us that HHH aborts its simulation after two cycles.

The above HHH refers to every pure function that correctly
emulates one of more steps of DDD.

As long as there are a finite number of steps, there is no infinite
recursion. The problem remains that HHH cannot simulate itself correctly.

void Infinite_Loop()
{
  HERE: goto HERE;
}

Likewise infinite loops are not infinite loops thus
contradicting the law of identity.

Bad example, although I know you think two equals infinite.

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

You (and your simulator) will probably think Finite_Recursion is also an infinite recursion.

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

XPost: sci.logic

Op 03.jul.2024 om 18:14 schreef olcott:

On 7/3/2024 11:05 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 17:53 schreef olcott:

On 7/3/2024 10:44 AM, Fred. Zwarts wrote:

Op 03.jul.2024 om 15:22 schreef olcott:

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

Op 03.jul.2024 om 05:07 schreef olcott:

On 7/2/2024 9:35 PM, Richard Damon wrote:

On 7/2/24 10:03 PM, olcott wrote:

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

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

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

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

Professor Sipser probably does understand the x86 language. >>>>>>>>>>>>> Shared-memory implementation of the Karp-Sipser
kernelization process
https://inria.hal.science/hal-03404798/file/hipc2021.pdf >>>>>>>>>>>>>

And the x86 language says the same thing,

YOU are just a liar, as proved by the fact that you can not >>>>>>>>>>>> give the Diagonalization proof you claimed you had.

Sorry, you are just too stupid to understand.

You continue to assume that you can simply disagree
with the x86 language. My memory was refreshed that
called you stupid would be a sin according to Christ.
I really want to do the best I can to repent.

But I am NOT disagreeing with the x86 language.

Can you point out what fact of it I am disagreing about it? >>>>>>>>>>

You keep trying to get away with saying that the simulation is >>>>>>>>> incorrect when the semantics of the x86 language conclusively >>>>>>>>> proves that it is correct.

Nope, and x86n emulation is only fully correct if it continues >>>>>>>> to the final end.

void Infinite_Loop()
{
   HERE: goto HERE;
}

Why do you say such ridiculously stupid things that you are are
false?

Your Infinite_Loop does not apply. For a two cycle recursive
simulation

This says nothing about two cycles nitwit.

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

You told us that HHH aborts its simulation after two cycles.

The above HHH refers to every pure function that correctly
emulates one of more steps of DDD.

As long as there are a finite number of steps, there is no infinite
recursion. The problem remains that HHH cannot simulate itself correctly.

The job of every halt decider is to predict what
the behavior of its input would be, not to get
stuck in infinite behavior so that it can never
report.

Remember: "I am not talking about a halt decider, dumbo!"?

We are talking about HHH simulating itself.
I proved that HHH cannot possibly correctly simulate itself.
Stop talking about 'correctly emulated by HHH', or show the error in the
proof.
I will not tolerate a change of subject. This point must be clear before
we can proceed to the next point.

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