From Newsgroup: comp.ai.philosophy

On 11/30/2025 10:15 AM, HAL 9000 wrote:

H must and always must halt for any input otherwise it isn't a halt
decider.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated D
would never stop running unless aborted then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*HHH/DD has been fully operational code since above date* https://github.com/plolcott/x86utm/blob/master/Halt7.c

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);
}

HHH is a simulating termination analyzer that
includes DD in its domain.

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

Halt is defined as DD reaching its own simulated
"return" statement while DD is being simulated
by HHH.

When the halting problem requires HHH to
report on the behavior of DD directly executed
from main, this is a category error because it
requires HHH to report on something besides
the behavior that the input to HHH(DD) maps to.
--
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

This required establishing a new foundation
for correct reasoning.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 11/30/25 11:52 AM, olcott wrote:

On 11/30/2025 10:15 AM, HAL 9000 wrote:

H must and always must halt for any input otherwise it isn't a halt
decider.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its
    input D until H correctly determines that its simulated D
    would never stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*HHH/DD has been fully operational code since above date* https://github.com/plolcott/x86utm/blob/master/Halt7.c

And proves that it is wrong.

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);
}

HHH is a simulating termination analyzer that
includes DD in its domain.

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

But that isn't the definiton of Halting, only your own lie.

Halt is defined as DD reaching its own simulated
"return" statement while DD is being simulated
by HHH.

No. it isn't, Halting is define as DD reaching its own final state when
RUN, or COMPLETELY simulated.

It also is only defined for "Programs", which require the including of
*ALL* the code used, so for that DD, includes THAT HHH, the one that
does abort and return 0, as that is what the code actually does.

Since your specific HHH doesn't completely simulate the input, its
simulation doesn't count.

And since changing HHH, changes the code of the PROGRAM DD, that isn't allowed.

The complete simuation of the input, as done by HHH1, shows that the
input is halting.

When the halting problem requires HHH to
report on the behavior of DD directly executed
from main, this is a category error because it
requires HHH to report on something besides
the behavior that the input to HHH(DD) maps to.

Nope, and that just shows that you don't beleive in words having
semantic meaning, as you think you can change that meaning.

All this shows is that you are just an ignorant liar.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

You have rigged this with a "Root" flag whch dynamically changes the
behavior of the second and subsequent calls to HHH, turning it into a
different procedure. That action also dynamically reconfgures DD into a different function, which doesn't terminate, while the original DD does.

If what you were saying were true, you would not need to employ invalid
tricks; you could properly demonstrate it with pure functions.

You don't understand that dynamically changing HHH is invalid, because
you don't understand that DD is built out of HHH. You incorrectly
believe there is always a single DD, no matter how HHH is redefined.

This is all because you have a grotesquely crude, ape-like intellect,
in addition to being a consummate crank.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 11/30/2025 7:44 PM, Kaz Kylheku wrote:

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

(1) It is a fact that this input to HHH(DD) does specify
non-halting behavior according to this definition
that you erased:

An input DD that halts for a simulating termination
analyzer HHH is defined as DD reaching its own simulated
"return" statement while DD is being simulated by HHH.

(2) It is a fact that HHH reports this.

The key most important fact is that the halting
problem *is* a category error because it requires
a halt decider to report on different behavior
than the actual behavior that its actual input
actually specifies.

This makes everything else that you say below moot
AKA totally beside the point and irrelevant.

You have rigged this with a "Root" flag whch dynamically changes the
behavior of the second and subsequent calls to HHH, turning it into a different procedure. That action also dynamically reconfgures DD into a different function, which doesn't terminate, while the original DD does.

If what you were saying were true, you would not need to employ invalid tricks; you could properly demonstrate it with pure functions.

You don't understand that dynamically changing HHH is invalid, because
you don't understand that DD is built out of HHH. You incorrectly
believe there is always a single DD, no matter how HHH is redefined.

This is all because you have a grotesquely crude, ape-like intellect,
in addition to being a consummate crank.

--
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

This required establishing a new foundation
for correct reasoning.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 11/30/25 9:12 PM, olcott wrote:

On 11/30/2025 7:44 PM, Kaz Kylheku wrote:

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

(1) It is a fact that this input to HHH(DD) does specify
    non-halting behavior according to this definition
    that you erased:

An input DD that halts for a simulating termination
analyzer HHH is defined as DD reaching its own simulated
"return" statement while DD is being simulated by HHH.

Which, since that ISN'T the definition of Halting, just shows that you
are nothing but an ignorant pathological liar that doesn't care about
the truth, an

(2) It is a fact that HHH reports this.

Which makes it incorrect.

Sorry, since you admit that you don't believe in following the actual semantics of the problem, you are just showing that you beleive that
lying is valid, and thus support the methods of those you claim are
trying to destroy the world, making you guilt of that as well.

The key most important fact is that the halting
problem *is* a category error because it requires
a halt decider to report on different behavior
than the actual behavior that its actual input
actually specifies.

No, your definition is a category error as you don't know the meaning of
the words.

Your statement is basically that a things can be different that what it
is defined to be if you don't like the definiion.

In other words, you are claiming the right to just lie.

This makes everything else that you say below moot
AKA totally beside the point and irrelevant.

Nope, it says that everything YOU have said is just a lie.

You have rigged this with a "Root" flag whch dynamically changes the
behavior of the second and subsequent calls to HHH, turning it into a
different procedure. That action also dynamically reconfgures DD into a
different function, which doesn't terminate, while the original DD does.

If what you were saying were true, you would not need to employ invalid
tricks; you could properly demonstrate it with pure functions.

You don't understand that dynamically changing HHH is invalid, because
you don't understand that DD is built out of HHH. You incorrectly
believe there is always a single DD, no matter how HHH is redefined.

This is all because you have a grotesquely crude, ape-like intellect,
in addition to being a consummate crank.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 2025-12-01, olcott <polcott333@gmail.com> wrote:

On 11/30/2025 7:44 PM, Kaz Kylheku wrote:

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

(1) It is a fact that this input to HHH(DD) does specify
non-halting behavior according to this definition
that you erased:

An input DD that halts for a simulating termination
analyzer HHH is defined as DD reaching its own simulated
"return" statement while DD is being simulated by HHH.

(2) It is a fact that HHH reports this.

The key most important fact is that the halting
problem *is* a category error because it requires

If you think the problem is a "category error", then ... fucking
stop discussing cases of it, with elaborate claims about
termination behavors.

If it is the case that the whole problem is a category error,
then everything that follows is erroneous and that is that.

a halt decider to report on different behavior
than the actual behavior that its actual input
actually specifies.

If you believe that, then stop trying to make halt deciders
which do that, and then claim they are correct.

This makes everything else that you say below moot
AKA totally beside the point and irrelevant.

But that would only be because it refers to your simulation work
and the claims you have based on it, which under the assumption that
halting is errneous, are all erroneous.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

olcott kirjoitti 30.11.2025 klo 18.52:

On 11/30/2025 10:15 AM, HAL 9000 wrote:

H must and always must halt for any input otherwise it isn't a halt
decider.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating halt decider H correctly simulates its
    input D until H correctly determines that its simulated D
    would never stop running unless aborted then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*HHH/DD has been fully operational code since above date* https://github.com/plolcott/x86utm/blob/master/Halt7.c

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);
}

HHH is a simulating termination analyzer that
includes DD in its domain.

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

Halt is defined as DD reaching its own simulated
"return" statement while DD is being simulated
by HHH.

When the halting problem requires HHH to
report on the behavior of DD directly executed
from main, this is a category error because it
requires HHH to report on something besides
the behavior that the input to HHH(DD) maps to.

As long as no proof is shown "provably correct" is no better than
"unproven and possible incorrect". But that does not matter as long
as it is not specified what Olcott is right about.
--
Mikko
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

olcott kirjoitti 1.12.2025 klo 4.12:

On 11/30/2025 7:44 PM, Kaz Kylheku wrote:

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

(1) It is a fact that this input to HHH(DD) does specify
    non-halting behavior according to this definition
    that you erased:

An input DD that halts for a simulating termination
analyzer HHH is defined as DD reaching its own simulated
"return" statement while DD is being simulated by HHH.

Which means that HHH is not a halting decider or a partial halting
decider. And that HHH does not serve any useful purpose.
--
Mikko
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 12/1/2025 3:31 AM, Mikko wrote:

olcott kirjoitti 30.11.2025 klo 18.52:

On 11/30/2025 10:15 AM, HAL 9000 wrote:

H must and always must halt for any input otherwise it isn't a halt
decider.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its
     input D until H correctly determines that its simulated D
     would never stop running unless aborted then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

*HHH/DD has been fully operational code since above date*
https://github.com/plolcott/x86utm/blob/master/Halt7.c

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);
}

HHH is a simulating termination analyzer that
includes DD in its domain.

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

Halt is defined as DD reaching its own simulated
"return" statement while DD is being simulated
by HHH.

When the halting problem requires HHH to
report on the behavior of DD directly executed
from main, this is a category error because it
requires HHH to report on something besides
the behavior that the input to HHH(DD) maps to.

As long as no proof is shown "provably correct" is no better than
"unproven and possible incorrect". But that does not matter as long
as it is not specified what Olcott is right about.

A prove is any sequence of steps that shows
that its conclusion is necessarily true. Its
a kind of semantic tautology.
--
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

This required establishing a new foundation
for correct reasoning.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 12/1/2025 3:39 AM, Mikko wrote:

olcott kirjoitti 1.12.2025 klo 4.12:

On 11/30/2025 7:44 PM, Kaz Kylheku wrote:

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

(1) It is a fact that this input to HHH(DD) does specify
     non-halting behavior according to this definition
     that you erased:

An input DD that halts for a simulating termination
analyzer HHH is defined as DD reaching its own simulated
"return" statement while DD is being simulated by HHH.

Which means that HHH is not a halting decider or a partial halting
decider. And that HHH does not serve any useful purpose.

If you carefully studied all of what I said you
would see that the halting problem is a category
error because it directly contradicts one of the
foundational axioms of computer science.

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

When we actually measure this property the only way
that we can: DD simulated by HHH cannot possibly reach
its own simulated "return" statement final halt state
while DD is being simulated by HHH. We see that DD
does specify a non-halting sequence.
--
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

This required establishing a new foundation
for correct reasoning.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 11/30/2025 11:34 PM, Kaz Kylheku wrote:

On 2025-12-01, olcott <polcott333@gmail.com> wrote:

On 11/30/2025 7:44 PM, Kaz Kylheku wrote:

On 2025-11-30, olcott <polcott333@gmail.com> wrote:

HHH does correctly report that DD simulated
by HHH (according to the semantics of the C
programming language) does not halt.

(1) It is a fact that this input to HHH(DD) does specify
non-halting behavior according to this definition
that you erased:

An input DD that halts for a simulating termination
analyzer HHH is defined as DD reaching its own simulated
"return" statement while DD is being simulated by HHH.

(2) It is a fact that HHH reports this.

The key most important fact is that the halting
problem *is* a category error because it requires

If you think the problem is a "category error", then ... fucking
stop discussing cases of it, with elaborate claims about
termination behavors.

If it is the case that the whole problem is a category error,
then everything that follows is erroneous and that is that.

a halt decider to report on different behavior
than the actual behavior that its actual input
actually specifies.

If you believe that, then stop trying to make halt deciders
which do that, and then claim they are correct.

This makes everything else that you say below moot
AKA totally beside the point and irrelevant.

But that would only be because it refers to your simulation work
and the claims you have based on it, which under the assumption that
halting is errneous, are all erroneous.

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);
}

That DD simulated by HHH according to the
semantics of the C programming language cannot
possibly reach its own "return" statement
final halt state while being simulated by HHH
conclusively proves that behavior that the
input to HHH(DD) specifies is non-halting behavior.

If you are overwhelmed by that much in a single
sentence I can rewrite it.
--
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

This required establishing a new foundation
for correct reasoning.
--- Synchronet 3.21a-Linux NewsLink 1.2