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

On 7/11/2024 2:20 AM, Fred. Zwarts wrote:

Op 10.jul.2024 om 20:58 schreef olcott:

On 7/10/2024 1:55 PM, Alan Mackenzie wrote:

Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:

Op 10.jul.2024 om 20:12 schreef Alan Mackenzie:

[ Followup-To: set ]

In comp.theory Fred. Zwarts <F.Zwarts@hetnet.nl> wrote:

[ .... ]

Proving that the simulation is incorrect. Because a correct
simulation
would not abort a halting program halfway its simulation.

Just for clarity, a correct simulation wouldn't abort a non-halting >>>>>> program either, would it?  Or have I misunderstood this correctness? >>>>
[ .... ]

A non-halting program cannot be simulated correctly in a finite time. >>>>> So, it depends whether we can call it a correct simulation, when it
does
not abort. But, for some meaning of 'correct', indeed, a simulator
should not abort a non-halting program either.

OK, thanks!

In other words he is saying that when you do
1 step correctly you did 0 steps correctly.

That is not what I said.

What you said logically entails that a correct simulation
of 1 step counts as a correct simulation of 0 steps.

And since the only "correct simulation" would be of ALL the stes,

What I said is that if a program needs two steps for a simulation, it
is incorrect to simulate only one step and then abort and report it
will never halt.
English seems to be a difficult language for you.

I am talking about the correct simulation of N steps and you
are trying to get away with saying there is no such thing
as the correct simulation of N steps. That is either terribly
confused or dishonest, yet incorrect either way.

But the correct simulation of N steps is NOT the correct simulation,
which implies of ALL steps.

You have just been caught lying by being imprecise and claiming two
different meanigs.

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

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

No DDD instance of each HHH/DDD pair ever reaches past its
own machine address of 0000216b and halts.

Thus each HHH element of the above infinite set of HHH/DDD
pairs is necessarily correct to reject its DDD as non-halting.

The "V2" in the subject line means that there was an error in the original.
The message should tell what the error was so that readers could focus on
the correction.

--
Mikko

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

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity steps of DDD₁ are correctly emulated by HHH₃" or whatever you mean.

--
Mikko

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

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean.

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does
not specify a behaviour and the question whether DDD halts is ill-posed.

--
Mikko

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

Op 15.jul.2024 om 15:43 schreef olcott:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity
steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean.

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input
does
not specify a behaviour and the question whether DDD halts is ill-posed.

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

We know that DDD can reach its final state. The reason that the
simulated DDD cannot reach its final state is that it is aborted one
cycle to soon.

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

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

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself 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.

Your HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed N-1 cycles,
because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct
simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria you stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

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

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

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

Am Mon, 15 Jul 2024 08:43:34 -0500 schrieb olcott:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

You should use the indices here, too, e.g., "where 1 to infinity
steps of DDD₁ are correctly emulated by HHH₃" or whatever you mean. >>>>

DDD is the exact same fixed constant finite string that always calls
HHH at the same fixed constant machine address.

If the function called by DDD is not part of the input then the input
does not specify a behaviour and the question whether DDD halts is
ill-posed.

We don't care about whether HHH halts. We know that HHH halts or fails
to meet its design spec.

Therefore it doesn't need to be aborted.

We are only seeing if DDD correctly emulated by HHH can can possibly
reach its own final state.

Which it can, since it only calls a halting HHH.

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

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

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the
semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly.

When we examine the infinite set of every HHH/DDD pair such that:
HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity steps of >>>> DDD₁ are correctly emulated by HHH₃" or whatever you mean.

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does >> not specify a behaviour and the question whether DDD halts is ill-posed.

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate
DDD to its final state. But we can see more, in particuar that DDD() halts
if HHH(DDD) does.

Anyway, if the function DDD calls is not a part of the input then the
question whether DDD halts is not well-posed and can only be ansered
with a conditional.

--
Mikko

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

Op 16.jul.2024 om 20:18 schreef olcott:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>> semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly. >>>>>>>
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity
steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean.

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the
input does
not specify a behaviour and the question whether DDD halts is
ill-posed.

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate
DDD to its final state.

No. HHH is not judging whether or not itself is a correct
emulator. The semantics of the x86 instructions that emulates
prove that its emulation is correct.

Only because DDD calls HHH(DDD) in recursive emulation it is
impossible for DDD correctly emulated by HHH to reach past
its own machine address of 0000216b.

But we can see more, in particuar that DDD() halts
if HHH(DDD) does.

In the exact same way that we can see that we are no longer
hungry after we have eaten. It is still a fact that HHH(DDD)
was required to abort its emulation in the exact same way
that it was required for us to eat to no longer be hungry.

But a person which has eaten is not hungry any more and does not need
food any more.
Similarly, a HHH that aborts does not need to be aborted.

Anyway, if the function DDD calls is not a part of the input then the
question whether DDD halts is not well-posed and can only be ansered
with a conditional.

We are analyzing whether or not DDD halts.
We are NOT analyzing whether or not HHH halts.

You are wring. DDD does not halt, because HHH is unable to simulate itself.

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

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

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself 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.

Your HHH is programmed to abort the simulation after N cycles of
recursive simulations. Therefore, it is incorrect to abort the
simulation of HHH when the simulated HHH has performed N-1 cycles,
because that changes the behaviour of HHH.
Since the simulated HHH always runs one cycle behind the simulating HHH,
it is clear that HHH can never simulate enough cycles for a correct
simulation, as is required by the x86 language.
Therefore, the simulation is incorrect according to the criteria you stipulated.
The conclusion is simple:
HHH cannot possibly simulate itself correctly.

No matter how much you want it to be correct, or how many times you
repeat that it is correct, it does not change the fact that such a
simulation is incorrect, because it is unable to reach the end.
Your own claim that the simulated HHH does not reach its end confirms
it. The trace you have shown also proves that HHH cannot reach the end
of its own simulation. So, your own claims prove that it is true that
HHH cannot possibly simulate itself up to the end, which makes the
simulation incorrect.

Sipser would agree that this incorrect simulation cannot be used to
detect a non-halting behaviour.

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

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

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>> semantics of the x86 programming language.
When N steps of DDD are emulated by HHH according to the semantics >>>>>>> of the x86 language then N steps are emulated correctly.
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
The above specifies the infinite set of every HHH/DDD pair where 1 >>>>>>> to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity
steps of DDD₁ are correctly emulated by HHH₃" or whatever you mean. >>>>>>

DDD is the exact same fixed constant finite string that always calls >>>>> HHH at the same fixed constant machine address.

If the function called by DDD is not part of the input then the input
does not specify a behaviour and the question whether DDD halts is
ill-posed.

We don't care about whether HHH halts. We know that HHH halts or fails
to meet its design spec.
We are only seeing if DDD correctly emulated by HHH can can possibly
reach its own final state.

HHH does not see even that. It only sees whther that it does not
emulate DDD to its final state.

No. HHH is not judging whether or not itself is a correct emulator. The semantics of the x86 instructions that emulates prove that its emulation
is correct.

You have been saying for a while that HHH returns what it would report
on its input DDD. Glad to see you come around.

Only because DDD calls HHH(DDD) in recursive emulation it is impossible
for DDD correctly emulated by HHH to reach past its own machine address
of 0000216b.

It is not impossible. The simulated HHH aborts just the same and returns
to DDD.

But we can see more, in particuar that DDD() halts if HHH(DDD) does.

It is still a fact that HHH(DDD) was required to abort its emulation.

Just no.

Anyway, if the function DDD calls is not a part of the input then the
question whether DDD halts is not well-posed and can only be ansered
with a conditional.

We are analyzing whether or not DDD halts.
We are NOT analyzing whether or not HHH halts.

Whether DDD halts depends entirely on HHH, because DDD does nothing
else but call it.

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

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

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>> semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly. >>>>>>>
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean.

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does >>>> not specify a behaviour and the question whether DDD halts is ill-posed. >>>>

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate
DDD to its final state.

No. HHH is not judging whether or not itself is a correct
emulator. The semantics of the x86 instructions that emulates
prove that its emulation is correct.

The semantics does not prove. Only a proof would prove.

--
Mikko

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

Op 16.jul.2024 om 22:43 schreef joes:

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

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>>> semantics of the x86 programming language.
When N steps of DDD are emulated by HHH according to the semantics >>>>>>>> of the x86 language then N steps are emulated correctly.
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.
The above specifies the infinite set of every HHH/DDD pair where 1 >>>>>>>> to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity >>>>>>> steps of DDD₁ are correctly emulated by HHH₃" or whatever you mean. >>>>>>>

DDD is the exact same fixed constant finite string that always calls >>>>>> HHH at the same fixed constant machine address.

If the function called by DDD is not part of the input then the input >>>>> does not specify a behaviour and the question whether DDD halts is
ill-posed.

We don't care about whether HHH halts. We know that HHH halts or fails >>>> to meet its design spec.
We are only seeing if DDD correctly emulated by HHH can can possibly
reach its own final state.

HHH does not see even that. It only sees whther that it does not
emulate DDD to its final state.

No. HHH is not judging whether or not itself is a correct emulator. The
semantics of the x86 instructions that emulates prove that its emulation
is correct.

You have been saying for a while that HHH returns what it would report
on its input DDD. Glad to see you come around.

Only because DDD calls HHH(DDD) in recursive emulation it is impossible
for DDD correctly emulated by HHH to reach past its own machine address
of 0000216b.

It is not impossible. The simulated HHH aborts just the same and returns
to DDD.

But we can see more, in particuar that DDD() halts if HHH(DDD) does.

It is still a fact that HHH(DDD) was required to abort its emulation.

Just no.

Anyway, if the function DDD calls is not a part of the input then the
question whether DDD halts is not well-posed and can only be ansered
with a conditional.

We are analyzing whether or not DDD halts.
We are NOT analyzing whether or not HHH halts.

Whether DDD halts depends entirely on HHH, because DDD does nothing
else but call it.

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

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

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.

HHH is simply 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-17 13:04:44 +0000, olcott said:

On 7/17/2024 1:52 AM, Mikko wrote:

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>>>> semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly. >>>>>>>>>
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH. >>>>>>>>

You should use the indices here, too, e.g., "where 1 to infinity steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean. >>>>>>>>

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does
not specify a behaviour and the question whether DDD halts is ill-posed. >>>>>>

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate >>>> DDD to its final state.

No. HHH is not judging whether or not itself is a correct
emulator. The semantics of the x86 instructions that emulates
prove that its emulation is correct.

The semantics does not prove. Only a proof would prove.

Nothing besides the semantics of English proves that
a kitten is not any type of 15 story office building.

The semantics of English does not prove that someone heard to use the word "kitten" does not refer to a 15 story office building. Perhaps the speaker
is a criminal who does not want be understood except by members of the
same gang.

--
Mikko

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

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>> semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly. >>>>>>>
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH.

You should use the indices here, too, e.g., "where 1 to infinity steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean.

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does >>>> not specify a behaviour and the question whether DDD halts is ill-posed. >>>>

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate
DDD to its final state.

No. HHH is not judging whether or not itself is a correct
emulator. The semantics of the x86 instructions that emulates
prove that its emulation is correct.

Semantics of x86 language alone doesn't prove anything. Only a detailed comparison of the emulator code to the x86 semantics may prove that.

--
Mikko

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

Am Wed, 31 Jul 2024 12:28:38 -0500 schrieb olcott:

On 7/31/2024 2:36 AM, Mikko wrote:

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

If the function called by DDD is not part of the input then the
input does not specify a behaviour and the question whether DDD
halts is ill-posed.

We don't care about whether HHH halts. We know that HHH halts or
fails to meet its design spec.
We are only seeing if DDD correctly emulated by HHH can can possibly >>>>> reach its own final state.

HHH does not see even that. It only sees whther that it does not
emulate DDD to its final state.

No. HHH is not judging whether or not itself is a correct emulator.

"HHH is correct when it gives the result it gives" lol

The semantics of the x86 instructions that emulates prove that its
emulation is correct.

Semantics of x86 language alone doesn't prove anything. Only a detailed
comparison of the emulator code to the x86 semantics may prove that.

*Infinite recursion behavior pattern*
An emulated sequence of instructions that has no conditional branch instructions in this sequence is exactly repeated when it calls the same function with the same parameters again.

Not the case here: as Mike pointed out, we are dealing with simulation,
not with calls. Furthermore, it is not the same function when the abort
is commented out or disabled by a static variable.

HHH continues to emulate DDD until DDD halts* or DDD proves that it must
be aborted. This proves that no emulated HHH can possibly return to any emulated DDD, thus DDD never *halts.

If HHH is a decider, it halts, returning to DDD.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

On 2024-07-31 17:28:38 +0000, olcott said:

On 7/31/2024 2:36 AM, Mikko wrote:

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>>>> semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the
semantics of the x86 language then N steps are emulated correctly. >>>>>>>>>
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH.
...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair
where 1 to infinity steps of DDD are correctly emulated by HHH. >>>>>>>>

You should use the indices here, too, e.g., "where 1 to infinity steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean. >>>>>>>>

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does
not specify a behaviour and the question whether DDD halts is ill-posed. >>>>>>

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate >>>> DDD to its final state.

No. HHH is not judging whether or not itself is a correct
emulator. The semantics of the x86 instructions that emulates
prove that its emulation is correct.

Semantics of x86 language alone doesn't prove anything. Only a detailed
comparison of the emulator code to the x86 semantics may prove that.

A proof is any sequence of steps such that the conclusion
is a necessary consequence of its basis.

Only if every "step" is a sentence.

Your traces are not such sequences.

Proving that DDD correctly emulated by HHH matches the
infinite recursion behavior pattern.
(a) The semantics of the x86 language.
(b) the design of HHH provided below.
(c) The definition of infinite recursion provided below.

*Infinite recursion behavior pattern*
An emulated sequence of instructions that has no conditional
branch instructions in this sequence is exactly repeated when
it calls the same function with the same parameters again.
As long as the called function can be determined to never
return this proves infinite recursion.

The recursive simulation does not satisfy the "no conditional branch" requirement so does not match the pattern.

--
Mikko

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

On 2024-08-01 11:56:31 +0000, olcott said:

On 8/1/2024 2:49 AM, Mikko wrote:

On 2024-07-31 17:28:38 +0000, olcott said:

On 7/31/2024 2:36 AM, Mikko wrote:

On 2024-07-16 18:18:07 +0000, olcott said:

On 7/16/2024 2:57 AM, Mikko wrote:

On 2024-07-15 13:43:34 +0000, olcott said:

On 7/15/2024 3:17 AM, Mikko wrote:

On 2024-07-14 14:50:47 +0000, olcott said:

On 7/14/2024 5:09 AM, Mikko wrote:

On 2024-07-12 14:56:05 +0000, olcott said:

We stipulate that the only measure of a correct emulation is the >>>>>>>>>>> semantics of the x86 programming language.

_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 N steps of DDD are emulated by HHH according to the >>>>>>>>>>> semantics of the x86 language then N steps are emulated correctly. >>>>>>>>>>>
When we examine the infinite set of every HHH/DDD pair such that: >>>>>>>>>>> HHH₁ one step of DDD is correctly emulated by HHH.
HHH₂ two steps of DDD are correctly emulated by HHH.
HHH₃ three steps of DDD are correctly emulated by HHH. >>>>>>>>>>> ...
HHH∞ The emulation of DDD by HHH never stops running.

The above specifies the infinite set of every HHH/DDD pair >>>>>>>>>>> where 1 to infinity steps of DDD are correctly emulated by HHH. >>>>>>>>>>

You should use the indices here, too, e.g., "where 1 to infinity steps of
DDD₁ are correctly emulated by HHH₃" or whatever you mean. >>>>>>>>>>

DDD is the exact same fixed constant finite string that
always calls HHH at the same fixed constant machine
address.

If the function called by DDD is not part of the input then the input does
not specify a behaviour and the question whether DDD halts is ill-posed.

We don't care about whether HHH halts. We know that
HHH halts or fails to meet its design spec.

We are only seeing if DDD correctly emulated by HHH
can can possibly reach its own final state.

HHH does not see even that. It only sees whther that it does not emulate >>>>>> DDD to its final state.

No. HHH is not judging whether or not itself is a correct
emulator. The semantics of the x86 instructions that emulates
prove that its emulation is correct.

Semantics of x86 language alone doesn't prove anything. Only a detailed >>>> comparison of the emulator code to the x86 semantics may prove that.

A proof is any sequence of steps such that the conclusion
is a necessary consequence of its basis.

Only if every "step" is a sentence.

Not at all.

From the meaning of "proof" directly follows that every proof is
a sequence of sentences.

--
Mikko

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