On 2024-07-07 14:16:10 +0000, olcott said:

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

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

Whether a partial simulation of DDD simulates the return depends
on the simulator. The code of DDD and x86 language don't tell
how much a simulator (not shown above) simulates.

--
Mikko

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

On 7/8/24 9:04 AM, olcott wrote:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

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

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge. Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

Nope, YOU have the insufficent knowledge, since you don't understand
that the x86 language says programs are deterministic, and their
behavior is fully establish when they are written, and running or
simulating them is only a way to observe that behavior, and the only
CORRECT observation of all the behavior, so letting that operation reach
its final state.

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

And that means a simulation that exactly reproduces the behavior of the
program represented by the input, something H neither does nor correctly predicts the behvior of such a simulation. It can't have, because that simulation halts if H returns the 0 answer you claim it does, so H can
NEVER have correctly determined it doesn't.

Whether a partial simulation of DDD simulates the return depends
on the simulator.

That is false proving that you have insufficient knowledge.
When DDD is correctly simulated by any pure function x86 emulator
that aborts its emulation at some point calls HHH(DDD) this
call never returns.

DDD returns,

The simulation of DDD by HHH doesn't reach that point.

You are so stupid you can't tell the diffference because you think your
lies are truth.

The code of DDD and x86 language don't tell
how much a simulator (not shown above) simulates.

Correct analysis proves that does not matter. None of the N
emulated instructions of DDD correctly emulated by HHH ever
reach past the fourth instruction of DDD.

Nope, just more of your lies, your "facts" are things that even YOU have
proven to be false.

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

On 2024-07-08 13:04:13 +0000, olcott said:

On 7/8/2024 2:22 AM, Mikko wrote:

On 2024-07-07 14:16:10 +0000, olcott said:

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

Sufficient knowledge of the x86 language conclusively proves
that the call from DDD correctly emulated by HHH to HHH(DDD)
cannot possibly return for any pure function HHH.

Suffifcient knowledge of the x86 language makes obvious that
DDD returns if and only if HHH returns.

That is insufficient knowledge.

Sufficient for the particular purpose. Possibly insufficient for
some other purpose.

Sufficient knowledge proves that
DDD correctly simulated by HHH meets this criteria.

A false claim is not knowledge.

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

Whether a partial simulation of DDD simulates the return depends
on the simulator.

That is false proving that you have insufficient knowledge.

It is true. There are partial simulators that do simulate D(I) to its termination (if it terminates) and there are simulators that don't.
That you cannot imagine something does not mean it can't exist.

--
Mikko

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

Op 09.jul.2024 om 16:19 schreef olcott:

On 7/9/2024 1:22 AM, Mikko wrote:

On 2024-07-08 13:04:13 +0000, olcott said:

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

Whether a partial simulation of DDD simulates the return depends
on the simulator.

That is false proving that you have insufficient knowledge.

It is true. There are partial simulators that do simulate D(I) to its
termination (if it terminates) and there are simulators that don't.
That you cannot imagine something does not mean it can't exist.

No pure function x86 emulator HHH can possibly emulate DDD
to its termination.

Indeed, no such HHH exists. This proves that HHH cannot possibly
simulate itself correctly.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls
an emulated HHH(DDD) to repeat this process until the
emulated DDD is aborted.

No such HHH exists. Only HHH that simulates itself incorrectly exist.
It repeats until it aborts the simulation prematurely, because the
simulated HHH is programmed to also abort one cycle later, which makes
the abort premature.

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

Indeed, because it is aborted prematurely. A correct simulation shows
that DDD does return, but HHH cannot possibly simulated itself up to the
end.

The DDD is an unneeded complexity. In the following much simpler
example, no DDD is needed to show the same behaviour. H cannot possibly simulate itself correctly.

int main()
{
return H(main, 0);
}

Olcott dreams of an infinite recursion, but the recursion is finite,
because HHH aborts, just as in:


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

Olcott never told us how HHH simulates Finite_Recursion, but I would not
be surprised if it thinks that it must abort it, too, for any N greater
than two. Because two seems to be infinite for it.

And even although the simulation is clearly incorrect, olcott loves to
remember Sipser, who only talks about correct simulations.

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

Op 09.jul.2024 om 16:46 schreef olcott:

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

Op 09.jul.2024 om 16:19 schreef olcott:

On 7/9/2024 1:22 AM, Mikko wrote:

On 2024-07-08 13:04:13 +0000, olcott said:

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

Whether a partial simulation of DDD simulates the return depends
on the simulator.

That is false proving that you have insufficient knowledge.

It is true. There are partial simulators that do simulate D(I) to
its termination (if it terminates) and there are simulators that don't. >>>> That you cannot imagine something does not mean it can't exist.

No pure function x86 emulator HHH can possibly emulate DDD
to its termination.

Indeed, no such HHH exists. This proves that HHH cannot possibly
simulate itself correctly.

"Correctly" means must do whatever the x86 code specifies.

And since the x86 code never specifies an abort, it is incorrect to
abort halfway a simulation that would halt. We know it would halt,
because other simulators show that it halts when HHH is correctly simulated.
If you want to deny this truth, point to the specification of the x86
language where it says that a program must be aborted. It is irrational
to defend an unneeded abort with a reference to the x86 specifications.

You are in psychological denial causing you to be irrational.

Illogical and irrelevant remarks ignored. I know olcott has problems to recognize the truth, so I do not feel offended.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls
an emulated HHH(DDD) to repeat this process until the
emulated DDD is aborted.

And the fact *that* it aborts, makes the simulation incorrect (as Sipser
would agree with), because the X86 code does not specify an abort at
that point. Therefore, the only conclusion must be: No such HHH exists.
We are discussing an empty set of HHH,
because HHH cannot possibly simulate itself correctly. HHH will always
abort too soon, when the simulated HHH has only one cycle to go.

It is easier to see with the following program, where the unneeded
complexity of DDD is eliminated:

int main()
{
return HHH(main);
}

The problem that HHH aborts after two cycles makes that it probably also
aborts

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

after two cycles of recursion.

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

Op 09.jul.2024 om 18:44 schreef olcott:

On 7/9/2024 10:21 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 16:46 schreef olcott:

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

Indeed, no such HHH exists. This proves that HHH cannot possibly
simulate itself correctly.

"Correctly" means must do whatever the x86 code specifies.

And since the x86 code never specifies an abort, it is incorrect to
abort halfway a simulation that would halt. We know it would halt,
because other simulators show that it halts when HHH is correctly
simulated.
If you want to deny this truth, point to the specification of the x86
language where it says that a program must be aborted. It is
irrational to defend an unneeded abort with a reference to the x86
specifications.

You are in psychological denial causing you to be irrational.

Illogical and irrelevant remarks ignored. I know olcott has problems
to recognize the truth, so I do not feel offended.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls
an emulated HHH(DDD) to repeat this process until the
emulated DDD is aborted.

And the fact *that* it aborts, makes the simulation incorrect (as
Sipser would agree with), because the X86 code does not specify an
abort at that point. Therefore, the only conclusion must be: No such
HHH exists.

HHH is fully operational in the x86utm operating system.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

When DDD is correctly emulated by any pure function x86
emulator HHH calls an emulated HHH(DDD) this call cannot
possibly return.

HHH cannot possibly simulate itself to the end and return, which shows
that its simulation is incorrect.

This prevents the emulated DDD from ever
reaching past its own machine address of 0000216b and halting.

Indeed, which shows that the simulation is incorrect.

HHH is required to report that it must abort the emulaton of
its input. HHH cannot correctly report that DDD need not be
aborted on the basis of the behavior of a directly executed
DDD(DDD) after HHH has already aborted its emulated DDD.
The sequence of sequence, selection and iteration cannot be
ignored.

Your seem to lose control of the discussion. HHH cannot report anything.
It is just a simulator that is unable to simulate itself op to the return.
HHH cannot possibly simulate itself correctly. So, it gives up and
returns. There is no report, only an incomplete simulation.

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

Am Tue, 09 Jul 2024 12:02:40 -0500 schrieb olcott:

On 7/9/2024 11:51 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 18:44 schreef olcott:

On 7/9/2024 10:21 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 16:46 schreef olcott:

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

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls an emulated >>>>>>> HHH(DDD) to repeat this process until the emulated DDD is aborted.

And the fact *that* it aborts, makes the simulation incorrect (as
Sipser would agree with), because the X86 code does not specify an
abort at that point. Therefore, the only conclusion must be: No such
HHH exists.

HHH is fully operational in the x86utm operating system.

When DDD is correctly emulated by any pure function x86 emulator HHH
calls an emulated HHH(DDD) this call cannot possibly return.

HHH cannot possibly simulate itself to the end and return, which shows

the simulation is correct because that is what the x86 code means when
it says that DDD correctly emulated by HHH is stuck in recursive
emulation.

The assembly doesn't show anything about emulation. There are only
function calls. If you just showed the source for HHH, you could point
to the line where it aborts.

That people not sufficiently understanding the semantics of the x86
language say otherwise merely proves that their understanding is insufficient.

For the millionth time: Nothing about this is special to x86.
What are the semantics that say that HHH doesn't halt?

--
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)

Am Tue, 09 Jul 2024 11:44:53 -0500 schrieb olcott:

On 7/9/2024 10:21 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 16:46 schreef olcott:

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

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls an emulated
HHH(DDD) to repeat this process until the emulated DDD is aborted.

And the fact *that* it aborts, makes the simulation incorrect (as
Sipser would agree with), because the X86 code does not specify an
abort at that point. Therefore, the only conclusion must be: No such
HHH exists.

HHH is fully operational in the x86utm operating system.

It does not fulfill the specification. Your HHH is not the true HHH.
It is bugged.

When DDD is correctly emulated by any pure function x86 emulator HHH
calls an emulated HHH(DDD) this call cannot possibly return. This
prevents the emulated DDD from ever reaching past its own machine
address of 0000216b and halting.

Are you saying that the called HHH(DDD) does not terminate?

HHH is required to report that it must abort the emulaton of its input.

No, why?

HHH cannot correctly report that DDD need not be aborted on the basis of
the behavior of a directly executed DDD(DDD) after HHH has already
aborted its emulated DDD.

Why did it abort DDD 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 09.jul.2024 om 19:02 schreef olcott:

On 7/9/2024 11:51 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 18:44 schreef olcott:

On 7/9/2024 10:21 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 16:46 schreef olcott:

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

Indeed, no such HHH exists. This proves that HHH cannot possibly
simulate itself correctly.

"Correctly" means must do whatever the x86 code specifies.

And since the x86 code never specifies an abort, it is incorrect to
abort halfway a simulation that would halt. We know it would halt,
because other simulators show that it halts when HHH is correctly
simulated.
If you want to deny this truth, point to the specification of the
x86 language where it says that a program must be aborted. It is
irrational to defend an unneeded abort with a reference to the x86
specifications.

You are in psychological denial causing you to be irrational.

Illogical and irrelevant remarks ignored. I know olcott has problems
to recognize the truth, so I do not feel offended.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls
an emulated HHH(DDD) to repeat this process until the
emulated DDD is aborted.

And the fact *that* it aborts, makes the simulation incorrect (as
Sipser would agree with), because the X86 code does not specify an
abort at that point. Therefore, the only conclusion must be: No such
HHH exists.

HHH is fully operational in the x86utm operating system.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

When DDD is correctly emulated by any pure function x86
emulator HHH calls an emulated HHH(DDD) this call cannot
possibly return.

HHH cannot possibly simulate itself to the end and return, which shows
that

the simulation is correct because that is what the x86
code means when it says that DDD correctly emulated by HHH
is stuck in recursive emulation.

That people not sufficiently understanding the semantics
of the x86 language say otherwise merely proves that their
understanding is insufficient.

You understand x86 insufficiently, because you think that a two cycle
recursion means an infinite recursion.

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

HHH, therefore, is programmed incorrectly, so that after two cycles it
aborts.
But it aborts when the simulated HHH is programmed to go for one other
cycle and then also abort and return. Therefore, the simulation is
aborted too soon, which makes it incorrect.
Maybe you should study x86, so that you see that no abort is needed for
a simulation of a halting program. The x86 language does not allow to
abort a halting program.
A simulator that correctly interprets the x86 code of HHH shows that it
halts.
Only HHH cannot possibly simulate itself correctly.

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

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

On 7/9/2024 11:51 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 18:44 schreef olcott:

On 7/9/2024 10:21 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 16:46 schreef olcott:

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

Indeed, no such HHH exists. This proves that HHH cannot possibly
simulate itself correctly.

"Correctly" means must do whatever the x86 code specifies.

And since the x86 code never specifies an abort, it is incorrect to
abort halfway a simulation that would halt. We know it would halt,
because other simulators show that it halts when HHH is correctly
simulated.
If you want to deny this truth, point to the specification of the
x86 language where it says that a program must be aborted. It is
irrational to defend an unneeded abort with a reference to the x86
specifications.

You are in psychological denial causing you to be irrational.

Illogical and irrelevant remarks ignored. I know olcott has problems
to recognize the truth, so I do not feel offended.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

*When DDD is correctly emulated by any pure function*
*HHH x86 emulator that can possibly exist* which calls
an emulated HHH(DDD) to repeat this process until the
emulated DDD is aborted.

And the fact *that* it aborts, makes the simulation incorrect (as
Sipser would agree with), because the X86 code does not specify an
abort at that point. Therefore, the only conclusion must be: No such
HHH exists.

HHH is fully operational in the x86utm operating system.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

When DDD is correctly emulated by any pure function x86
emulator HHH calls an emulated HHH(DDD) this call cannot
possibly return.

HHH cannot possibly simulate itself to the end and return, which shows
that

the simulation is correct because that is what the x86
code means when it says that DDD correctly emulated by HHH
is stuck in recursive emulation.

BNo, the simulation is INCORRECT because it is INCOMPLETE, because the definition of the execution of every instruction emulated included that
the next instruction WILL execute, and thus stopping the emulation at
that point is just INCORRECT.

That people not sufficiently understanding the semantics
of the x86 language say otherwise merely proves that their
understanding is insufficient.

No, YOU don't understand that fundamental nature or computers.

How would you like it if the programs on your computer suddenly decided
they could just stop at arbitary points?

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

Am Tue, 09 Jul 2024 16:18:07 -0500 schrieb olcott:

On 7/9/2024 3:31 PM, Fred. Zwarts wrote:

DDD [0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

I am saying that DDD correctly emulated by HHH can't freaking make it
past the above line of code no freaking matter what.

That means that HHH doesn't return, in particular that it doesn't abort.

--
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 09.jul.2024 om 23:18 schreef olcott:

On 7/9/2024 3:31 PM, Fred. Zwarts wrote:

You understand x86 insufficiently, because you think that a two cycle
recursion means an infinite recursion.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

I am saying that DDD correctly emulated by HHH
can't freaking make it past the above line of
code no freaking matter what.

Which proves that HHH does not interpret x86 code correctly. So, the set
of HHH that correctly emulates is empty.
It performs an abort halfway the simulation, where the x86 code does not
allow it.
You can repeat it hundred times, but that does not make it correct.
HHH cannot possibly simulate itself correctly.
You may want very very much that it is correct, but that does not change
the situation that it is incorrect.
A correct simulator shows that HHH *does* abort and halt. So, when HHH
is unable to reproduce it, it only shows that its simulation is incorrect.
A two cycle recursion is not an infinite recursion. Is that already over
your head?

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

Maybe it is too complex for you, because you add an unneeded function
DDD. Without DDD it is much simpler to understand:

int main()
{
return HHH(main);
}

It is clear that HHH returns, but that its simulation thinks it does not
halt, which makes it simply incorrect.

So, Sipser was right, but he was talking about a correct simulation, not
about the incorrect simulation of HHH.

The chances of this are the same as a billion
geometric square circles hitting you in the face
and knocking you on your ass.

Irrelevant text ignored.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

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

On 2024-07-09 14:19:59 +0000, olcott said:

On 7/9/2024 1:22 AM, Mikko wrote:

On 2024-07-08 13:04:13 +0000, olcott said:

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

Whether a partial simulation of DDD simulates the return depends
on the simulator.

That is false proving that you have insufficient knowledge.

It is true. There are partial simulators that do simulate D(I) to its
termination (if it terminates) and there are simulators that don't.
That you cannot imagine something does not mean it can't exist.

No pure function x86 emulator HHH can possibly emulate DDD
to its termination.

_DDD()
[00002163] 55 push ebp ; housekeeping
[00002164] 8bec mov ebp,esp ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404 add esp,+04
[00002173] 5d pop ebp
[00002174] c3 ret
Size in bytes:(0018) [00002174]

An emulator can take a shortcut when it has to emulate a call to a
fuction it knows. In case it detects a call to itself it may simply
assume (correctly or incorrectly) that the function returns and
emulate the instructions after the call.

--
Mikko

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

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

Simulating a halting program only halfway and then abort it, is an
incorrect simulation.

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

Your knowledge of x86 seems to be failing. There is no reason to abort a halting program halfway its simulation.

Your understanding of correctly incorrectly diverges
from the semantics of the x86 language making you wrong.
You responded to the wrong version of my post.

You seem to have an invalid understanding of x86. It never indicates
that a halting program should be aborted halfway its simulation.

So, the set of HHH that correctly emulates is empty.

This is only your ignorance.

You failed to indicate why it is a good idea to abort a halting program
halfway its simulation.
You seem to be stuck in infinite invalid reasoning.
Wishing it is correct very very much does not make it correct.

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

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time. It is
programmed to simulate a fixed number of cycles (say N), after which it
aborts. Dreaming of other simulators that simulate 1 to ∞ steps does not change the HHH that we are considering.
A simulator does not need ∞ steps to simulate a halting program.
Only HHH cannot possibly simulate itself correctly, because it needs a
few (not ∞) one cycle more than N, but it can't do that.
So, no matter how many steps HHH is programmed to simulate, it always
aborts too soon, making the simulation incorrect.
Wishing very very much it is correct does not make it correct.
You can repeat it 1000 times more, but it does not make it correct.
It only displays a lack of reasoning.

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

Op 10.jul.2024 om 16:53 schreef olcott:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

Which conclusively proves that none of these simulations was correct.

For each of them, the semantics of the x86 conclusively proves that it
aborts one cycle too soon. Therefore, each of them is incorrect. The
only reason why the simulation does not halt, is that it is aborted one
cycle too soon.
The one that simulates 1 step is incorrect.The one that simulates 2
steps is incorrect, etc. Even the one that simulates ∞ steps is incorrect.
If not, tell us which of the infinite set is correct.

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

Op 10.jul.2024 om 19:41 schreef olcott:

On 7/10/2024 12:38 PM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:53 schreef olcott:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

Which conclusively proves that none of these simulations was correct.

For each of them, the semantics of the x86 conclusively proves that it
aborts one cycle too soon.

You seem to be a mindless idiot that cannot pay any attention.
You just stupidly said that the one that NEVER ABORTS aborts too soon.

It seems you do not even understand limits. When talking about 1 to ∞, ∞ should be taken as a limit. It means that no matter how large an N you
choose, the simulation that aborts after N cycles, still aborts one
cycle too soon.

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

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

What is the set you call "the etire set of every possible HHH"?

--
Mikko

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

On 7/11/24 10:49 AM, olcott wrote:

On 7/11/2024 2:22 AM, Mikko wrote:

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

What is the set you call "the etire set of every possible HHH"?

An infinite set of different instances of HHH
HHH emulates 1 step of DDD
HHH emulates 2 steps of DDD
HHH emulates 3 steps of DDD...
HHH emulates ∞ steps of DDD
Every DDD of each HHH/DDD pair is either aborted or keeps running.

No, the EMULATION of every DDD that is aborted creates a DDD that
returns in the behavior after HHH stops observing, because that HHH
(which that DDD called) returns to its caller, including that DDD.

Only the DDD that calls an HHH that NEVER aborts is non-halting.

You confuse the observation of the partial behavior by HHH emulating the
input with the ACTUAL behavior of that input.

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

On 2024-07-11 14:49:16 +0000, olcott said:

On 7/11/2024 2:22 AM, Mikko wrote:

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

What is the set you call "the etire set of every possible HHH"?

An infinite set of different instances of HHH
HHH emulates 1 step of DDD
HHH emulates 2 steps of DDD
HHH emulates 3 steps of DDD...
HHH emulates ∞ steps of DDD
Every DDD of each HHH/DDD pair is either aborted or keeps running.

In that situation you should use the symobls HHH₁, HHH₂, HHH₃, ...
so that you can use HHHᵢ when you say aothing about every one of them.
And the one more symbols for the one that runs forever. And they should
not be defined to run DDD but whatever input is given.

--
Mikko

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

Op 11.jul.2024 om 16:49 schreef olcott:

On 7/11/2024 2:22 AM, Mikko wrote:

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly.

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

What is the set you call "the etire set of every possible HHH"?

An infinite set of different instances of HHH
HHH emulates 1 step of DDD
HHH emulates 2 steps of DDD
HHH emulates 3 steps of DDD...
HHH emulates ∞ steps of DDD
Every DDD of each HHH/DDD pair is either aborted or keeps running.

Every HHH in this set is incorrect, because it cannot possibly simulate
itself correctly up to the end.
This shows that the set of HHH correctly simulating itself is empty.
It is incorrect, not because the start of the simulation is incorrect,
but because the HHH that abort, abort a halting program halfway, one
cycle before the simulation would halt, and the HHH that do not abort
does not halt at all. In none of these cases the end of the simulation
is reached.

The semantics of the x86 language specify that all N instructions of a
halting program must be processed to get the correct behaviour. HHH
cannot do that.

You make it unneeded complex by introducing DDD. The simpler example is:

int main()
{
return HHH(main);
}

No DDD needed. This shows more clearly that the problem is HHH, not DDD.
Since you told us that HHH aborts after a finite number of cycles of
recursive simulation, which was also shown in the full trace that you
mentioned as a reference, we see that the simulation is aborted one
cycle too soon. The simulation does not simulate the last part of the
behaviour correctly, which includes that last cycle, the abort and the
return. That is similar to the simulation of:

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

If Finite_Recursion(5) is simulated only for two cycles of recursion,
after which the simulation is aborted, then the simulation is incorrect.

And since the simulation is proven to be incorrect, you cannot refer to
Sipser, who only agreed with a correct simulation.

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

Op 12.jul.2024 om 14:33 schreef olcott:

On 7/12/2024 5:01 AM, Fred. Zwarts wrote:

Op 11.jul.2024 om 16:49 schreef olcott:

On 7/11/2024 2:22 AM, Mikko wrote:

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping >>>>>>>>> [00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly. >>>>>>>>>

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

What is the set you call "the etire set of every possible HHH"?

An infinite set of different instances of HHH
HHH emulates 1 step of DDD
HHH emulates 2 steps of DDD
HHH emulates 3 steps of DDD...
HHH emulates ∞ steps of DDD
Every DDD of each HHH/DDD pair is either aborted or keeps running.

Every HHH in this set is incorrect, because it cannot possibly
simulate itself correctly up to the end.

There is no freaking end you freaking moron.
I apologize for getting harsh, yet nothing else seems to work.

I don't feel offended, because I know you have problems to recognize the
truth.
You think that by only wishing and repeating you can make something true.

Each HHH that aborts has an end, namely, when it aborts and ends.
Your problem is that you HHH cannot reach that end, when simulating itself.
The HHH that does not abort has no end, so it is still true that it
cannot possibly simulate itself correctly up to the end.
That is what makes the simulation of HHH by itself incorrect.

This shows that the set of HHH correctly simulating itself is empty.
It is incorrect, not because the start of the simulation is incorrect,
but because the HHH that abort, abort a halting program halfway, one
cycle before the simulation would halt, and the HHH that do not abort do
not halt at all. In none of these cases the end of the simulation is
reached.

The semantics of the x86 language specify that all N instructions of a
halting program must be processed to get the correct behaviour. HHH
cannot do that.

You make it unneeded complex by introducing DDD. The simpler example is:

int main()
{
return HHH(main);
}

No DDD needed. This shows more clearly that the problem is HHH, not DDD.
Since you told us that HHH aborts after a finite number of cycles of
recursive simulation, which was also shown in the full trace that you
mentioned as a reference, we see that the simulation is aborted one
cycle too soon. The simulation does not simulate the last part of the
behaviour correctly, which includes that last cycle, the abort and the
return. That is similar to the simulation of:

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

If Finite_Recursion(5) is simulated only for two cycles of recursion,
after which the simulation is aborted, then the simulation is incorrect.

And since the simulation is proven to be incorrect, you cannot refer to
Sipser, who only agreed with a correct simulation.

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

Am Fri, 12 Jul 2024 07:33:01 -0500 schrieb olcott:

On 7/12/2024 5:01 AM, Fred. Zwarts wrote:

Op 11.jul.2024 om 16:49 schreef olcott:

On 7/11/2024 2:22 AM, Mikko wrote:

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

An infinite set of different instances of HHH HHH emulates 1 step of
DDD HHH emulates 2 steps of DDD HHH emulates 3 steps of DDD...
HHH emulates ∞ steps of DDD Every DDD of each HHH/DDD pair is either
aborted or keeps running.

Every HHH in this set is incorrect, because it cannot possibly simulate
itself correctly up to the end.

There is no freaking end you freaking moron.
I apologize for getting harsh, yet nothing else seems to work.

You said that HHH halts.

--
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)

Am Fri, 12 Jul 2024 08:45:55 -0500 schrieb olcott:

On 7/12/2024 7:53 AM, Fred. Zwarts wrote:

Op 12.jul.2024 om 14:33 schreef olcott:

There is no freaking end you freaking moron.
I apologize for getting harsh, yet nothing else seems to work.

I don't feel offended, because I know you have problems to recognize
the truth.
You think that by only wishing and repeating you can make something
true.
Each HHH that aborts has an end,

Maybe you don't understand what halting means.
When DDD correctly emulated by HHH stops running because HHH correctly recognizes that DDD would never otherwise stop running THIS DOES NOT
MEAN THAT DDD HALTS.

True. Only in this case DDD does actually halt and the abort was unneeded.

--
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 12.jul.2024 om 15:45 schreef olcott:

On 7/12/2024 7:53 AM, Fred. Zwarts wrote:

Op 12.jul.2024 om 14:33 schreef olcott:

There is no freaking end you freaking moron.
I apologize for getting harsh, yet nothing else seems to work.

I don't feel offended, because I know you have problems to recognize
the truth.
You think that by only wishing and repeating you can make something true.

Each HHH that aborts has an end,

Maybe you don't understand what halting means.
When DDD correctly emulated by HHH stops running because
HHH correctly recognizes that DDD would never otherwise
stop running THIS DOES NOT MEAN THAT DDD HALTS.

But HHH is wrong in this determination, because one cycle later its
simulation would halt without a need to abort, because the simulated HHH
would abort.

_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

We are talking about an HHH that is programmed to abort after N cycles
(with N = 0 up to an arbitrary large number ∞). Each of them aborts one
cycle before the simulated HHH would abort. It makes no sense to dream
about another HHH that does not abort, because we are considering the
case of an HHH that aborts.
This shows that each HHH aborts the simulation of itself prematurely. Therefore, each HHH has an end (that is how it is programmed), but the simulation does not reach it.
Therefore, each of these simulations is incorrect.

No matter how much you want to be it correct, or how many times you
repeat that its is correct, it does not change the fact that the
simulation is incorrect, because it is unable to reach the end.

DDD has nothing to do with it. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. Proving that the problem is not in DDD, but
in HHH, which is required to halt, but it decides that HHH does not halt.

HHH is unable to decide about finite recursions.

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

It decides after N recursions that there is an infinite recursion, which
is incorrect.

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

On 2024-07-12 13:35:34 +0000, olcott said:

On 7/12/2024 4:08 AM, Mikko wrote:

On 2024-07-11 14:49:16 +0000, olcott said:

On 7/11/2024 2:22 AM, Mikko wrote:

On 2024-07-10 14:53:00 +0000, olcott said:

On 7/10/2024 9:41 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 16:16 schreef olcott:

On 7/10/2024 9:09 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 14:37 schreef olcott:

On 7/10/2024 2:13 AM, Fred. Zwarts wrote:

Op 09.jul.2024 om 23:18 schreef olcot

_DDD()
[00002163] 55         push ebp      ; housekeeping >>>>>>>>> [00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)

DDD correctly emulated by any pure function HHH that
correctly emulates 1 to ∞ steps of DDD can't make it
past the above line of code no matter what.

[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]

Which proves that HHH does not interpret x86 code correctly. >>>>>>>>>

*It interprets the code correctly*
https://github.com/wfeldt/libx86emu

*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*
*correctly emulates 1 to ∞ steps of DDD*

You seem to be stuck in infinite invalid reasoning.
A simulator cannot simulate 1 to ∞ steps at the same time.

For the entire infinite set of every possible HHH the
semantics of the x86 language conclusively proves that
no DDD every halts.

What is the set you call "the etire set of every possible HHH"?

An infinite set of different instances of HHH
HHH emulates 1 step of DDD
HHH emulates 2 steps of DDD
HHH emulates 3 steps of DDD...
HHH emulates ∞ steps of DDD
Every DDD of each HHH/DDD pair is either aborted or keeps running.

In that situation you should use the symobls HHH₁, HHH₂, HHH₃, ...
so that you can use HHHᵢ when you say aothing about every one of them.
And the one more symbols for the one that runs forever.

I did not want to say it as verbosely as that, yet your suggestion
would be clearer.

For honest purposes clearer would be better. But understand that
different purposes mean different priorities.

And they should
not be defined to run DDD but whatever input is given.

I certainly can't do that. People here use every excuse
they can to change the subject and then stay on this
changed subject and never get back to the point.

Of course you can and should. No reason to expect them to protest less
if you make more errors.

--
Mikko

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

On 2024-07-13 12:44:50 +0000, olcott said:

On 7/13/2024 3:12 AM, Mikko wrote:

On 2024-07-12 13:35:34 +0000, olcott said:

On 7/12/2024 4:08 AM, Mikko wrote:

In that situation you should use the symobls HHH₁, HHH₂, HHH₃, ... >>>> so that you can use HHHᵢ when you say aothing about every one of them. >>>> And the one more symbols for the one that runs forever.

I did not want to say it as verbosely as that, yet your suggestion
would be clearer.

For honest purposes clearer would be better. But understand that
different purposes mean different priorities.

I made it clearer using your suggestions.

Where is that clearer presentations?

And they should
not be defined to run DDD but whatever input is given.

I certainly can't do that. People here use every excuse
they can to change the subject and then stay on this
changed subject and never get back to the point.

Of course you can and should. No reason to expect them to protest less
if you make more errors.

My current paper examines these three inputs at the C
source-code level in the simplest one first order.

void Infinite_Loop()
{
HERE: goto HERE;
}

void Infinite_Recursion()
{
Infinite_Recursion();
}

void DDD()
{
HHH(DDD);
}

It then examines the simplest possible pathological input
above at the assembly language level.

Going to the assembly langage level does not add anything if the code
of HHH is not shown. That HHH simulates at the machine langage level
does not alter the fact that the behaviour it simulates is the behaviour
of the C code.

Then it moves on to this input showing that its x86 execution
trace is essentially the same as DDD correctly emulated by HHH.

If HHH aborts its simulation and never simulates the return from HHH or anything past that point then it does not matter what the behaour after
point is. This is obvious from the C semantics.

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

But the part that HHH never simulates is the part that determines
whether the program returns or not. The halt status of DD is differnt
from the halt status of DDD if HHH(DD) returns nonzero. Otherwise
it is the same.

Then the last half of the paper applies these same ideas
to the Peter Linz Turing machine based proof based on this
greatly simplified syntax.

I show that ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by adapted UTM embedded_H has
this same essential pattern as the above two, it remains
stuck in recursive simulation until its input is aborted.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

This is incorrect. That looks like tree clauses, a subordinate clause and
two main coordinated main clauses. But there should be conjunctions that
show either that the structure really is so or that the intended meaning
is something else.

--
Mikko

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