Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out
any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out
any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
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:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out
any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
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?
That is irrelevant to anything in the quoted text.
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out
any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out
any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
On 11/5/2025 4:53 AM, Mikko wrote:
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out
any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
It forms a proof that H(D) is correct to reject (D).
That you didn't see that proves that you are not
paying close enough attention.
On 2025-11-05 11:37:15 +0000, olcott said:
On 11/5/2025 4:53 AM, Mikko wrote:
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your
perfirmance in the art of excution traces". You didn't ppint out >>>>>>> any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
It forms a proof that H(D) is correct to reject (D).
That you didn't see that proves that you are not
paying close enough attention.
If does not form a proof of anything.
That H(D) rejects a halting computation means that H is not a halt
decider. Whether not being a halt decider is "correct" depends on
which norm H is compared to.
On 11/6/2025 2:55 AM, Mikko wrote:
On 2025-11-05 11:37:15 +0000, olcott said:
On 11/5/2025 4:53 AM, Mikko wrote:
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your >>>>>>>> perfirmance in the art of excution traces". You didn't ppint out >>>>>>>> any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
It forms a proof that H(D) is correct to reject (D).
That you didn't see that proves that you are not
paying close enough attention.
If does not form a proof of anything.
The proof would be my reviewers actually knowing C
programming and being able to do their own execution
trace.
On 2025-11-06 10:54:43 +0000, olcott said:
On 11/6/2025 2:55 AM, Mikko wrote:
On 2025-11-05 11:37:15 +0000, olcott said:
On 11/5/2025 4:53 AM, Mikko wrote:
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your >>>>>>>>> perfirmance in the art of excution traces". You didn't ppint out >>>>>>>>> any error or incoherence in that sentence. Instead you said
"There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
It forms a proof that H(D) is correct to reject (D).
That you didn't see that proves that you are not
paying close enough attention.
If does not form a proof of anything.
The proof would be my reviewers actually knowing C
programming and being able to do their own execution
trace.
No, that would not be a proof. A proof is a seuence of sentences,
each of which either is a premise or follows from earlier sentences
in the proof by a truth-preserving transformatios. The proof proves
its last sentence, which is called the concluson of the proof.
On Fri, 2025-11-07 at 08:38 -0600, olcott wrote:
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:No, it is bounded.
No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its theI have no idea what you are saying here.
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/, >>>>>>>>>>> H were not to abort the simulation of D, then it would turn into H' >>>>>>>>>>> and therefore D would turn into D'. And because that D' is >>>>>>>>>>> nonterminating, it is somehow "philosophically okay" for H to claim >>>>>>>>>>> that D is nonterminating, because D' is nonterminating. You claim that
the H decision is correct because it should be interpreted as being >>>>>>>>>>> really about D'.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'! >>>>>>>>>> In the updated version a finite string of ASCII characters that definesa C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call to >>>>>>>>> a UTM and simulates that?Somewhat separately from that, I don't agree that D' could ever be >>>>>>>>>>> considered the finite string inputThen you are rejecting reality.
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
return 0, and later you call a UTM with the saved state, which then halts.Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels ofThat only happens when you screw up the specified execution trace. >>>>>>>>> You haven’t shown that. H could easily save the state of the simulation,
D simulations starting up --- and individually terminating. >>>>>>>>>
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the >>>>>>>>> halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non-If this is your most fundamental belief it may seem
decider H. There can be no correct patterns in the diagonal case. >>>>>>>>
that way. Four LLM systems now understand my system
and they figured it out on their own and proved that
they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that >>>>>>>>> doesn’t match it.
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)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your >>>>>>> head is harder than the stone (and the chick is thicker than steel). >>>>>>>
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'.
And see the assembly dump as 'proof'. Wake up, idiot.
If I was incorrect then you could show what
the correct execution trace should be.
First of all, the correct halt decider does not exist.
We can only 'experiment'
by assumptions.... But you know the liar's paradox well, so I save this.
If you refer to POOH, no one can reproduce POOH, POOH is considered as non-existent.
If
you lack the skill to show this and still
want to disagree then you can be ignored.
Sure, you can ignore all and believe garbage.
On 11/7/2025 9:34 AM, wij wrote:
On Fri, 2025-11-07 at 09:20 -0600, olcott wrote:
On 11/7/2025 9:17 AM, wij wrote:
On Fri, 2025-11-07 at 09:06 -0600, olcott wrote:
On 11/7/2025 8:55 AM, wij wrote:
On Fri, 2025-11-07 at 08:38 -0600, olcott wrote:
On 11/7/2025 8:35 AM, wij wrote:
On Fri, 2025-11-07 at 08:28 -0600, olcott wrote:
On 11/7/2025 8:12 AM, wij wrote:
On Fri, 2025-11-07 at 08:06 -0600, olcott wrote:
On 11/7/2025 7:43 AM, wij wrote:
On Fri, 2025-11-07 at 06:55 -0600, olcott wrote:
On 11/7/2025 4:45 AM, joes wrote:
Am Thu, 06 Nov 2025 20:46:57 -0600 schrieb olcott:
On 11/6/2025 7:46 PM, Kaz Kylheku wrote:
No, it is bounded.No, what doesn't halt is H' simulating D'. H' is a different deciderNot exactly. Your H is a UTM in a for loop.
which is just a UTM. Ih the language of our "concrete example" it does
this:
In D_prime, the H_prime call does not return. It never reaches its the
"do opposite" logic. We completely agree!
But D_prime is not D, and H_prime is not H.
You have been trying to say that this: that /if/, /hypothetically/,
H were not to abort the simulation of D, then it would turn into H'
and therefore D would turn into D'. And because that D' is
nonterminating, it is somehow "philosophically okay" for H to claim
that D is nonterminating, because D' is nonterminating. You claim
that
the H decision is correct because it should be interpreted as being
really about D'.
I have no idea what you are saying here.
Yes, what’s giving you trouble?
If it depends on an arbitrary function with a fixed name, then it’s notWhat you actually mean is that the true input to H is D'!In the updated version a finite string of ASCII characters that defines
a C function that calls its own C interpreter.
a single function/program with a definite halting status.
Is that what you mean? H replaces the call from D to H with a call toSomewhat separately from that, I don't agree that D' could ever beThen you are rejecting reality.
considered the finite string input
a UTM and simulates that?
When you ask Mary a yes/no question she is not in a different parallelYou think she can answer both at once?
universe depending on her answer.
Mike Terry even produced a clean HHH and DD pair of test cases which
eliminate all shared, mutable, static data.
He actually observed the start of the tower; seeing numerous levels of
D simulations starting up --- and individually terminating.
That only happens when you screw up the specified execution trace.You haven’t shown that. H could easily save the state of the simulation,
return 0, and later you call a UTM with the saved state, which then halts.
It flat out nutty to do anything at all besides reject an input when the
behavior OF THIS INPUT CORRECTLY MATCHES A CORRECT NON-HALTING BEHAVIOR
PATTERN.
It just seems like you and Mike fail to understand CORRECT NON-HALTING
BEHAVIOR PATTERNS.
Your pattern is not correct, because it ignores that D calls the
halting H.
D simulated by the executed H does not call any halting H.
Then its the wrong 'H'. Read the Halting Problem carefully.
In HP proof, the counter-case D refers to the real DECIDER that reports the
result, not something else.
You think that D runs forever because it calls the non-
decider H. There can be no correct patterns in the diagonal case.
If this is your most fundamental belief it may seem that way. Four LLM systems now understand my system and they figured it out on their own and proved that they are correct.
Ask all LLM's, they are not responsible for their answer.
Every fix to the detection logic gives rise to a new program that
doesn’t match it.
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)
If H claims it is a halt decider (i.e. H(x)==1 iff x() halts),
D has no way to return.
Until H aborts.
Manual 'abort'? or You lie the H(D) in main is the H(D) in D.
This is just ordinary C that no one
here understands. I have been programming
in C since K & R was the standard.
Only you the idiot do not understand what program is.
I know your final (or next step) is playing god, go ahead proving your
head is harder than the stone (and the chick is thicker than steel).
When we start with the semantics of the C programming language and this finite string of ASCII characters defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
So the correct answer of Halting Problem is undecidable. Agree.
It might seem that way if you didn't understand
a word that I just said
You are false god. What you said is garbage.
and don't know anything
about programming in C.
No one here (except you) who need debugger to explain C 'semantic'.
And see the assembly dump as 'proof'. Wake up, idiot.
If I was incorrect then you could show what
the correct execution trace should be.
First of all, the correct halt decider does not exist.
Changing the subject is known as the strawman deception
it is what cheaters do when they have no actual rebuttal
and still want to be disagreeable.
I am only talking about D simulated by H.
I have no problem of "D simulated by (POO) H", except if you claim the HP proof
is refuted is a big problem.
As to the constantly changing POOH, many people have already explained to you.
So you accept that D simulated by H cannot possibly
reach its own simulated "return" statement?
Repeat:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
If the H(D) in D above is a halt decider, D() cannot return. (the last line, obvious)
As to "D simulated by H", that is Peter Olcott's Own Problem, not what
the HP concerns.
If you want to understand 'the simulating H', people already explained.
In other words you dishonestly dodge the directSave the trick.
question because:
(a) You are dishonest
(b) You are clueless about C
(c) You want to be disagreeable no matter what the facts are
Which is it?
That you think it is irrelevant is not an excuse
because I can only show relevance after this point
is made. Thus thinking it is irrelevant is (a) and (b).
On 11/7/2025 2:26 AM, Mikko wrote:
On 2025-11-06 10:54:43 +0000, olcott said:
On 11/6/2025 2:55 AM, Mikko wrote:
On 2025-11-05 11:37:15 +0000, olcott said:
On 11/5/2025 4:53 AM, Mikko wrote:
On 2025-11-04 13:56:17 +0000, olcott said:
On 11/4/2025 4:10 AM, Mikko wrote:
On 2025-11-03 23:28:03 +0000, olcott said:
On 11/2/2025 6:28 AM, Mikko wrote:
Irrelevant here. I said "Perhaps you should try to improve your >>>>>>>>>> perfirmance in the art of excution traces". You didn't ppint out >>>>>>>>>> any error or incoherence in that sentence. Instead you said >>>>>>>>>> "There is no mistake in the essence of above."
*Claude, ChatGPGT, Gemini and Grok all agree on this*
*links provided below*
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?
That is irrelevant to anything in the quoted text.
You didn't even pay attention to the words the last paragraph.
Everything in the last paragraph, including the question, is
as ifrrelevant as the text before.
One should also note that you didn't identify any relevance.
It forms a proof that H(D) is correct to reject (D).
That you didn't see that proves that you are not
paying close enough attention.
If does not form a proof of anything.
The proof would be my reviewers actually knowing C
programming and being able to do their own execution
trace.
No, that would not be a proof. A proof is a seuence of sentences,
A proof is any damn thing that shows a conclusion
is necessarily true.
When we start with the semantics of the C programming
language and this finite string of ASCII characters
defining the C function D:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
And the knowledge that H is a C interpreter
that takes the above test.c file as an input
and knows that the call to H(D) in D calls
itself to simulate the text body of D then
the execution trace proves that D simulated
by H cannot possibly reach its own simulated
"return" statement final halt state.
I am talking about correct semantic logical entailment
on the basis of self-evident truths. A self-evident
truth is proven true entirely on the basis of its meaning.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 78:39:38 |
| Calls: | 13,805 |
| Files: | 186,990 |
| D/L today: |
5,992 files (1,958M bytes) |
| Messages: | 2,443,207 |