Am Sun, 02 Mar 2025 08:42:03 -0600 schrieb olcott:

I challenged everyone here to provide the machine address by machine
address (AKA line by line) execution trace of DD correctly emulated by
HHH that reaches its own "ret" instruction.
No one made any attempt to do this because they know that this would
prove that they are stupidly wrong to say that my trace is incorrect.

I did, on thursday at 9pm UTC.

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

Am Sun, 02 Mar 2025 09:51:56 -0600 schrieb olcott:

On 3/2/2025 8:55 AM, joes wrote:

Am Sun, 02 Mar 2025 08:42:03 -0600 schrieb olcott:

I challenged everyone here to provide the machine address by machine
address (AKA line by line) execution trace of DD correctly emulated by
HHH that reaches its own "ret" instruction.
No one made any attempt to do this because they know that this would
prove that they are stupidly wrong to say that my trace is incorrect.

I did, on thursday at 9pm UTC.

I am asking for a sequence of 10 hexadecimal integer machine addresses
of DD correctly emulated by HHH.

See that post.

At machine address 0000213c HHH emulates itself emulating DD.

Yeah, it simulates HHH, not DD.

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

Am Sun, 02 Mar 2025 10:48:06 -0600 schrieb olcott:

On 3/2/2025 10:22 AM, joes wrote:

Am Sun, 02 Mar 2025 09:51:56 -0600 schrieb olcott:

On 3/2/2025 8:55 AM, joes wrote:

Am Sun, 02 Mar 2025 08:42:03 -0600 schrieb olcott:

I challenged everyone here to provide the machine address by machine >>>>> address (AKA line by line) execution trace of DD correctly emulated
by HHH that reaches its own "ret" instruction.
No one made any attempt to do this because they know that this would >>>>> prove that they are stupidly wrong to say that my trace is
incorrect.

I did, on thursday at 9pm UTC.

I am asking for a sequence of 10 hexadecimal integer machine addresses
of DD correctly emulated by HHH.

See that post.

Do you not know what a hexadecimal integer machine address is?

Are you a compiler?

On 2/27/2025 3:00 PM, joes wrote:

Anyway: ignoring the call to HHH, because it doesn't call DD in turn,

Is counterfactual The actual HHH does emulate itself emulating DD as a
100% totally verified fact.

Calling != simulating. And you only wanted the instructions of DD.

we continue with 2141 until the conditional jump, whereupon we either enter an infinite loop (which is more than 15 instructions) or
proceed to return (which is 13 instructions), depending on the return value of HHH.

There you go.

--
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 15:42 schreef olcott:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

Olcott could as well challenge everyone to draw a correct square circle.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

No one will attempt to draw a square circle. Does that imply that it is
wrong to say that another failed attempt to draw a square circle is
incorrect?

Similarly, HHH cannot possibly simulate itself correctly. Olcott's HHH
is incorrect, but a correct HHH that simulates itself does not exist. Therefore, it is very stupid to challenge everyone to correct HHH.

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

Op 02.mrt.2025 om 16:51 schreef olcott:

On 3/2/2025 8:55 AM, joes wrote:

Am Sun, 02 Mar 2025 08:42:03 -0600 schrieb olcott:

I challenged everyone here to provide the machine address by machine
address (AKA line by line) execution trace of DD correctly emulated by
HHH that reaches its own "ret" instruction.
No one made any attempt to do this because they know that this would
prove that they are stupidly wrong to say that my trace is incorrect.

I did, on thursday at 9pm UTC.

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

I am asking for a sequence of 10 hexadecimal integer
machine addresses of DD correctly emulated by HHH.

At machine address 0000213c HHH emulates itself
emulating DD. (As an anyone would know that knows
what an x86 emulator is).

We use Olcott's statement that HHH returns 0.
Then the sequence would be:
00002133, 00002134, 00002136, 00002137, 0000213c, 00002141, 00002144,
00002147, 0000214b, 0000214f, 00002152, 00002154, 00002155.

This correct trace is also found by the simulation by HHH1.
Unfortunately, HHH cannot possibly perform this correct simulation,
because HHH cannot possibly simulate itself correctly up to the end.

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

Op 02.mrt.2025 om 20:06 schreef olcott:

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

Op 02.mrt.2025 om 15:42 schreef olcott:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

Olcott could as well challenge everyone to draw a correct square circle.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

No one will attempt to draw a square circle. Does that imply that it
is wrong to say that another failed attempt to draw a square circle is
incorrect?

Similarly, HHH cannot possibly simulate itself correctly.

This C code conclusively proves that HHH does correctly
emulate self emulating DD correctly. https://github.com/plolcott/x86utm/blob/master/Halt7.c

I think we can agree on the following:
It is clear that this HHH cannot possibly reach the 'ret' instruction of
DD in the finite string that (when given for direct execution, or to
another simulator, like HHH1) has been proven to reach the 'ret'
instruction without problem.
So, we can agree that HHH correctly reports that this DD is not
computable for HHH. (I.e., that a correct simulation cannot be done by HHH.)

Well done! Olcott has been able to construct a simulator that reports
for certain inputs that it cannot possibly do the computation.
We agree that DD is not computable for HHH. What is the next step of the
proof?

Face it.
There is a finite string DD that
1) When given for direct execution reaches its 'ret' instruction.
(Computable by direct execution.)
2) When given to many simulators (including HHH1) reaches its 'ret' instruction. (Computable by these simulators.)
3) When given to a yellow carrot does not even start to run. (Not
computable by a yellow carrot.)
4) When given to HHH starts, but does not reach its 'ret' instruction.
(Not computable by HHH.)

Since Olcott already admitted that DD reaches the 'ret' instruction in
the direct execution and the simulation by HHH1 we reached complete
agreement. HHH is correct to report that DD is not computable by HHH.
What is the next step of the proof?

That you lack the technical capability to understand
that code is far less than no actual rebuttal at all.

Irrelevant remark, showing Olcott's lack of knowledge of my technical capabilities.

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

Am Sun, 02 Mar 2025 11:04:51 -0600 schrieb olcott:

On 2/27/2025 3:00 PM, joes wrote:

Am Thu, 27 Feb 2025 13:06:41 -0600 schrieb olcott:

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

Op 27.feb.2025 om 05:40 schreef olcott:

On 2/26/2025 9:52 AM, joes wrote:

Am Wed, 26 Feb 2025 08:49:42 -0600 schrieb olcott:

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

Op 26.feb.2025 om 05:50 schreef olcott:

On 2/25/2025 10:21 PM, Richard Damon wrote:

You already know that you are stupidly wrong about the emulation >>>>>>>>> being incorrect or you would have provided the correct emulation >>>>>>>>> sequence long ago.
What are the first 15 lines of DD correctly emulated by HHH?

The error in the simulation occurs already at the 5th
instruction,
the 'call 000015c3'. Instead of simulating this instruction,

What are the correct first 15 lines of DD emulated by HHH.

There can be no correct continuation.

If I am wrong then a correct simulation must exist.

HHH1 did a correct simulation, so, there it is.

That dishonestly dodged the original question:
What are the first 15 *lines of DD* correctly emulated by HHH?

Look at what HHH1 does.

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

Anyway: ignoring the call to HHH

It moronically stupid unless HHH ignores this call and HHH does not
ignore this call.

You didn't ask for the trace of HHH.

What are the hexadecimal machine addresses of the first 10 lines of DD correctly emulated by HHH?
A failure to answer that question with ten hexadecimal values proves
that the reviewer is either dishonest or clueless.

Or lazy.
See below.

because it doesn't call DD in turn,
we continue with 2141 until the conditional jump, whereupon we either
enter an infinite loop (which is more than 15 instructions)
or proceed to return (which is 13 instructions), depending on the
return value of HHH.

--
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 3/2/25 9:42 AM, olcott wrote:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

But the pattern isn't "non-terminatingf", as the actual correct
emulation of the exact DD that HHH is saying is non-terminating will
terminate.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

The problem is that the HHH that does to the cprrect emulation never
will abort its emulation to answer, and thus fails to be a decider.

Your challenge fails on the basis that it is based on the presumption of
a false statement, that there CAN be an HHH that both correctly emulates
the input and is a decider.

Correct emulation is correct emulation regardless of who does it for any
actual programs, and thus the correct emulation by your HHH1, that
reaches the final state is the proof that your claim is just a blatant lie.

If the "correct emulation" by HHH for this exact input difered, then you
could show the first instruction in these two emulation where the
difference occurs.

Note, to even make the claim that you can emulate DD, we need to correct
your input to include *ALL* of the code for the PROGRAM DD, which
includes the code for the HHH that you claim is giving the correct
answer (and thus doesn't change when we examine it by some other
decider, even another hypothetical version of HHH).

Without that correction, you problem just fails as it is impossible to correctly emulate that which isn't provided, so if the code for HHH
isn't provided, it can't be emulated.

If you want to try to get away with your HHH is just described as an
emulator, then that needs to be what HHH actually is, and that needs to
FULLY describe its behavior. If you then try to "augement" by saying it
aborts it emulation, you need to START with that behaivor, and if HHH is
know to abort its emulation of DD and returns 0, then it is clear tht
hte correct emulation of DD is to halt.

Your attempt to LIE about HHH being two different programs, one the
decider that aborts, and one the "ideal" emulator that doesnt just
proves that your logic accepts lies as true and is thus itself just a lie.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

The fact that *YOU* have failed to show where the correct emulation of
this exact input by HHH1 first differs from the partial emulation by HHH
at the actual emulation of an instrucion, is just an admittion by your
that you KNOW your claims are false, and that you are just trying to
bluff your way, just proving that you are nothing but a flat out blatant
liar, who may be so stupid he doesn't understand how stupid he is to
insist on things that are clearly fals.\e.

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

On 2025-03-02 14:42:03 +0000, olcott said:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

Wrong conclusion. That sometthing is not proven only means it is unproeven.
It may be correct, it may be incorrect. Without a proof we can only say
that you claim more than you know.

--
Mikko

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

On 2025-03-02 19:06:52 +0000, olcott said:

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

Op 02.mrt.2025 om 15:42 schreef olcott:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

Olcott could as well challenge everyone to draw a correct square circle.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

No one will attempt to draw a square circle. Does that imply that it is
wrong to say that another failed attempt to draw a square circle is
incorrect?

Similarly, HHH cannot possibly simulate itself correctly.

This C code conclusively proves that HHH does correctly
emulate self emulating DD correctly. https://github.com/plolcott/x86utm/blob/master/Halt7.c

A C code does not prove. Only a proof would prove.

--
Mikko

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

Am Mon, 03 Mar 2025 13:46:30 -0600 schrieb olcott:

On 3/3/2025 6:46 AM, Mikko wrote:

On 2025-03-02 19:06:52 +0000, olcott said:

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

Op 02.mrt.2025 om 15:42 schreef olcott:

HHH is an emulating termination analyzer that emulates the x86
machine code located at the address of a function using a fully
functional x86 emulator.
When HHH recognizes a non-terminating pattern in the execution trace >>>>> of its emulated input it aborts this emulation and returns 0.
I challenged everyone here to provide the machine address by machine >>>>> address (AKA line by line) execution trace of DD correctly emulated
by HHH that reaches its own "ret" instruction.

Olcott could as well challenge everyone to draw a correct square
circle.

No one made any attempt to do this because they know that this would >>>>> prove that they are stupidly wrong to say that my trace is
incorrect.

No one will attempt to draw a square circle. Does that imply that it
is wrong to say that another failed attempt to draw a square circle
is incorrect?
Similarly, HHH cannot possibly simulate itself correctly.

This C code conclusively proves that HHH does correctly emulate self
emulating DD correctly.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

A C code does not prove. Only a proof would prove.

The C code proves exactly these things. https://github.com/plolcott/x86utm/blob/master/Halt7.c The above code
proves that:
(a) HHH correctly emulates itself emulating DD.

No, it simulates HHH1 simulating DD.

(b) DD correctly emulated by HHH cannot possibly reach its own "ret" instruction and terminate normally.
(c) The behavior of the input to HHH(DD) is different than the behavior
of the directly executed DD

Then DD is not the input.

because DD calls HHH(DD) in recursive
emulation and the directly executed DD does not call HHH(DD) in
recursive emulation.

The other way around.

This code proves that it reports integers > 5
void GT5(int X)
{
if (X > 5)
printf("X is greater than five\n");
}

This code proves nothing (although it does "report integers >5").

--
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 3/3/25 2:46 PM, olcott wrote:

On 3/3/2025 6:46 AM, Mikko wrote:

On 2025-03-02 19:06:52 +0000, olcott said:

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

Op 02.mrt.2025 om 15:42 schreef olcott:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

Olcott could as well challenge everyone to draw a correct square
circle.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

No one will attempt to draw a square circle. Does that imply that it
is wrong to say that another failed attempt to draw a square circle
is incorrect?

Similarly, HHH cannot possibly simulate itself correctly.

This C code conclusively proves that HHH does correctly
emulate self emulating DD correctly.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

A C code does not prove. Only a proof would prove.

The C code proves exactly these things.
That you can't even understand that it does prove
those things shows even less technical competence.

The C code proves that HHH will abort its emulation, and thus is not a
correct emulator

https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that:
(a) HHH correctly emulates itself emulating DD.

No, it doesn't, it aborts

(b) DD correctly emulated by HHH cannot possibly
reach its own "ret" instruction and terminate normally.

Since you HHH doesn't do that, it isn't shown by that code.

The fact that a DIFFERENT program DD calling a DIFFERENT HHH will never
return is irrelvent, as that different HHH fails to decider.

(c) The behavior of the input to HHH(DD) is different
than the behavior of the directly executed DD because
DD calls HHH(DD) in recursive emulation and the directly
executed DD does not call HHH(DD) in recursive emulation.

And where is that difference? You have implicitly admited this is a lie, because you can't show the first instruction actually emulated where the difference occurs.

Your problem is your claim is based on unsupporeted (and unsupportable)
lies and make-beleive.

All you are doing is proving you are just a pathological lying idiot
that doesn't care about the truth.

This code proves that it reports integers > 5

void GT5(int X)
{
  if (X > 5)
    printf("X is greater than five\n");
}

Irrelevent.

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

On 2025-03-03 19:46:30 +0000, olcott said:

On 3/3/2025 6:46 AM, Mikko wrote:

On 2025-03-02 19:06:52 +0000, olcott said:

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

Op 02.mrt.2025 om 15:42 schreef olcott:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

Olcott could as well challenge everyone to draw a correct square circle. >>>>

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

No one will attempt to draw a square circle. Does that imply that it is >>>> wrong to say that another failed attempt to draw a square circle is
incorrect?

Similarly, HHH cannot possibly simulate itself correctly.

This C code conclusively proves that HHH does correctly
emulate self emulating DD correctly.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

A C code does not prove. Only a proof would prove.

The C code proves exactly these things.

No, it does not. That you can insist that it would indicates that
you don't know what the word means.

That you can't even understand that it does prove
those things shows even less technical competence.

One doesn't need much techincal competence to tell the difference
between a C code and a proof.

--
Mikko

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

On 2025-03-03 19:42:16 +0000, olcott said:

On 3/3/2025 6:42 AM, Mikko wrote:

On 2025-03-02 14:42:03 +0000, olcott said:

HHH is an emulating termination analyzer that emulates
the x86 machine code located at the address of a function
using a fully functional x86 emulator.

When HHH recognizes a non-terminating pattern in the
execution trace of its emulated input it aborts this
emulation and returns 0.

typedef void (*ptr)();
int HHH(ptr P);

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]

I challenged everyone here to provide the machine address
by machine address (AKA line by line) execution trace
of DD correctly emulated by HHH that reaches its own
"ret" instruction.

No one made any attempt to do this because they know that
this would prove that they are stupidly wrong to say that
my trace is incorrect.

Wrong conclusion. That sometthing is not proven only means it is unproeven. >> It may be correct, it may be incorrect. Without a proof we can only say
that you claim more than you know.

That you do not understand this code is much less
than no rebuttal at all.

Your last paragraph is so obviously wrong that I don't think any repbuttal
is needed.

--
Mikko

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