From Newsgroup: comp.lang.c

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination analyzer
because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern* https://github.com/plolcott/x86utm/blob/master/Halt7.c
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 09/08/2025 14:08, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination
analyzer because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
 Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern* https://github.com/plolcott/x86utm/blob/master/Halt7.c

If HHH doesn't have to report because its u32 needs to be
aborted, you can simplify the code immeasurably.

int HHH(ptr P)
{
assert(false); /* job done, but it proves NOTHING. */
}

Unless HHH reports, it's worthless.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

[comp.theory trimmed]

On 09/08/2025 14:14, Richard Heathfield wrote:

On 09/08/2025 14:08, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

<snip>

Keith et al

I promised to stop doing this, didn't I?

Well, I plonked olcott in this group and thought no more about it...

...but forgot about cross-posts, and was caught napping. Sorry.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 8/9/2025 8:14 AM, Richard Heathfield wrote:

On 09/08/2025 14:08, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination analyzer
because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
  Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

If HHH doesn't have to report because its u32 needs to be aborted, you
can simplify the code immeasurably.

*That return value is passed back to line 1143 of HHH*

if (Decide_Halting_HH(&Aborted, &execution_trace, &decoded,
code_end, End_Of_Code, &master_state,
&slave_state, &slave_stack, Root))
goto END_OF_CODE;
*Aborted = 0x90909090; // deprecated
*execution_trace = 0x90909090;
return 0; // Does not halt
END_OF_CODE:
*Aborted = 0x90909090; // deprecated
*execution_trace = 0x90909090;
return 1; // Input has normally terminated
}
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 09/08/2025 15:02, olcott wrote:

On 8/9/2025 8:14 AM, Richard Heathfield wrote:

On 09/08/2025 14:08, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination
analyzer because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
  Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

If HHH doesn't have to report because its u32 needs to be
aborted, you can simplify the code immeasurably.

*That return value is passed back to line 1143 of HHH*

  if (Decide_Halting_HH(&Aborted, &execution_trace, &decoded,
                        code_end, End_Of_Code, &master_state,
                        &slave_state, &slave_stack, Root))
      goto END_OF_CODE;
  *Aborted         = 0x90909090; // deprecated
  *execution_trace = 0x90909090;
  return 0;  // Does not halt
END_OF_CODE:
  *Aborted         = 0x90909090; // deprecated
  *execution_trace = 0x90909090;
  return 1; // Input has normally terminated
}

So HHH /does/ return... with the wrong answer, a la Turing. QED.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 8/9/2025 9:11 AM, Richard Heathfield wrote:

On 09/08/2025 15:02, olcott wrote:

On 8/9/2025 8:14 AM, Richard Heathfield wrote:

On 09/08/2025 14:08, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination analyzer
because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
  Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

If HHH doesn't have to report because its u32 needs to be aborted,
you can simplify the code immeasurably.

*That return value is passed back to line 1143 of HHH*

   if (Decide_Halting_HH(&Aborted, &execution_trace, &decoded,
                         code_end, End_Of_Code, &master_state,
                         &slave_state, &slave_stack, Root))
       goto END_OF_CODE;
   *Aborted         = 0x90909090; // deprecated
   *execution_trace = 0x90909090;
   return 0;  // Does not halt
END_OF_CODE:
   *Aborted         = 0x90909090; // deprecated
   *execution_trace = 0x90909090;
   return 1; // Input has normally terminated
}

So HHH /does/ return... with the wrong answer, a la Turing. QED.

*It is only the wrong answer to the wrong problem*
Asking HHH to report on the behavior of the directly
executed DD() is like asking sum(3,5) to report on
the sum of 7 + 2.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 8/9/25 9:08 AM, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination analyzer
because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
 Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern* https://github.com/plolcott/x86utm/blob/master/Halt7.c

Which has been proven to be incorrect, as the input program CAN be
correctly simuated without aborting, since this funciton erroneously
tells HHH to abort its simulation.

And, changing this code to not do that, changes the input.

That is a fundamental problem with our argument, you are stuck in a
category error as the ACTUAL input changes when you change the code for
the decider, since the program of the input uses it, and thus that code
is part of the program of the input, and thus needs to be present to
allow for correct simulation.

All you are doing is proving that you don't understand what you are
talking about, or even how logic works.

Sorry, you are just proving how ignorant you are of the rules and
definitions of the system, that you are too stupid to learn those
definitions, and just don't care that you are saying things that are
wrong, which just makes you a pathological liar.

IF you don't like the definition, create a new system and see if anyone
wants to use it, you don't get to change them in the system.

That is why ZFC isn't in Naive Set Theory.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 8/9/25 10:16 AM, olcott wrote:

On 8/9/2025 9:11 AM, Richard Heathfield wrote:

On 09/08/2025 15:02, olcott wrote:

On 8/9/2025 8:14 AM, Richard Heathfield wrote:

On 09/08/2025 14:08, olcott wrote:

On 8/9/2025 12:31 AM, Richard Heathfield wrote:

On 09/08/2025 06:27, olcott wrote:

It is impossible to show how DD correctly simulated
by HHH can possibly reach its own emulated "ret"
instruction

So HHH never returns, so it fails to act as a termination analyzer >>>>>> because it fails to report its finding.

u32 Needs_To_Be_Aborted_Trace_HH
(Decoded_Line_Of_Code* execution_trace,
  Decoded_Line_Of_Code *current);

Line 996 matches the
*recursive simulation non-halting behavior pattern*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

If HHH doesn't have to report because its u32 needs to be aborted,
you can simplify the code immeasurably.

*That return value is passed back to line 1143 of HHH*

   if (Decide_Halting_HH(&Aborted, &execution_trace, &decoded,
                         code_end, End_Of_Code, &master_state,
                         &slave_state, &slave_stack, Root))
       goto END_OF_CODE;
   *Aborted         = 0x90909090; // deprecated
   *execution_trace = 0x90909090;
   return 0;  // Does not halt
END_OF_CODE:
   *Aborted         = 0x90909090; // deprecated
   *execution_trace = 0x90909090;
   return 1; // Input has normally terminated
}

So HHH /does/ return... with the wrong answer, a la Turing. QED.

*It is only the wrong answer to the wrong problem*
Asking HHH to report on the behavior of the directly
executed DD() is like asking sum(3,5) to report on
the sum of 7 + 2.

No, it is YOU that has the wrong problem, as the Halting Problem is
DEFINED by looking at the direct behavior of the program represented in
the input.

Since you representation isn't even of a program, you are just lost in a category error, showing just how stupid you are.
--- Synchronet 3.21a-Linux NewsLink 1.2