The problem is not C, and nobody needs to lie about it.
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
as "DD" and "HHH" could be referring to:
* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary set
of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by [algorithm|C function|finite string] HHH ever reach its own "return"
statement while [algorithm|C function|finite string] DD is beingsimulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above, pick
one and give the resulting sentence.
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary set
of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by [algorithm|C function|finite string] HHH ever reach its own "return"
statement while [algorithm|C function|finite string] DD is beingsimulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above, pick
one and give the resulting sentence.
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary
set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return"
statement while [algorithm|C function|finite string] DD is beingsimulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary
set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function
HHH ever reach its own "return" statement
while C function DD is being simulated by
C function HHH?
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return"
statement while [algorithm|C function|finite string] DD is beingsimulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be referring to: >>>>
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of instructions that
always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary
set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Does there exist a finite number of N simulations that C function HHHfunction HHH reaches its own
can be modified to perform such that C function DD simulated by C
simulated "return" statement while C function DD is being
simulated by C function HHH?
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return"
statement while [algorithm|C function|finite string] DD is beingsimulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be referring >>>>> to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of instructions
that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary >>>>> set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that C function HHHfunction HHH reaches its own
can be modified to perform such that C function DD simulated by C
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return" >>>>> ˙> statement while [algorithm|C function|finite string] DD is being >>>>> simulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
referring to:
* an algorithm, i.e. a fixed immutable sequence of instructions
that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any
arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above >>>>>> sentence refers to an algorithm, a C function, or a finite string. >>>>>>
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that C function HHHfunction HHH reaches its own
can be modified to perform such that C function DD simulated by C
simulated "return" statement while C function DD is being
simulated by C function HHH?
A direct deflection away from the actual point.
Yes?
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return" >>>>>> ˙> statement while [algorithm|C function|finite string] DD is
being simulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above, >>>>>> pick one and give the resulting sentence.
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be referring >>>>> to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of instructions
that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any arbitrary >>>>> set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above
sentence refers to an algorithm, a C function, or a finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that C function HHHfunction HHH reaches its own
can be modified to perform such that C function DD simulated by C
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return" >>>>> ˙> statement while [algorithm|C function|finite string] DD is being >>>>> simulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
referring to:
* an algorithm, i.e. a fixed immutable sequence of instructions
that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any
arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above >>>>>> sentence refers to an algorithm, a C function, or a finite string. >>>>>>
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that C function HHHfunction HHH reaches its own
can be modified to perform such that C function DD simulated by C
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] HHHthat simulates [algorithm|C function|finite string] DD according
to the operational semantics of the C programming languagereaches its own simulated
such that the simulated [algorithm|C function|finite string] DD
return statement in any N finite number of simulations.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own "return" >>>>>> ˙> statement while [algorithm|C function|finite string] DD is
being simulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]" above, >>>>>> pick one and give the resulting sentence.
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
referring to:
* an algorithm, i.e. a fixed immutable sequence of instructions >>>>>>> that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any
arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the
starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the above >>>>>>> sentence refers to an algorithm, a C function, or a finite string. >>>>>>>
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own
"return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that C function HHH >>> ˙> can be modified to perform such that C function DD simulated by Cfunction HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] HHHthat simulates [algorithm|C function|finite string] DD according
to the operational semantics of the C programming languagereaches its own simulated
such that the simulated [algorithm|C function|finite string] DD
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
Then we can discuss whether that statement is correct.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own
"return"
statement while [algorithm|C function|finite string] DD isbeing simulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]"
above, pick one and give the resulting sentence.
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
referring to:
* an algorithm, i.e. a fixed immutable sequence of instructions >>>>>>>> that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any
arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the >>>>>>>> starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the
above sentence refers to an algorithm, a C function, or a finite >>>>>>>> string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own >>>>>> "return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that C functionHHH
can be modified to perform such that C function DD simulated by Cfunction HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] HHHthat simulates [algorithm|C function|finite string] DD according
to the operational semantics of the C programming languagereaches its own simulated
such that the simulated [algorithm|C function|finite string] DD
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Then we can discuss whether that statement is correct.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by[algorithm| C function|finite string] HHH ever reach its own
"return"
statement while [algorithm|C function|finite string] DD is >>>>>>>> being simulated by [algorithm|C function|finite string] HHH?
For each instance of "[algorithm|C function|finite string]"
above, pick one and give the resulting sentence.
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
referring to:
* an algorithm, i.e. a fixed immutable sequence of instructions >>>>>>>>> that always generates the same output for a given input.
* a C function, i.e. a named address that can contain any
arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the >>>>>>>>> starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>> above sentence refers to an algorithm, a C function, or a
finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its own >>>>>>> "return" statement while C function DD is being simulated by C
function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that Cfunction HHH
can be modified to perform such that C function DD simulated byC function HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] HHHthat simulates [algorithm|C function|finite string] DD according
to the operational semantics of the C programming languagereaches its own simulated
such that the simulated [algorithm|C function|finite string] DD
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Then we can discuss whether that statement is correct.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by >>>>>>>>> [algorithm| C function|finite string] HHH ever reach its own >>>>>>>>> "return"For each instance of "[algorithm|C function|finite string]" >>>>>>>>> above, pick one and give the resulting sentence.
statement while [algorithm|C function|finite string] DD is >>>>>>>>> being simulated by [algorithm|C function|finite string] HHH? >>>>>>>>>
I am not erasing the context.You just did and I am doing this to you
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.You just did and I am doing this to you
so you can see what I mean.
You must keep the quoted words that you
are responding to. If you don't do this
then it is too easy to cheat and respond
to a bad paraphrase of my words instead
of the actual words that I actually said.
I am not erasing the context.
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03 int Halt_Status = HHH(DD);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a given >>>>>>>>>> input.
* a C function, i.e. a named address that can contain any >>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is the >>>>>>>>>> starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>> own "return" statement while C function DD is being simulated by >>>>>>>> C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications:
Does there exist a finite number of N simulations that Cfunction HHH
can be modified to perform such that C function DD simulated by >>>>>> C function HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] HHHthat simulates [algorithm|C function|finite string] DD according
to the operational semantics of the C programming languagereaches its own simulated
such that the simulated [algorithm|C function|finite string] DD
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Then we can discuss whether that statement is correct.
To make the request for clarification more explicit:
Does [algorithm|C function|finite string] DD simulated by >>>>>>>>>> [algorithm| C function|finite string] HHH ever reach its own >>>>>>>>>> "return"For each instance of "[algorithm|C function|finite string]" >>>>>>>>>> above, pick one and give the resulting sentence.
statement while [algorithm|C function|finite string] DD is >>>>>>>>>> being simulated by [algorithm|C function|finite string] HHH? >>>>>>>>>>
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
and u _still_ haven't explain wtf this has to do with the halting theorum
Le 01/11/2026 … 21:59, olcott a ‚crit :
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
NO.
There is NO such finite N, PROVIDED you assume that at every one of
those N levels the nested HHH call continues the simulation instead of returning.
That is trivial.
On 11/1/2026 3:03 PM, Python wrote:
Le 01/11/2026 … 21:59, olcott a ‚crit :
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
NO.
There is NO such finite N, PROVIDED you assume that at every one of
those N levels the nested HHH call continues the simulation instead of
returning.
That is trivial.
Then why did it take you a dozen or more exchanges
to pay enough attention to finally acknowledge this
self-evident truth?
On 11/1/2026 3:44 PM, olcott wrote:
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>
Does there exist a finite number of N simulations that Cfunction HHH
can be modified to perform such that C function DD simulated >>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string]HHH that simulates [algorithm|C function|finite string] DD according >>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] DDreaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
Le 01/11/2026 … 22:17, olcott a ‚crit :
On 11/1/2026 3:03 PM, Python wrote:
Le 01/11/2026 … 21:59, olcott a ‚crit :
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
NO.
There is NO such finite N, PROVIDED you assume that at every one of
those N levels the nested HHH call continues the simulation instead
of returning.
That is trivial.
Then why did it take you a dozen or more exchanges
to pay enough attention to finally acknowledge this
self-evident truth?
Because that is NOT the proposition I spent those exchanges disputing.
I have repeatedly agreed that:
˙˙ IF every nested HHH continues simulating instead of returning,
˙˙ then no finite nesting depth reaches DD's return.
What I have repeatedly REJECTED is your next step:
˙˙ therefore no nested HHH can ever return,
˙˙ therefore the recursion is infinite,
˙˙ therefore DD cannot halt.
You finally asked the first proposition explicitly, with the quantifier
over finite N, and I answered NO immediately.
So don't do exactly what I warned you about:
˙˙ I agreed with A.
˙˙ You believe A => B.
˙˙ Therefore you announce that I finally "acknowledged" B.
I acknowledged A.
I still reject B.
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
and u _still_ haven't explain wtf this has to do with the halting theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
On 11/1/2026 3:20 PM, Python wrote:
Le 01/11/2026 … 22:17, olcott a ‚crit :
On 11/1/2026 3:03 PM, Python wrote:
Le 01/11/2026 … 21:59, olcott a ‚crit :
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
NO.
There is NO such finite N, PROVIDED you assume that at every one of
those N levels the nested HHH call continues the simulation instead
of returning.
That is trivial.
Then why did it take you a dozen or more exchanges
to pay enough attention to finally acknowledge this
self-evident truth?
Because that is NOT the proposition I spent those exchanges disputing.
I have repeatedly agreed that:
˙˙ IF every nested HHH continues simulating instead of returning,
˙˙ then no finite nesting depth reaches DD's return.
The mathematical induction proof of non-termination takes
the simulation invariant of
DD simulated by HHH does not halt while being simulated
as formal proof of non-termination of DD while DD is being
simulated by HHH.
I can show how this refutes the halting theorem with
more steps of my proof that has the above as their
foundation.
On 11/1/2026 3:44 PM, olcott wrote:
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>
Does there exist a finite number of N simulations that Cfunction HHH
can be modified to perform such that C function DD simulated >>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string]HHH that simulates [algorithm|C function|finite string] DD according >>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] DDreaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above,
pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
and u _still_ haven't explain wtf this has to do with the halting
theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u
explain wtf this has to do with the halting theorem???
On 11/1/2026 3:04 PM, dbush wrote:
On 11/1/2026 3:44 PM, olcott wrote:
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question: >>>>>>>>>>>>>
Does DD simulated by HHH ever reach its own "return" >>>>>>>>>>>>> statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>>
Does there exist a finite number of N simulations that Cfunction HHH
can be modified to perform such that C function DD simulated >>>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string]HHH that simulates [algorithm|C function|finite string] DD according >>>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] DD >>>>>> reaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above, >>>>>> pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
So within today's exchanges you have been very helpful.
You forced me to make my words completely clear. That
is exactly the kind of feedback that I have been looking
for all along. Thanks again. I updated by published proof
with these better words.
On 11/1/2026 3:31 PM, dart200 wrote:
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
either one works.
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
Great. It has taken quite a few years to get
agreement on this one single point. I had to
make my words much more clear to do this.
and u _still_ haven't explain wtf this has to do with the halting
theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u
explain wtf this has to do with the halting theorem? ? ?
This is the next step:
The mathematical induction proof of non-termination takes
the simulation invariant of
DD simulated by HHH does not halt while being simulated
as formal proof of non-termination of DD while DD is being
simulated by HHH.
Le 01/11/2026 … 22:30, olcott a ‚crit :
On 11/1/2026 3:20 PM, Python wrote:
Le 01/11/2026 … 22:17, olcott a ‚crit :
On 11/1/2026 3:03 PM, Python wrote:
Le 01/11/2026 … 21:59, olcott a ‚crit :
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
NO.
There is NO such finite N, PROVIDED you assume that at every one of >>>>> those N levels the nested HHH call continues the simulation instead >>>>> of returning.
That is trivial.
Then why did it take you a dozen or more exchanges
to pay enough attention to finally acknowledge this
self-evident truth?
Because that is NOT the proposition I spent those exchanges disputing.
I have repeatedly agreed that:
˙˙˙ IF every nested HHH continues simulating instead of returning,
˙˙˙ then no finite nesting depth reaches DD's return.
The mathematical induction proof of non-termination takes
the simulation invariant of
DD simulated by HHH does not halt while being simulated
as formal proof of non-termination of DD while DD is being
simulated by HHH.
I can show how this refutes the halting theorem with
more steps of my proof that has the above as their
foundation.
No, Peter. Calling it a "simulation invariant" does not prove it.
Le 01/11/2026 … 22:42, olcott a ‚crit :
On 11/1/2026 3:04 PM, dbush wrote:
On 11/1/2026 3:44 PM, olcott wrote:
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question: >>>>>>>>>>>>>>
Does DD simulated by HHH ever reach its own "return" >>>>>>>>>>>>>> statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>>>
Does there exist a finite number of N simulations that C >>>>>>>>> function HHH
can be modified to perform such that C function DD simulated >>>>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being >>>>>>>>> ˙> simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] >>>>>>> HHH that simulates [algorithm|C function|finite string] DD according >>>>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] >>>>>>> DD reaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above, >>>>>>> pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH that >>>>> simulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
So within today's exchanges you have been very helpful.
You forced me to make my words completely clear. That
is exactly the kind of feedback that I have been looking
for all along. Thanks again. I updated by published proof
with these better words.
For the record, before Peter starts counting this as another endorsement
of his proof:
dbush agreed to ONE explicitly negotiated statement:
˙˙ There does not exist any implementation of C function HHH
˙˙ that simulates C function DD according to the operational
˙˙ semantics of C such that the simulated C function DD reaches
˙˙ its own simulated return statement in any N finite number
˙˙ of simulations.
On 11/1/2026 3:39 PM, Python wrote:
Le 01/11/2026 … 22:30, olcott a ‚crit :(Please pay 100% complete attention to the exact meaning of every word)
On 11/1/2026 3:20 PM, Python wrote:
Le 01/11/2026 … 22:17, olcott a ‚crit :
On 11/1/2026 3:03 PM, Python wrote:
Le 01/11/2026 … 21:59, olcott a ‚crit :
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does there exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
NO.
There is NO such finite N, PROVIDED you assume that at every one of >>>>>> those N levels the nested HHH call continues the simulation instead >>>>>> of returning.
That is trivial.
Then why did it take you a dozen or more exchanges
to pay enough attention to finally acknowledge this
self-evident truth?
Because that is NOT the proposition I spent those exchanges disputing. >>>>
I have repeatedly agreed that:
˙˙˙ IF every nested HHH continues simulating instead of returning,
˙˙˙ then no finite nesting depth reaches DD's return.
The mathematical induction proof of non-termination takes
the simulation invariant of
DD simulated by HHH does not halt while being simulated
as formal proof of non-termination of DD while DD is being
simulated by HHH.
I can show how this refutes the halting theorem with
more steps of my proof that has the above as their
foundation.
No, Peter. Calling it a "simulation invariant" does not prove it.
There does exist any finite number of N simulations of
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
ENTAILS
(Please pay 100% complete attention to the exact meaning of every word)
The mathematical induction proof of non-termination takes
the simulation invariant of
DD simulated by HHH does not halt while being simulated
as formal proof of non-termination of DD while DD is being
simulated by HHH.
(Please pay 100% complete attention to the exact meaning of every word)
We went round-and round-and-round ONLY BECAUSE YOU DID NOT DO THIS.
When LLMs fail to pay hardly any attention I ask them:
what the fuck is wrong with you? DO YOU HAVE DEMENTIA?
Le 01/11/2026 … 22:42, olcott a ‚crit :
On 11/1/2026 3:04 PM, dbush wrote:
On 11/1/2026 3:44 PM, olcott wrote:
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question: >>>>>>>>>>>>>>
Does DD simulated by HHH ever reach its own "return" >>>>>>>>>>>>>> statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>>>
Does there exist a finite number of N simulations that C >>>>>>>>> function HHH
can be modified to perform such that C function DD simulated >>>>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being >>>>>>>>> ˙> simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] >>>>>>> HHH that simulates [algorithm|C function|finite string] DD according >>>>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] >>>>>>> DD reaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above, >>>>>>> pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH that >>>>> simulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
So within today's exchanges you have been very helpful.
You forced me to make my words completely clear. That
is exactly the kind of feedback that I have been looking
for all along. Thanks again. I updated by published proof
with these better words.
For the record, before Peter starts counting this as another endorsement
of his proof:
dbush agreed to ONE explicitly negotiated statement:
˙˙ There does not exist any implementation of C function HHH
˙˙ that simulates C function DD according to the operational
˙˙ semantics of C such that the simulated C function DD reaches
˙˙ its own simulated return statement in any N finite number
˙˙ of simulations.
On 11/1/2026 3:31 PM, dart200 wrote:
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
either one works.
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
Great. It has taken quite a few years to get
agreement on this one single point. I had to
make my words much more clear to do this.
and u _still_ haven't explain wtf this has to do with the halting
theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u
explain wtf this has to do with the halting theorem???
This is the next step:
The mathematical induction proof of non-termination takes
the simulation invariant of
DD simulated by HHH does not halt while being simulated
as formal proof of non-termination of DD while DD is being
simulated by HHH.
On 11/1/26 1:45 PM, olcott wrote:
On 11/1/2026 3:31 PM, dart200 wrote:
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
either one works.
i suggest you use "N steps" since HHH does not do multiple simulations
of DD
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
Great. It has taken quite a few years to get
agreement on this one single point. I had to
make my words much more clear to do this.
and u _still_ haven't explain wtf this has to do with the halting
theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u
explain wtf this has to do with the halting theorem???
This is the next step:
The mathematical induction proof of non-termination takes
the simulation invariant of
idk what u mean by "takes the simulation invariant of"
On 11/1/2026 4:15 PM, dart200 wrote:
On 11/1/26 1:45 PM, olcott wrote:
On 11/1/2026 3:31 PM, dart200 wrote:
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
either one works.
i suggest you use "N steps" since HHH does not do multiple simulations
of DD
"steps" is better, yet the person evaluating it has this
as the entire scope.
DD is to be construed as a finite string of C source code of
a C function. HHH is to be construed as a C interpreter that
simulates C source code. HHH can simulate itself simulating
DD if needed.
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
Great. It has taken quite a few years to get
agreement on this one single point. I had to
make my words much more clear to do this.
and u _still_ haven't explain wtf this has to do with the halting >>>>>> theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u
explain wtf this has to do with the halting theorem???
This is the next step:
The mathematical induction proof of non-termination takes
the simulation invariant of
idk what u mean by "takes the simulation invariant of"
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
ENTAILS
This mathematical induction proof of non-termination
simulation invariant:
*DD simulated by HHH does not halt while being simulated*
as formal proof of non-termination of DD while DD is being
simulated by HHH.
On 11/1/26 2:26 PM, olcott wrote:
On 11/1/2026 4:15 PM, dart200 wrote:
On 11/1/26 1:45 PM, olcott wrote:
On 11/1/2026 3:31 PM, dart200 wrote:
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
either one works.
i suggest you use "N steps" since HHH does not do multiple
simulations of DD
"steps" is better, yet the person evaluating it has this
as the entire scope.
DD is to be construed as a finite string of C source code of
a C function. HHH is to be construed as a C interpreter that
simulates C source code. HHH can simulate itself simulating
DD if needed.
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
Great. It has taken quite a few years to get
agreement on this one single point. I had to
make my words much more clear to do this.
and u _still_ haven't explain wtf this has to do with the halting >>>>>>> theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u
explain wtf this has to do with the halting theorem???
This is the next step:
The mathematical induction proof of non-termination takes
the simulation invariant of
idk what u mean by "takes the simulation invariant of"
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
ENTAILS
This mathematical induction proof of non-termination
simulation invariant:
how is the proof of non-termination simulation invariant ...?
it depends on HHH doing the simulation.
if we use ? to do the
simulation, then DD would halt
*DD simulated by HHH does not halt while being simulated*
as formal proof of non-termination of DD while DD is being
simulated by HHH.
On 11/1/2026 3:04 PM, dbush wrote:
On 11/1/2026 3:44 PM, olcott wrote:The mathematical induction proof of non-termination takes
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question: >>>>>>>>>>>>>
Does DD simulated by HHH ever reach its own "return" >>>>>>>>>>>>> statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>>
Does there exist a finite number of N simulations that Cfunction HHH
can be modified to perform such that C function DD simulated >>>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being
simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string]HHH that simulates [algorithm|C function|finite string] DD according >>>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] DD >>>>>> reaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above, >>>>>> pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH thatsimulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
the simulation invariant of
*DD simulated by HHH does not halt while being simulated*
as formal proof of non-termination of DD while DD is being
simulated by HHH.
The mathematical induction proof of non-termination takessimulated*
the simulation invariant of
*C function DD simulated by C function HHH does not halt while being
as formal proof of non-termination of C function DD while C functionDD is being
simulated by C function HHH.
On 11/1/2026 4:26 PM, olcott wrote:
On 11/1/2026 3:04 PM, dbush wrote:
On 11/1/2026 3:44 PM, olcott wrote:The mathematical induction proof of non-termination takes
On 11/1/2026 2:38 PM, dbush wrote:
On 11/1/2026 3:21 PM, olcott wrote:
On 11/1/2026 2:18 PM, dbush wrote:
On 11/1/2026 1:53 PM, olcott wrote:
On 11/1/2026 11:59 AM, dbush wrote:
On 11/1/2026 12:44 PM, olcott wrote:
On 11/1/2026 9:09 AM, dbush wrote:
On 11/1/2026 9:50 AM, olcott wrote:
On 11/1/2026 8:01 AM, dbush wrote:
On 11/1/2026 8:35 AM, olcott wrote:
typedef int (*ptr)();The above statement is unclear as "DD" and "HHH" could be >>>>>>>>>>>>> referring to:
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question: >>>>>>>>>>>>>>
Does DD simulated by HHH ever reach its own "return" >>>>>>>>>>>>>> statement while DD is being simulated by HHH?
* an algorithm, i.e. a fixed immutable sequence of
instructions that always generates the same output for a >>>>>>>>>>>>> given input.
* a C function, i.e. a named address that can contain any >>>>>>>>>>>>> arbitrary set of instructions in sequence
* a finite string, i.e. a 32-bit function pointer which is >>>>>>>>>>>>> the starting address of a C function.
So please clarify whether each use of "HHH" and "DD" in the >>>>>>>>>>>>> above sentence refers to an algorithm, a C function, or a >>>>>>>>>>>>> finite string.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would the following be correct?
Does C function DD simulated by C function HHH ever reach its >>>>>>>>>>> own "return" statement while C function DD is being simulated >>>>>>>>>>> by C function HHH?
Yes that seems correct.
Does C function DD simulated by C function
HHH ever reach its own [SIMULATED] "return" statement
while C function DD is being simulated by
C function HHH?
Does there exist a finite number of N simulations
such that DD simulated by HHH reaches its own
simulated "return" statement while DD is being
simulated by HHH?
Let apply the same to the above, with a few more clarifications: >>>>>>>>>
Does there exist a finite number of N simulations that C >>>>>>>>> function HHH
can be modified to perform such that C function DD simulated >>>>>>>>> by C function HHH reaches its own
simulated "return" statement while C function DD is being >>>>>>>>> ˙> simulated by C function HHH?
Yes?
There does not exist any HHH that simulates DD according
to the operational semantics of the C programming language
such that the simulated DD reaches its own simulated
return statement in any N finite number of simulations.
There does not exist any [algorithm|C function|finite string] >>>>>>> HHH that simulates [algorithm|C function|finite string] DD according >>>>>>> ˙> to the operational semantics of the C programming language
such that the simulated [algorithm|C function|finite string] >>>>>>> DD reaches its own simulated
return statement in any N finite number of simulations.
For each instance of "[algorithm|C function|finite string]" above, >>>>>>> pick one and give the resulting sentence.
DD is to be construed as a finite string of C source
code of a C function. HHH is to be construed as a C
interpreter that simulates C source code. HHH can
simulate itself simulating DD if needed.
So would this be correct?
There does not exist any *implementation of* C function HHH that >>>>> simulates C function DD according
to the operational semantics of the C programming language
such that the simulated C function DD reaches its own simulated
return statement in any N finite number of simulations.
Yes [any *implementation of* C function HHH] is actually clearer.
Good.˙ Then *I agree that the above statement is correct*.
the simulation invariant of
*DD simulated by HHH does not halt while being simulated*
as formal proof of non-termination of DD while DD is being
simulated by HHH.
With clarifications:
The mathematical induction proof of non-termination takessimulated*
the simulation invariant of
*C function DD simulated by C function HHH does not halt while being
as formal proof of non-termination of C function DD while C functionDD is being
simulated by C function HHH.
Agreed?
On 11/1/2026 5:10 PM, dart200 wrote:
On 11/1/26 2:26 PM, olcott wrote:
On 11/1/2026 4:15 PM, dart200 wrote:
On 11/1/26 1:45 PM, olcott wrote:
On 11/1/2026 3:31 PM, dart200 wrote:
On 11/1/26 1:14 PM, olcott wrote:
On 11/1/2026 3:02 PM, dart200 wrote:
On 11/1/26 12:59 PM, olcott wrote:
On 11/1/2026 2:44 PM, Python wrote:
I am not erasing the context.
This is the exact context that I will respond to.
ANYTHING ELSE IS A DISHONEST DIVERSION AWAY FROM THE POINT
typedef int (*ptr)();
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
There does exist any finite number of N simulations
of DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
no,
Typo corrected:
There does exist any finite number of N simulations of
i think u mean "N steps"
either one works.
i suggest you use "N steps" since HHH does not do multiple
simulations of DD
"steps" is better, yet the person evaluating it has this
as the entire scope.
DD is to be construed as a finite string of C source code of
a C function. HHH is to be construed as a C interpreter that
simulates C source code. HHH can simulate itself simulating
DD if needed.
DD simulated by HHH such that the simulated DD reaches
its own simulated "return" statement while DD is being
simulated by HHH.
What do you mean by No:
(a) There does not exist
(b) There does exist
no (a) there does _not_ exist
Great. It has taken quite a few years to get
agreement on this one single point. I had to
make my words much more clear to do this.
and u _still_ haven't explain wtf this has to do with the
halting theorum
I can only say that as each step of my proof is
validated otherwise no one pays enough attention.
how many times do i need to express my explicit agreement before u >>>>>> explain wtf this has to do with the halting theorem???
This is the next step:
The mathematical induction proof of non-termination takes
the simulation invariant of
idk what u mean by "takes the simulation invariant of"
There does not exist any implementation of C function HHH
that simulates C function DD according to the operational
semantics of C such that the simulated C function DD reaches
its own simulated return statement in any N finite number of
steps.
ENTAILS
This mathematical induction proof of non-termination
simulation invariant:
how is the proof of non-termination simulation invariant ...?
it depends on HHH doing the simulation.
Nope. Thanks to dbush much better words we can see
that it does not. (see above) Your improvement was
also good and implemented.
˙if we use ? to do the simulation, then DD would halt
*DD simulated by HHH does not halt while being simulated*
as formal proof of non-termination of DD while DD is being
simulated by HHH.
typedef int (*ptr)();The question you have been raising for years is not specific
int HHH(ptr P);
01 int DD()
02 {
03˙˙ int Halt_Status = HHH(DD);
04˙˙ if (Halt_Status)
05˙˙˙˙ HERE: goto HERE;
06˙˙ return Halt_Status;
07 }
08
09 void main()
10 {
11˙ HHH(DD);
12 }
The C / C++ groups are the only people in the
world that did not flat out lie about this question:
Does DD simulated by HHH ever reach its own "return"
statement while DD is being simulated by HHH?
| Sysop: | Tetrazocine |
|---|---|
| Location: | Melbourne, VIC, Australia |
| Users: | 4 |
| Nodes: | 8 (0 / 8) |
| Uptime: | 190:54:38 |
| Calls: | 222 |
| Files: | 21,513 |
| Messages: | 85,912 |