On 3/2/25 4:21 PM, olcott wrote:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

WHich only shows that HHH can not correctly emulate its input and give
an answer.

Since the halting problem is *NOT* about the emulation done by the
decider, you are just working on a strawman.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

Another different instance that does not call its own
emulator in recursive emulation is not the same damn thing.

But what emulator is looking at a program can not matter.

It seems you theory of programming has a significant deviation from the standard model, likely because you just don't understand the meaning of
the basic terms.

For instance, the DD you have shown is *NOT* a complete program by
itself, as it is using an unknown function that isn't defined, that of HHH.

Once you include a definition of HHH, then it becomes clear that either
HHH does the correct simulation and doesn't answer, or it doesn't do the correct simulation, and gives the wrong answer.

Thus, your whole system is in error because you are just too stupid to understand what you are talking about.

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

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was unable to
reach the 'ret' instruction. So in Olcott's terminology 'non terminating behavior' is a property of the simulator of DD, not of DD in the context
of the x86 language. 'Non termination behaviour' used in this way means
only one thing: HHH could not possibly reach the end of the simulation.

Another different instance that does not call its own
emulator in recursive emulation is not the same damn thing.

Exactly the same instance of the finite string DD, when given for direct execution, or to correct simulator, does reach the 'ret' instruction.

So we can reach agreement if we make the following claims:
1) Direct execution reaches the 'ret' instruction of exactly the same
finite string DD.
2) HHH cannot possibly reach the 'ret' instruction of exactly the same
finite string DD.
3) A yellow carrot does not even reach the first instruction of exactly
the same finite string DD.
4) HHH1 reaches the 'ret' instruction of exactly the same finite string DD.

If termination behaviour is changed to mean something about the
environment, instead of DD itself, then 1 and 4 show termination
behaviour and 2 and 3 show non termination behaviour for exactly the
same finite string DD.

What is the value of his result? Who is interested in the possibility to
make a simulator that does not reach the 'ret' instruction of a program
if other environments reach that instruction without problems?

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

On 3/2/25 5:28 PM, olcott wrote:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was unable
to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

No, it calls a specific emulator, that of a given HHH. There is no
requirement for the program DD to be emulated by that program.

You are just proving that you don't understand what a program is.
Programs are independent entities, that operate on their own. They don't
need an "emulator" to run them. Depending on your computation structure,
they may need a "processor" to run them, which in this case would be an
x86 processor, or a correct software emulator of one, but the program is defined as using a fully correct complete operation of that program, not
what some partial operation done by a partial (and thus incorrect) emulator/decider.

Your ignorance of this just shows how little you know, and your
rejection of it when it is pointed out just shows you don't care about
the facts, just your pathological lies about it.

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

On 3/2/25 8:21 PM, olcott wrote:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 5:28 PM, olcott wrote:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was
unable to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

No, it calls a specific emulator, that of a given HHH. There is no
requirement for the program DD to be emulated by that program.

THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR

Which is just a LIE, it calls the specific HHH that aborts its emulation
and return. You are just showing you don't understand what your words mean.

MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION

Nope, prove otherwise by HHH1.

I have been very stupid about this too because I
should have thought of those words two years ago.

That I did not think of those words two years ago
seems to make me a moron about effective communication.

But your words are just lies that expose your utter stupidity,

THe problem is your whole arguement is based on lies and errors, which
have been pointed out many times, and you ignore them because you know
you have no defense, but just continue your FRAUD by repeating the known errors.

You are so stupid, you make fundamental errors in your use of terms, and
are so stupid you can't see the errors when they are pointed out,
because you have brainwashed yourself to blindly beleive your own lies.

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

Am Sun, 02 Mar 2025 22:19:48 -0600 schrieb olcott:

On 3/2/2025 9:46 PM, Richard Damon wrote:

On 3/2/25 9:22 PM, olcott wrote:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 4:49 PM, olcott wrote:

On 3/2/2025 3:29 PM, Richard Damon wrote:

On 3/2/25 4:21 PM, olcott wrote:

WHich only shows that HHH can not correctly emulate its input and
give an answer.

The fact that HHH does correctly determine that DD emulated by HHH
cannot possibly reach its own "ret"
instruction and terminate normally proves that your claim is counter >>>>> factual.

You say that, but it isn't true,

You keep trying to get away with saying that the fact that DD calls
its own emulator in recursive emulation does not change the behavior
from the behavior of the directly executed DD.

Obviously. DD is fixed.

And you keep on making the claim without evidence!!!!
What instruction acted differently between the to, that was directly
executied and correctly emulated to different results.

The call to HHH(DD) from the directly executed DD returns to DD. The
call to HHH(DD) from DD correctly emulated by HHH cannot possibly return BECAUSE IT CALLS ITS OWN EMULATOR.

Which proves that HHH can't simulate itself, since the rest is the same.

I never said it that clearly ever before.

Maybe you should have.

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

Op 02.mrt.2025 om 23:28 schreef olcott:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was unable
to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

Counter factual. The exact same finite string in direct execution or
simulated by HHH1 shows that DD is perfectly able to reach its 'ret' instruction of the exact same input, because *HHH* cannot simulate itself.
It is *HHH* that fails to reach this 'ret' instruction.

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

Am Sun, 02 Mar 2025 19:21:39 -0600 schrieb olcott:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 5:28 PM, olcott wrote:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

In other words 'non terminating behavior' means that *HHH* was unable
to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator makes DD unable to
reach its own "ret" instruction.

No, it calls a specific emulator, that of a given HHH. There is no
requirement for the program DD to be emulated by that program.

THE FACT THAT DD DOES CALL ITS OWN EMULATOR
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION

DD reaches its return instruction.
But HHH can't simulate itself.

That I did not think of those words two years ago seems to make me a
moron about effective communication.

Yay for introspection!

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

Op 03.mrt.2025 om 02:21 schreef olcott:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 5:28 PM, olcott wrote:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was
unable to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

No, it calls a specific emulator, that of a given HHH. There is no
requirement for the program DD to be emulated by that program.

THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR

MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION

Shouting or repeating false claims do not make them true.

No, the fact that HHH tries to emulate itself makes HHH unable to reach
the 'ret' instruction, where other simulators or direct execution have
no problem to reach it, HHH gets stuck in simulating *itself*.

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

On 3/2/25 11:19 PM, olcott wrote:

On 3/2/2025 9:46 PM, Richard Damon wrote:

On 3/2/25 9:22 PM, olcott wrote:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 4:49 PM, olcott wrote:

On 3/2/2025 3:29 PM, Richard Damon wrote:

On 3/2/25 4:21 PM, olcott wrote:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

WHich only shows that HHH can not correctly emulate its input and
give an answer.

The fact that HHH does correctly determine that DD
emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally proves that your
claim is counter factual.

You say that, but it isn't true,

You keep trying to get away with saying that the
fact that DD calls its own emulator in recursive
emulation does not change the behavior from the
behavior of the directly executed DD.

AT THIS POINT THAT BECOMES VERY STUPIDLY WRONG.
SINCE WE KNOW THAT YOU ARE NOT THAT STUPID WHAT ELSE IS LEFT?

And you keep on making the claim without evidence!!!!


What instruction acted differently between the to, that was directly
executied and correctly emulated to different results.

The call to HHH(DD) from the directly executed DD returns
to DD. The call to HHH(DD) from DD correctly emulated by
HHH cannot possibly return BECAUSE IT CALLS ITS OWN EMULATOR.

I never said it that clearly ever before.

Except that isn't what it does, because a program can't do that. A
Program can't know if or by who it is being emulated or decided.

DD calls a copy of the DECIDER that claims to correctly decide it.

All copies of that DECIDER behave the same, so if the HHH(DD) that DD
calls gets stuck, so does your outer HHH(DD)

You have accepted that by failing to point out what exact step the
functions differed in behavior.

Sorry, you are just proving how stupid you are.

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

On 2025-03-02 21:21:04 +0000, olcott said:

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

_DD()
[00002133] 55 push ebp ; housekeeping
[00002134] 8bec mov ebp,esp ; housekeeping
[00002136] 51 push ecx ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404 add esp,+04
[00002144] 8945fc mov [ebp-04],eax
[00002147] 837dfc00 cmp dword [ebp-04],+00
[0000214b] 7402 jz 0000214f
[0000214d] ebfe jmp 0000214d
[0000214f] 8b45fc mov eax,[ebp-04]
[00002152] 8be5 mov esp,ebp
[00002154] 5d pop ebp
[00002155] c3 ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

DD does not fully specify a behaviour. The behaviour depends on HHH,
which is not a part of DD. If HHH returns 0 then DD specifies a non- terminatingg behaviour but that is a big if.

--
Mikko

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

Op 03.mrt.2025 om 15:13 schreef olcott:

On 3/3/2025 2:49 AM, Fred. Zwarts wrote:

Op 03.mrt.2025 om 02:21 schreef olcott:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 5:28 PM, olcott wrote:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was
unable to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

No, it calls a specific emulator, that of a given HHH. There is no
requirement for the program DD to be emulated by that program.

THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR

MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION

Shouting or repeating false claims do not make them true.

Richard said that he has ADD and he has proven that he only glances
at a couple of my words before contriving an incorrect rebuttal
on the basis of ignoring most of these words.

I have found that repeating these words in all caps helps
Richard to see these words for the first time.

No, the fact that HHH tries to emulate itself makes HHH unable to
reach the 'ret' instruction, where other simulators or direct
execution have no problem to reach it, HHH gets stuck in simulating
*itself*.

That your technical skills are insufficient to understand
the code that conclusively proves that HHH does emulate
itself emulating DD

I see no rebuttal, only a proof that Olcott has no idea about my
technical skills.
My technical skills are sufficient to see that HHH fails to reach the
'ret' instruction that the direct execution and other simulators have no problem to reach. So, this is a failure of HHH, not a property of DD.

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

Op 03.mrt.2025 om 15:08 schreef olcott:

On 3/3/2025 2:46 AM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 23:28 schreef olcott:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was
unable to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

Counter factual. The exact same finite string in direct execution or
simulated by HHH1 shows that DD is perfectly able to reach its 'ret'

Because neither of these cases has DD calling its own emulator.
Ignoring how this changes the behavior of DD is stupid.

Indeed, HHH is a simulator that cannot possibly simulate itself
correctly up to the end, so it fails when it attempts to simulate DD
that uses the same HHH. That is a problem for HHH, not of DD, because DD
is very well able to reach its 'ret' in direct execution or other
simulators. So, the finite string DD describes a halting program, but
HHH is unable to simulate it properly. The behaviour of a program
described by a finite string is completely defined by its direct
execution. A failing simulator does not change that.

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

On 3/3/25 9:02 AM, olcott wrote:

On 3/3/2025 2:24 AM, joes wrote:

Am Sun, 02 Mar 2025 22:19:48 -0600 schrieb olcott:

On 3/2/2025 9:46 PM, Richard Damon wrote:

On 3/2/25 9:22 PM, olcott wrote:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 4:49 PM, olcott wrote:

On 3/2/2025 3:29 PM, Richard Damon wrote:

On 3/2/25 4:21 PM, olcott wrote:

WHich only shows that HHH can not correctly emulate its input and >>>>>>>> give an answer.

The fact that HHH does correctly determine that DD emulated by HHH >>>>>>> cannot possibly reach its own "ret"
instruction and terminate normally proves that your claim is counter >>>>>>> factual.

You say that, but it isn't true,

You keep trying to get away with saying that the fact that DD calls
its own emulator in recursive emulation does not change the behavior >>>>> from the behavior of the directly executed DD.

Obviously. DD is fixed.

And you keep on making the claim without evidence!!!!
What instruction acted differently between the to, that was directly
executied and correctly emulated to different results.

The call to HHH(DD) from the directly executed DD returns to DD. The
call to HHH(DD) from DD correctly emulated by HHH cannot possibly return >>> BECAUSE IT CALLS ITS OWN EMULATOR.

Which proves that HHH can't simulate itself, since the rest is the same.

That your technical skills are insufficient to understand
the code that conclusively proves that HHH does emulate
itself emulating DD

https://github.com/plolcott/x86utm/blob/master/Halt7.c

Is far less than no rebuttal at all.

NO, it proves that HHH only PARTIALLY emulates itself.

Your don't seem to know the difference, because you don't seem to
understand what a correct emulation needs to be.

Of course, if you are willing to say that HHH does an INCORRECT
emulaiton of itself, we can agree, but that blows your theory out of the
water.

And the factd that is what it does, says your theory is at the bottom of
the lake.

I never said it that clearly ever before.

Maybe you should have.

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

Op 04.mrt.2025 om 01:31 schreef olcott:

On 3/3/2025 2:01 PM, Fred. Zwarts wrote:

Op 03.mrt.2025 om 15:08 schreef olcott:

On 3/3/2025 2:46 AM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 23:28 schreef olcott:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was
unable to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

Counter factual. The exact same finite string in direct execution or
simulated by HHH1 shows that DD is perfectly able to reach its 'ret'

Because neither of these cases has DD calling its own emulator.
Ignoring how this changes the behavior of DD is stupid.

Indeed, HHH is a simulator that cannot possibly simulate itself
correctly up to the end,

I repeatedly showed the failure of HHH to reach the 'ret' instruction of
the finite string that is its input, where the direct execution and
other simulators have no problem with exactly the same finite string to
reach this 'ret' instruction.

Olcott claims that HHH does not fail to reach this 'ret' instruction.


If this was not stupidly wrong you could show
all of the steps of DD correctly emulated by HHH
that reaches its own "ret" instruction.

You cannot do that because:
(a) You know that you are wrong
(b) You do not understand these things

I don't understand why Olcott keeps repeating the failure of HHH to
reach the 'ret' instruction.

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

Op 04.mrt.2025 om 00:44 schreef olcott:

On 3/3/2025 1:57 PM, Fred. Zwarts wrote:

Op 03.mrt.2025 om 15:13 schreef olcott:

On 3/3/2025 2:49 AM, Fred. Zwarts wrote:

Op 03.mrt.2025 om 02:21 schreef olcott:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 5:28 PM, olcott wrote:

On 3/2/2025 4:15 PM, Fred. Zwarts wrote:

Op 02.mrt.2025 om 22:21 schreef olcott:

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

_DD()
[00002133] 55         push ebp      ; housekeeping >>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

This process computes the mapping from the actual input
(not any other damn thing) finite string to the non
terminating behavior that this finite specifies when
it calls its own emulator in recursive emulation.

In other words 'non terminating behavior' means that *HHH* was >>>>>>>> unable to reach the 'ret' instruction.

Not at all. The fact that DD calls its own emulator
makes DD unable to reach its own "ret" instruction.

No, it calls a specific emulator, that of a given HHH. There is no >>>>>> requirement for the program DD to be emulated by that program.

THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR
THE FACT THAT DD DOES CALL ITS OWN EMULATOR

MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION
MAKES DD UNABLE TO REACH ITS OWN "ret" INSTRUCTION

Shouting or repeating false claims do not make them true.

Richard said that he has ADD and he has proven that he only glances
at a couple of my words before contriving an incorrect rebuttal
on the basis of ignoring most of these words.

I have found that repeating these words in all caps helps
Richard to see these words for the first time.

No, the fact that HHH tries to emulate itself makes HHH unable to
reach the 'ret' instruction, where other simulators or direct
execution have no problem to reach it, HHH gets stuck in simulating
*itself*.

That your technical skills are insufficient to understand
the code that conclusively proves that HHH does emulate
itself emulating DD

I see no rebuttal, only a proof that Olcott has no idea about my
technical skills.

My technical skills are sufficient to see that HHH fails to reach the
'ret' instruction that the direct execution and other simulators have
no problem to reach. So, this is a failure of HHH, not a property of DD.

The only valid rebuttal is to show all of the steps of DD
correctly emulated by HHH that reaches its own "ret" instruction.

HHH fails to reach the 'ret' instruction, where the direct execution and
other simulators have no problem with exactly the same finite string as
input, to reach the 'ret' instruction.

The only rebuttal for this failure of HHH is to show that HHH correctly
reaches the 'ret' instruction.

You cannot do that because:
(a) You know that you are wrong
(b) You do not understand these things

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

On 2025-03-03 18:33:52 +0000, olcott said:

On 3/3/2025 8:44 AM, Mikko wrote:

On 2025-03-02 21:21:04 +0000, olcott said:

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

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

DD does not fully specify a behaviour. The behaviour depends on HHH,
which is not a part of DD. If HHH returns 0 then DD specifies a non-
terminatingg behaviour but that is a big if.

A stipulated premise is that HHH emulates its input.

Sometimes, though it iw never stipulated that that emulation be complete.
At other times you have assumed that HHH is as shown at https://github.com/plolcott/x86utm/blob/master/Halt7.c .

This is proven by the actual code that no one here
understands.

No, the code does not prove the stipulation (or anything).

--
Mikko

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