On 2025-10-30, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 6:47 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
In the same sort of way that aborting Infinite_Loop()
causes it to reach its own "return" statement.
In other words not at all only a lie.
Can you point of which lines of code are perpetrating a lie,
It is only you yourself lying or being inexplicably
confused over very simple matters.
That's your unsubstantiated word against code with test results.
and how they are doing it? From that, a fix may be identified.
theSo does the Infinite_Loop()
slave_state and slave_stack objects still exist,
When DDD is aborted by HHH, I can tell you exactly where it is.
Likewise with Infinite_Loop().
Correct; it is similar, except that of course Infinite_Loop doesn't
create a grandchild simulation.
So you are really trying to get away with
saying that you don't understand that D
So You are really trying to get away with that you don't understand the execution traces produced by some small addition to your own C project?
People other than you consider my claims plausible.
There is code and exdcution traces.
You simply cannot dismiss that without looking into it.
If you had credibility left to lose, that's the sort of argumentation
you'd want to avoid.
simulated by H cannot possibly reach its
own simulated "return" statement even if
God commands it?
I understand that you put in countermeasures against that happening.
Your Init_Halts_HH function returns 1 to the first caller, and then
0 to subsequent callers. This is captured by H as the local variable
Root.
Only the H instance with Root == 1 is supposed to be performing
the abort test.
So if that worked right, it should cause the simulated H to behave
like a pure simulation and so its D should be infinitely executing.
Let's set aside the issue that that is hideous cheat that.
For one reason or another: IT IS NOT WORKING.
The nested H's are getting Root == 1 out of Init_Halts_H, and so doing
the abort check, returning 0 to their respective DD's.
Mkke Terry pointed this out first.
On 10/29/2025 8:42 PM, Kaz Kylheku wrote:
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 6:47 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
In the same sort of way that aborting Infinite_Loop()
causes it to reach its own "return" statement.
In other words not at all only a lie.
Can you point of which lines of code are perpetrating a lie,
It is only you yourself lying or being inexplicably
confused over very simple matters.
That's your unsubstantiated word against code with test results.
and how they are doing it? From that, a fix may be identified.
theSo does the Infinite_Loop()
slave_state and slave_stack objects still exist,
When DDD is aborted by HHH, I can tell you exactly where it is.
Likewise with Infinite_Loop().
Correct; it is similar, except that of course Infinite_Loop doesn't
create a grandchild simulation.
So you are really trying to get away with
saying that you don't understand that D
So You are really trying to get away with that you don't understand the
execution traces produced by some small addition to your own C project?
People other than you consider my claims plausible.
There is code and exdcution traces.
You simply cannot dismiss that without looking into it.
If you had credibility left to lose, that's the sort of argumentation
you'd want to avoid.
simulated by H cannot possibly reach its
own simulated "return" statement even if
God commands it?
I understand that you put in countermeasures against that happening.
Your Init_Halts_HH function returns 1 to the first caller, and then
0 to subsequent callers. This is captured by H as the local variable
Root.
Only the H instance with Root == 1 is supposed to be performing
the abort test.
So if that worked right, it should cause the simulated H to behave
like a pure simulation and so its D should be infinitely executing.
Let's set aside the issue that that is hideous cheat that.
For one reason or another: IT IS NOT WORKING.
The nested H's are getting Root == 1 out of Init_Halts_H, and so doing
the abort check, returning 0 to their respective DD's.
Mkke Terry pointed this out first.
When I simplify it down to this and you
disagree and cannot see how you are not simply
a damned liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
On 10/29/2025 6:30 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 2:08 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
Not at all, it is stipulated that H does simulate D according to the >>>>> semantics of the C language until H sees that itself is stuck in
recursive simulation.
Then H reports 0, whereas if the simulation is continued,
it hals in th esmae way as a D() executed on a regular
simulartor/processor.
I don't see how you are getting this.
Which line of code are you struggling with? I'm open to questions.You tried to get away with saying that this halts
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
So all that I see is flat out dishonesty.
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:Now that four different LLM systems have been able
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully defined >>>>>>> because HHH has external linkage and is thus not part of the referent or
partially defined because HHH, as a callee from the referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the equivocation >>>>>> deception that might be useful later, dependig on how others respond. >>>>>
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation.
I will simplify it for you:
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Am Wed, 29 Oct 2025 18:35:54 -0500 schrieb olcott:
On 10/29/2025 6:30 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 2:08 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
Not at all, it is stipulated that H does simulate D according to the >>>>>> semantics of the C language until H sees that itself is stuck in
recursive simulation.
You can stipulate that, but H doesn’t do it.
Then H reports 0, whereas if the simulation is continued,
it hals in th esmae way as a D() executed on a regular
simulartor/processor.
I don't see how you are getting this.
You don’t see how D calls an aborting simulator? H1 simulates that.
Which line of code are you struggling with? I'm open to questions.You tried to get away with saying that this halts
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
So all that I see is flat out dishonesty.
That is literally a lie. Nobody has suggested anything like that.
On 2025-10-29, olcott <polcott333@gmail.com> wrote:--
You tried to get away with saying that this halts
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
That was just the one time I was kidding.
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
In Jun you committed a Halt7.obj which uses H(D). So we can run
this.
On 10/30/2025 5:06 AM, joes wrote:
Am Wed, 29 Oct 2025 18:35:54 -0500 schrieb olcott:
On 10/29/2025 6:30 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 2:08 PM, Kaz Kylheku wrote:
Are you too fucking stupid to see that D simulated by H cannot reach itsYou don’t see how D calls an aborting simulator? H1 simulates that.Then H reports 0, whereas if the simulation is continued,I don't see how you are getting this.
it hals in th esmae way as a D() executed on a regular
simulartor/processor.
own simulated "return" statement?
If you are then I am done talking to you.
He admitted that he did recently.That is literally a lie. Nobody has suggested anything like that.Which line of code are you struggling with? I'm open to questions.You tried to get away with saying that this halts
void Infinite_Loop()
{
HERE: goto HERE;
return;
}
So all that I see is flat out dishonesty.
On 10/29/2025 6:47 PM, Kaz Kylheku wrote:
That was just the one time I was kidding.
On 10/30/2025 12:33 AM, Kaz Kylheku wrote:
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
In Jun you committed a Halt7.obj which uses H(D). So we can run
this.
Are you too fucking stupid to see
that D simulated by H cannot reach
its own simulated "return" statement?
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and there >>>>>>>>> id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully
defined
because HHH has external linkage and is thus not part of the
referent or
partially defined because HHH, as a callee from the referent, is >>>>>>>> part of
the referent itself?
I am. Olcott does not specify as that would prevent the equivocation >>>>>>> deception that might be useful later, dependig on how others
respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation.
I will simplify it for you:
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference
seems to be distraction by an irrelevancy.
Am Thu, 30 Oct 2025 07:36:51 -0500 schrieb olcott:
On 10/30/2025 5:06 AM, joes wrote:
Am Wed, 29 Oct 2025 18:35:54 -0500 schrieb olcott:
On 10/29/2025 6:30 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 2:08 PM, Kaz Kylheku wrote:
Are you too fucking stupid to see that D simulated by H cannot reach itsYou don’t see how D calls an aborting simulator? H1 simulates that.Then H reports 0, whereas if the simulation is continued,I don't see how you are getting this.
it hals in th esmae way as a D() executed on a regular
simulartor/processor.
own simulated "return" statement?
If you are then I am done talking to you.
Could you explain what you think D would do after being aborted?
Or why H1 doesn’t notice that it is calling a non-aborting simulator?
You are literally immune to humour. So which line of code gives you
trouble?
On 10/30/2025 12:33 AM, Kaz Kylheku wrote:
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
In Jun you committed a Halt7.obj which uses H(D). So we can run
this.
Are you too fucking stupid to see
that D simulated by H cannot reach
its own simulated "return" statement?
On 10/30/2025 7:55 AM, joes wrote:
Am Thu, 30 Oct 2025 07:36:51 -0500 schrieb olcott:
On 10/30/2025 5:06 AM, joes wrote:
Am Wed, 29 Oct 2025 18:35:54 -0500 schrieb olcott:
On 10/29/2025 6:30 PM, Kaz Kylheku wrote:
On 2025-10-29, olcott <polcott333@gmail.com> wrote:
On 10/29/2025 2:08 PM, Kaz Kylheku wrote:
Are you too fucking stupid to see that D simulated by H cannot reach its >>> own simulated "return" statement?You don’t see how D calls an aborting simulator? H1 simulates that.Then H reports 0, whereas if the simulation is continued,I don't see how you are getting this.
it hals in th esmae way as a D() executed on a regular
simulartor/processor.
If you are then I am done talking to you.
Could you explain what you think D would do after being aborted?
Or why H1 doesn’t notice that it is calling a non-aborting simulator?
D simulated by H measures the semantic property
of the actual input as opposed to and contrast
with the semantic property of a non-input. H and
H1 are identical except that D does not call H1.
We can tell an input from an input because an
input is an argument to the function H.
D.input_to_H
specifies different behavior than
D.input_to_H1.
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
On 10/30/2025 12:33 AM, Kaz Kylheku wrote:
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
In Jun you committed a Halt7.obj which uses H(D). So we can run
this.
Are you too fucking stupid to see
You can earn your right to call me stupid, when you refer to code
where I messed up.
From where I'm standing, that epithet rather applies to you, and
I wouldn't hesitate to use it, so it is fair to use it on me.
You put /fake/ countermeasures into your code to try to make sure that a simulated H would behave differently from the top-level H, so as to
never return to the simulated D.
You did not /validate/ this hypothesis by not writing the code to
continue the simulation after H is done with it.
And, would you know it, a regression has showed up; your idiotic cheat
which would get your code instantly dismissed by CS academia is not
working.
that D simulated by H cannot reach
its own simulated "return" statement?
It depends on the H, obviously!
Under a simulationg H which doesn't abort, that is true.
Under a H which looks for the abort pattern and returns 0, that is
completely false.
On 10/30/2025 11:47 AM, Kaz Kylheku wrote:
that D simulated by H cannot reach
its own simulated "return" statement?
It depends on the H, obviously!
Under a simulationg H which doesn't abort, that is true.
Under a H which looks for the abort pattern and returns 0, that is
completely false.
So you are too fucking stupid to pay attention
to the fact that D simulated by H is not fucking
D() called from main().
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
On 10/30/2025 11:47 AM, Kaz Kylheku wrote:
that D simulated by H cannot reach
its own simulated "return" statement?
It depends on the H, obviously!
Under a simulationg H which doesn't abort, that is true.
Under a H which looks for the abort pattern and returns 0, that is
completely false.
So you are too fucking stupid to pay attention
to the fact that D simulated by H is not fucking
D() called from main().
You miserable, desperate imbecile:
I am tracing the D simulation from H, and that one halts.
I am not tracing D called from main.
D is /not/ called from main in any of your the Halt.obj test cases
in the history of that file.
I have not touched your Halt7.obj test files whatsoever; you
compiled those.
Even if something were to be (wrongly!) different between the two
(which is plausible due to your cheat-ridden bug trap known as x86utm
and its Halt7 test case file) it is completely /irrelevant/
since I'm not looking at D called from main, what-so-ever.
Until you grapple with the actual code you are just pushing air from
under your keycaps.
On 10/30/2025 3:05 PM, Kaz Kylheku wrote:
On 2025-10-30, olcott <polcott333@gmail.com> wrote:
On 10/30/2025 11:47 AM, Kaz Kylheku wrote:
that D simulated by H cannot reach
its own simulated "return" statement?
It depends on the H, obviously!
Under a simulationg H which doesn't abort, that is true.
Under a H which looks for the abort pattern and returns 0, that is
completely false.
So you are too fucking stupid to pay attention
to the fact that D simulated by H is not fucking
D() called from main().
You miserable, desperate imbecile:
I am tracing the D simulation from H, and that one halts.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0;
Then you must be a fucking liar.
I am not tracing D called from main.
D is /not/ called from main in any of your the Halt.obj test cases
in the history of that file.
I have not touched your Halt7.obj test files whatsoever; you
compiled those.
I am not fucking talking about Halt7.obj you
fucking moron. There is no D in Halt7.obj nitwit.
*I would much much rather be nice, but nice DOES NOT WORK*
Until you grapple with the actual code you are just pushing air from
under your keycaps.
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:Not at all, it is stipulated that H does simulate
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:Now that four different LLM systems have been able
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully defined >>>>>>>>> because HHH has external linkage and is thus not part of the referent or
partially defined because HHH, as a callee from the referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the equivocation >>>>>>>> deception that might be useful later, dependig on how others respond. >>>>>>>
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation.
I will simplify it for you:
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with equivocation. >>>
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference
seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
Are we taking that "DD" refers to a C-function that is fully defined
because HHH has external linkage and is thus not part of the referent or partially defined because HHH, as a callee from the referent, is part of
the referent itself?
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:I will simplify it for you:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and >>>>>>>>>>> there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully >>>>>>>>>> defined
because HHH has external linkage and is thus not part of the >>>>>>>>>> referent or
partially defined because HHH, as a callee from the referent, >>>>>>>>>> is part of
the referent itself?
I am. Olcott does not specify as that would prevent the
equivocation
deception that might be useful later, dependig on how others >>>>>>>>> respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation. >>>>>>
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with
equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference
seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined
because HHH has external linkage and is thus not part of the referent or
partially defined because HHH, as a callee from the referent, is part of
the referent itself?
I have answered about my use of "DD". Olcott has not answered but tried
to devert attention from the question.
On 10/31/2025 6:37 AM, Mikko wrote:
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:Not at all, it is stipulated that H does simulate
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:I will simplify it for you:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully defined
because HHH has external linkage and is thus not part of the referent or
partially defined because HHH, as a callee from the referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the equivocation >>>>>>>>>> deception that might be useful later, dependig on how others respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation. >>>>>>>
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with equivocation. >>>>>
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference
seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined
because HHH has external linkage and is thus not part of the referent or >>> partially defined because HHH, as a callee from the referent, is part of >>> the referent itself?
I have answered about my use of "DD". Olcott has not answered but tried
to devert attention from the question.
All that we need to know about H is specified by this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
On 2025-10-31 12:47:01 +0000, olcott said:
On 10/31/2025 6:37 AM, Mikko wrote:
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:I will simplify it for you:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and >>>>>>>>>>>>> there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully >>>>>>>>>>>> defined
because HHH has external linkage and is thus not part of the >>>>>>>>>>>> referent or
partially defined because HHH, as a callee from the
referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the >>>>>>>>>>> equivocation
deception that might be useful later, dependig on how others >>>>>>>>>>> respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation. >>>>>>>>
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with
equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference
seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined
because HHH has external linkage and is thus not part of the
referent or
partially defined because HHH, as a callee from the referent, is
part of
the referent itself?
I have answered about my use of "DD". Olcott has not answered but tried
to devert attention from the question.
All that we need to know about H is specified by this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
That is much more than all we need to know about H. All we need to
know about H is that it is not a halt decider.
On 11/1/2025 4:58 AM, Mikko wrote:
On 2025-10-31 12:47:01 +0000, olcott said:
On 10/31/2025 6:37 AM, Mikko wrote:
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:I will simplify it for you:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and >>>>>>>>>>>>>> there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully >>>>>>>>>>>>> defined
because HHH has external linkage and is thus not part of the >>>>>>>>>>>>> referent or
partially defined because HHH, as a callee from the >>>>>>>>>>>>> referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the >>>>>>>>>>>> equivocation
deception that might be useful later, dependig on how others >>>>>>>>>>>> respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation. >>>>>>>>>
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with
equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference >>>>>> seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined >>>>> because HHH has external linkage and is thus not part of the
referent or
partially defined because HHH, as a callee from the referent, is
part of
the referent itself?
I have answered about my use of "DD". Olcott has not answered but tried >>>> to devert attention from the question.
All that we need to know about H is specified by this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
That is much more than all we need to know about H. All we need to
know about H is that it is not a halt decider.
*Richard flat out lied about this*
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.
On 2025-11-01, olcott <polcott333@gmail.com> wrote:
On 11/1/2025 4:58 AM, Mikko wrote:
On 2025-10-31 12:47:01 +0000, olcott said:
On 10/31/2025 6:37 AM, Mikko wrote:
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:I will simplify it for you:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said: >>>>>>>>>>>>>
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and >>>>>>>>>>>>>>> there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully >>>>>>>>>>>>>> defined
because HHH has external linkage and is thus not part of the >>>>>>>>>>>>>> referent or
partially defined because HHH, as a callee from the >>>>>>>>>>>>>> referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the >>>>>>>>>>>>> equivocation
deception that might be useful later, dependig on how others >>>>>>>>>>>>> respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation. >>>>>>>>>>
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with
equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping >>>>>>> the option to deceive with equivocation even though his preference >>>>>>> seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined >>>>>> because HHH has external linkage and is thus not part of the
referent or
partially defined because HHH, as a callee from the referent, is
part of
the referent itself?
I have answered about my use of "DD". Olcott has not answered but tried >>>>> to devert attention from the question.
All that we need to know about H is specified by this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
That is much more than all we need to know about H. All we need to
know about H is that it is not a halt decider.
*Richard flat out lied about this*
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.
Not that you've been able to code.
I can write a C interpreter which can interpret itself.
On 11/1/2025 11:46 AM, Kaz Kylheku wrote:
On 2025-11-01, olcott <polcott333@gmail.com> wrote:
On 11/1/2025 4:58 AM, Mikko wrote:
On 2025-10-31 12:47:01 +0000, olcott said:
On 10/31/2025 6:37 AM, Mikko wrote:
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said: >>>>>>>>>>>>>>
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and >>>>>>>>>>>>>>>> there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully >>>>>>>>>>>>>>> defined
because HHH has external linkage and is thus not part of the >>>>>>>>>>>>>>> referent or
partially defined because HHH, as a callee from the >>>>>>>>>>>>>>> referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the >>>>>>>>>>>>>> equivocation
deception that might be useful later, dependig on how others >>>>>>>>>>>>>> respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers >>>>>>>>>>>>> have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with
equivocation.
I will simplify it for you:
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with >>>>>>>>>> equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping >>>>>>>> the option to deceive with equivocation even though his preference >>>>>>>> seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined >>>>>>> because HHH has external linkage and is thus not part of the
referent or
partially defined because HHH, as a callee from the referent, is >>>>>>> part of
the referent itself?
I have answered about my use of "DD". Olcott has not answered but >>>>>> tried
to devert attention from the question.
All that we need to know about H is specified by this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
That is much more than all we need to know about H. All we need to
know about H is that it is not a halt decider.
*Richard flat out lied about this*
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.
Not that you've been able to code.
I have been able to code it yet the x86 language has
proven to be enormously too difficult for everyone
here. BECAUSE OF THIS I WILL NOT DISCUSS THE X86
CODE WITH ANYONE.
Since you already admitted this:
On 10/31/2025 7:44 PM, Kaz Kylheku wrote:
I can write a C interpreter which can interpret itself.
What the fuck is holding you up with proving your
damned lie that D simulated by H reaches its own
simulated "return" statement?
Disagreeing with source-code is not a smart thing to do.
H is a correct termination analyzer for D.
Not that you've been able to code.
I have been able to code it yet the x86 language has
proven to be enormously too difficult for everyone
here. BECAUSE OF THIS I WILL NOT DISCUSS THE X86
CODE WITH ANYONE.
Since you already admitted this:
On 10/31/2025 7:44 PM, Kaz Kylheku wrote:
I can write a C interpreter which can interpret itself.
What the fuck is holding you up with proving your
damned lie that D simulated by H reaches its own
simulated "return" statement?
On 2025-11-01, olcott <polcott333@gmail.com> wrote:
H is a correct termination analyzer for D.
Not that you've been able to code.
I have been able to code it yet the x86 language has
proven to be enormously too difficult for everyone
here. BECAUSE OF THIS I WILL NOT DISCUSS THE X86
CODE WITH ANYONE.
The one who will not discuss is obviously the one who doesn't wish his
lack of understanding to be exposed.
On 11/1/2025 4:58 AM, Mikko wrote:
On 2025-10-31 12:47:01 +0000, olcott said:
On 10/31/2025 6:37 AM, Mikko wrote:
On 2025-10-30 13:12:24 +0000, olcott said:
On 10/30/2025 5:15 AM, Mikko wrote:
On 2025-10-29 16:33:58 +0000, olcott said:
On 10/29/2025 5:07 AM, Mikko wrote:
On 2025-10-28 15:14:07 +0000, olcott said:
On 10/28/2025 5:03 AM, Mikko wrote:
On 2025-10-27 14:41:15 +0000, olcott said:I will simplify it for you:
On 10/27/2025 4:51 AM, Mikko wrote:
On 2025-10-26 11:28:47 +0000, Tristan Wibberley said:
On 26/10/2025 09:11, Mikko Levanto wrote:
HHH never dimulates more steps than there are in DD, and there id only a
finite number of steps there.
Are we taking that "DD" refers to a C-function that is fully defined
because HHH has external linkage and is thus not part of the referent or
partially defined because HHH, as a callee from the referent, is part of
the referent itself?
I am. Olcott does not specify as that would prevent the equivocation
deception that might be useful later, dependig on how others respond.
Now that four different LLM systems have been able
reverse-engineer the non-halting result by merely
being told to faithfully simulate DD with HHH and
see what happens this proves that all of my reviewers
have been dishonest with me for three years.
typedef int (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
*Halting Problem Simulation in C*
https://philpapers.org/archive/OLCHPS-2.pdf
Note that the above keeps the option to deceive with equivocation. >>>>>>>>>
Anyone knowing C and denying this is a liar.
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern.
Note that the above still keeps the option to deceive with equivocation.
Not at all, it is stipulated that H does simulate
D according to the semantics of the C language until
H sees that itself is stuck in recursive simulation.
Note that Olcott still does not answer the question, thus keeping
the option to deceive with equivocation even though his preference >>>>>> seems to be distraction by an irrelevancy.
I am referring to D simulated by H when you change
my words to something else you are a liar.
Olcott wrote on 2025-10-24:
When 0 to infinity steps of DD are
correctly simulated by HHH the
simulated DD never reaches its own
simulated final halt state.
On 10/26/25 7:28 AM, Tristan Wibberley wrote:
Are we taking that "DD" refers to a C-function that is fully defined >>>>> because HHH has external linkage and is thus not part of the referent or >>>>> partially defined because HHH, as a callee from the referent, is part of >>>>> the referent itself?
I have answered about my use of "DD". Olcott has not answered but tried >>>> to devert attention from the question.
All that we need to know about H is specified by this:
int D()
{
int Halt_Status = H(D);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
H simulates D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
that calls H(D) to simulate D
until H sees this repeating pattern
Then H returns 0 to reject its input as non-halting.
That is much more than all we need to know about H. All we need to
know about H is that it is not a halt decider.
*Richard flat out lied about this*
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,075 |
| Nodes: | 10 (0 / 10) |
| Uptime: | 90:35:40 |
| Calls: | 13,798 |
| Calls today: | 1 |
| Files: | 186,989 |
| D/L today: |
5,332 files (1,536M bytes) |
| Messages: | 2,438,212 |