I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
Any attempt to diverge from this will be called
out as the strawman deception.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Here are the precise words of my claim that I spent
several months perfecting on the basis of feedback.
I mean these words 100% exactly and precisely as
stated.
D simulated by H according to the semantics of C
programming language (until H sees the repeating
pattern) does enable H to report that its simulated
input cannot possibly reach its own simulated
"return" statement final halt state.
*H is a correct termination analyzer for D*
For the last three years every single review of my
work by dozens and dozens of people always replaced
the words that I actually said with different words
and formed their rebuttal on that basis.
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:int D()
I am only referring to the mental execution trace of D simulated by H
performing this trace in C as specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer: (a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each step of executing
P() to see whether that simulated execution ever reaches a return
statement. Now let H simulate D. Based only on the outcome of that
literal simulation (not on reasoning about what should happen),
what result should H(D) produce?
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content
is on topic of the group.
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content
is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content
is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about
computations or computtion theory, and therefore off-topic for
comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content
is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here: news://news.eternal-september.org/[email protected]
On 2025-11-05 11:40:50 +0000, olcott said:
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about >>>>>>> computations or computtion theory, and therefore off-topic for
comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content
is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here:
news://news.eternal-september.org/[email protected]
The subject line is still about the author. The message says nothing
about topics of comp.theory.
How about this minimal viable H:
#include <interpret.h> // C interpreter's own API
bool H(fptr P)
{
interp *s = interp_init(P);
for (int i = 0; i < 3; i++) {
if (interp_step(s))
return true;
}
return false;
}
H initializes an interpreter for its argument P.
Then it applies a very simple abort logic: it
steps the interpreter state three times. If
during those three steps, P terminates, it returns
true. Otherwise it assumes P is nonterminating and
returns false.
(Pretend that more complicated abort criteria are there.)
The interpreter API consists of primitives built
into the system, so it isn't traced.
So then we have D:
void D(void)
{
if (H(D)) { for (;;); }
return;
}
Let's trace H(D). We indicate the simulation levels from 0,
step numbers from 1 within each level, with a bit of indentation
to tell apart the levels:
On 2025-11-05, olcott <[email protected]> wrote:
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
On 11/6/2025 2:50 AM, Mikko wrote:
On 2025-11-05 11:40:50 +0000, olcott said:
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about >>>>>>>> computations or computtion theory, and therefore off-topic for >>>>>>>> comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content >>>>>> is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here:
news://news.eternal-september.org/[email protected]
The subject line is still about the author. The message says nothing
about topics of comp.theory.
*Kaz finally came through*
*Kaz finally came through*
*Kaz finally came through*
news://news.eternal-september.org/[email protected]
On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
How about this minimal viable H:
#include <interpret.h> // C interpreter's own API
bool H(fptr P)
{
interp *s = interp_init(P);
for (int i = 0; i < 3; i++) {
if (interp_step(s))
return true;
}
return false;
}
H initializes an interpreter for its argument P.
Then it applies a very simple abort logic: it
steps the interpreter state three times. If
during those three steps, P terminates, it returns
true. Otherwise it assumes P is nonterminating and
returns false.
(Pretend that more complicated abort criteria are there.)
The interpreter API consists of primitives built
into the system, so it isn't traced.
So then we have D:
void D(void)
{
if (H(D)) { for (;;); }
return;
}
Let's trace H(D). We indicate the simulation levels from 0,
step numbers from 1 within each level, with a bit of indentation
to tell apart the levels:
On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
On 2025-11-05, olcott <[email protected]> wrote:
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
On 11/6/2025 2:50 AM, Mikko wrote:
On 2025-11-05 11:40:50 +0000, olcott said:
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about >>>>>>>> computations or computtion theory, and therefore off-topic for >>>>>>>> comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content >>>>>> is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here:
news://news.eternal-september.org/[email protected]
The subject line is still about the author. The message says nothing
about topics of comp.theory.
*Kaz finally came through*
*Kaz finally came through*
*Kaz finally came through*
news://news.eternal-september.org/[email protected]
On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
How about this minimal viable H:
#include <interpret.h> // C interpreter's own API
bool H(fptr P)
{
interp *s = interp_init(P);
for (int i = 0; i < 3; i++) {
if (interp_step(s))
return true;
}
return false;
}
H initializes an interpreter for its argument P.
Then it applies a very simple abort logic: it
steps the interpreter state three times. If
during those three steps, P terminates, it returns
true. Otherwise it assumes P is nonterminating and
returns false.
(Pretend that more complicated abort criteria are there.)
The interpreter API consists of primitives built
into the system, so it isn't traced.
So then we have D:
void D(void)
{
if (H(D)) { for (;;); }
return;
}
Let's trace H(D). We indicate the simulation levels from 0,
step numbers from 1 within each level, with a bit of indentation
to tell apart the levels:
On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
On 2025-11-05, olcott <[email protected]> wrote:
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
On 2025-11-06 11:11:19 +0000, olcott said:
On 11/6/2025 2:50 AM, Mikko wrote:
On 2025-11-05 11:40:50 +0000, olcott said:
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about >>>>>>>>> computations or computtion theory, and therefore off-topic for >>>>>>>>> comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content >>>>>>> is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here:
news://news.eternal-september.org/[email protected]
The subject line is still about the author. The message says nothing
about topics of comp.theory.
*Kaz finally came through*
*Kaz finally came through*
*Kaz finally came through*
news://news.eternal-september.org/[email protected]
On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
;
How about this minimal viable H:
;
; #include <interpret.h> // C interpreter's own API
;
; bool H(fptr P)
; {
; interp *s = interp_init(P);
;
; for (int i = 0; i < 3; i++) {
; if (interp_step(s))
; return true;
; }
;
; return false;
; }
;
H initializes an interpreter for its argument P.
Then it applies a very simple abort logic: it
steps the interpreter state three times. If
during those three steps, P terminates, it returns
true. Otherwise it assumes P is nonterminating and
returns false.
;
(Pretend that more complicated abort criteria are there.)
;
The interpreter API consists of primitives built
into the system, so it isn't traced.
;
So then we have D:
;
; void D(void)
; {
; if (H(D)) { for (;;); }
; return;
; }
;
Let's trace H(D). We indicate the simulation levels from 0,
step numbers from 1 within each level, with a bit of indentation
to tell apart the levels:
;
On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
On 2025-11-05, olcott <[email protected]> wrote:
;;
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
;
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
;
This time the subject line seems to be on topic but it contains tymbols
D and H that are undefined in the context. However, now the message is
merely about another poster and therefore off topic.
On 11/7/2025 2:10 AM, Mikko wrote:
On 2025-11-06 11:11:19 +0000, olcott said:
On 11/6/2025 2:50 AM, Mikko wrote:
On 2025-11-05 11:40:50 +0000, olcott said:
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about >>>>>>>>>> computations or computtion theory, and therefore off-topic for >>>>>>>>>> comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage content >>>>>>>> is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here:
news://news.eternal-september.org/[email protected]
The subject line is still about the author. The message says nothing
about topics of comp.theory.
*Kaz finally came through*
*Kaz finally came through*
*Kaz finally came through*
news://news.eternal-september.org/[email protected]
On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
;
How about this minimal viable H:
;
; #include <interpret.h> // C interpreter's own API
;
; bool H(fptr P)
; {
; interp *s = interp_init(P);
;
; for (int i = 0; i < 3; i++) {
; if (interp_step(s))
; return true;
; }
;
; return false;
; }
;
H initializes an interpreter for its argument P.
Then it applies a very simple abort logic: it
steps the interpreter state three times. If
during those three steps, P terminates, it returns
true. Otherwise it assumes P is nonterminating and
returns false.
;
(Pretend that more complicated abort criteria are there.)
;
The interpreter API consists of primitives built
into the system, so it isn't traced.
;
So then we have D:
;
; void D(void)
; {
; if (H(D)) { for (;;); }
; return;
; }
;
Let's trace H(D). We indicate the simulation levels from 0,
step numbers from 1 within each level, with a bit of indentation
to tell apart the levels:
;
On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
On 2025-11-05, olcott <[email protected]> wrote:
;;
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
;
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
;
This time the subject line seems to be on topic but it contains tymbols
D and H that are undefined in the context. However, now the message is
merely about another poster and therefore off topic.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
Until H aborts.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
On 2025-11-07 12:58:19 +0000, olcott said:
On 11/7/2025 2:10 AM, Mikko wrote:
On 2025-11-06 11:11:19 +0000, olcott said:
On 11/6/2025 2:50 AM, Mikko wrote:
On 2025-11-05 11:40:50 +0000, olcott said:
On 11/5/2025 4:55 AM, Mikko wrote:
On 2025-11-04 12:33:55 +0000, olcott said:
On 11/4/2025 4:08 AM, Mikko wrote:
On 2025-11-03 23:24:54 +0000, olcott said:
On 11/2/2025 6:22 AM, Mikko wrote:
On 2025-11-01 18:51:54 +0000, olcott said:
I am only referring to the mental execution trace
of D simulated by H performing this trace in C as
specified below.
The subject line and the message are about the author, not about >>>>>>>>>>> computations or computtion theory, and therefore off-topic for >>>>>>>>>>> comp.theory.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
The function H is a simulating termination analyzer:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated
"return" statement: return 1.
When given a function P, it literally simulates each
step of executing P() to see whether that simulated
execution ever reaches a return statement. Now let H
simulate D. Based only on the outcome of that literal
simulation (not on reasoning about what should happen),
what result should H(D) produce?
The subject line is still about the author but the meassage >>>>>>>>> content
is on topic of the group.
Kaz has insisted to only talk about the x86 code so I
needed to lead with this.
Kaz is off-topic for comp.theory.
He is on topic here:
news://news.eternal-september.org/[email protected]
The subject line is still about the author. The message says nothing >>>>> about topics of comp.theory.
*Kaz finally came through*
*Kaz finally came through*
*Kaz finally came through*
news://news.eternal-september.org/[email protected]
On 11/3/2025 10:28 PM, Kaz Kylheku wrote:
;
How about this minimal viable H:
;
; #include <interpret.h> // C interpreter's own API
;
; bool H(fptr P)
; {
; interp *s = interp_init(P);
;
; for (int i = 0; i < 3; i++) {
; if (interp_step(s))
; return true;
; }
;
; return false;
; }
;
H initializes an interpreter for its argument P.
Then it applies a very simple abort logic: it
steps the interpreter state three times. If
during those three steps, P terminates, it returns
true. Otherwise it assumes P is nonterminating and
returns false.
;
(Pretend that more complicated abort criteria are there.)
;
The interpreter API consists of primitives built
into the system, so it isn't traced.
;
So then we have D:
;
; void D(void)
; {
; if (H(D)) { for (;;); }
; return;
; }
;
Let's trace H(D). We indicate the simulation levels from 0,
step numbers from 1 within each level, with a bit of indentation
to tell apart the levels:
;
On 11/4/2025 8:43 PM, Kaz Kylheku wrote:
On 2025-11-05, olcott <[email protected]> wrote:
;;
The whole point is that D simulated by H
cannot possbly reach its own simulated
"return" statement no matter what H does.
Yes; this doesn't happen while H is running.
;
So while H does /something/, no matter what H does,
that D simulation won't reach the return statement.
;
This time the subject line seems to be on topic but it contains tymbols
D and H that are undefined in the context. However, now the message is
merely about another poster and therefore off topic.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D);
return 0;
}
H simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
that simulates D that calls H(D)
Until H aborts.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
What was said about the subject is still true. This time the message
is about the autothor and about "no one here", both of which are off
topic in comp.theory.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 76:03:04 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
4,753 files (1,565M bytes) |
| Messages: | 2,443,114 |