From Newsgroup: comp.theory

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
if (YouSayItHalts)
while(true)
;
else
return;
}

void OutputProgram()
{
printf("\n\n\nvoid LoopIfYouSayItHalts "
"(bool YouSayItHalts)\n");
printf("{\n");
printf(" if (YouSayItHalts)\n");
printf(" while(true)\n");
printf(" ;\n");
printf(" else\n");
printf(" return;\n");
printf("}\n\n\n");
}

void Prompt()
{
char choice = 'x';
printf("Does this program Halt?\n");
printf("(Y or N) translated to Boolean argument"
" to LoopIfYouSayItHalts()\n");
printf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
while (choice != 'Y'&& choice != 'y' &&
choice != 'N' && choice != 'n')
{
choice = getch();
if (choice != 'Y'&& choice != 'y' &&
choice != 'N' && choice != 'n')
printf("Must be (Y or N)\n");
}

if (choice == 'Y' || choice == 'y')
{
printf("\nWrong Answer!\n"
"LoopIfYouSayItHalts(true) is stuck in a loop!\n\n");
LoopIfYouSayItHalts(true);
}
if (choice == 'N' || choice == 'n')
{
printf("\nWrong Answer!\n"
"LoopIfYouSayItHalts(false) halts now!\n\n");
LoopIfYouSayItHalts(false);
}
}


int main()
{
OutputProgram();
Prompt();
return 0;
}
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n");
-a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}

int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}

void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}

void Prompt()
{
-a-achar choice = 'x';
-a-aprintf("Does this program Halt?\n");
-a-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a{
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a-a}

-a-aif (choice == 'Y' || choice == 'y')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >> -a-a-a LoopIfYouSayItHalts(true);
-a-a}
-a-aif (choice == 'N' || choice == 'n')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a-a}
}


int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}

Complete idiot !

Mensa scored me in the top 3%
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am 09.10.2025 um 19:40 schrieb olcott:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}

void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}

void Prompt()
{
-a-achar choice = 'x';
-a-aprintf("Does this program Halt?\n");
-a-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a{
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a-a}

-a-aif (choice == 'Y' || choice == 'y')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>> -a-a-a LoopIfYouSayItHalts(true);
-a-a}
-a-aif (choice == 'N' || choice == 'n')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a-a}
}


int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}

Complete idiot !

Mensa scored me in the top 3%

The IQ correlates largely with the psychological health,
but in the area of rCirCiparticularly high IQs, the opposite is true,
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 09/10/2025 19:12, Bonita Montero wrote:

Am 09.10.2025 um 19:40 schrieb olcott:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}

void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}

void Prompt()
{
-a-achar choice = 'x';
-a-aprintf("Does this program Halt?\n");
-a-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a{
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a-a}

-a-aif (choice == 'Y' || choice == 'y')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>> -a-a-a LoopIfYouSayItHalts(true);
-a-a}
-a-aif (choice == 'N' || choice == 'n')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a-a}
}


int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}

Complete idiot !

Mensa scored me in the top 3%

The IQ correlates largely with the psychological health,
but in the area of rCirCiparticularly high IQs, the opposite is true,

In the UK there are about two million people with a higher IQ
than that claimed by Olcott. In the USA, ten million. It's
nothing to write home about.

Judging by his contributions to this newsgroup, however, I am
inclined to doubt his claim. 128 isn't a stunning score, but I'd
expect much better reasoning ability from someone purporting to
be that bright.
--
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/9/2025 1:23 PM, Richard Heathfield wrote:

On 09/10/2025 19:12, Bonita Montero wrote:

Am 09.10.2025 um 19:40 schrieb olcott:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}

void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}

void Prompt()
{
-a-achar choice = 'x';
-a-aprintf("Does this program Halt?\n");
-a-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a{
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a-a}

-a-aif (choice == 'Y' || choice == 'y')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n");
-a-a-a LoopIfYouSayItHalts(true);
-a-a}
-a-aif (choice == 'N' || choice == 'n')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a-a}
}


int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}

Complete idiot !

Mensa scored me in the top 3%

The IQ correlates largely with the psychological health,
but in the area of rCirCiparticularly high IQs, the opposite is true,

In the UK there are about two million people with a higher IQ than that claimed by Olcott. In the USA, ten million. It's nothing to write home about.

Judging by his contributions to this newsgroup, however, I am inclined
to doubt his claim. 128 isn't a stunning score, but I'd expect much
better reasoning ability from someone purporting to be that bright.

You do not pay complete attention to the exact
meaning of my words never derives any correct rebuttal.

Have you ever carefully read the Linz proof?
How much and what kind of actual programming
experience do you have?
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-09, olcott <polcott333@gmail.com> wrote:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Complete idiot !

Mensa scored me in the top 3%

That's uninformative without knowing out of what village.
--
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.theory

On 2025-10-09, Richard Heathfield <rjh@cpax.org.uk> wrote:

Judging by his contributions to this newsgroup, however, I am
inclined to doubt his claim. 128 isn't a stunning score, but I'd
expect much better reasoning ability from someone purporting to
be that bright.

He may have been bright once, but his brain blew a gasket and threw a
rod since then. (If I must use analogies, make mine automotive.)

It's some combination of crazy + cognitive decline.

Early stages of dementia plus memory issues.

By some system he can recall some snippet of what he wrote in 2004,
but not what transpired in a debate 24 hours ago.

Basically, we here think we are all clinical hotshots who can
cure someone of Alzheimer's through Usenet.
--
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.theory

On 10/9/2025 2:50 PM, Kaz Kylheku wrote:

On 2025-10-09, olcott <polcott333@gmail.com> wrote:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Complete idiot !

Mensa scored me in the top 3%

That's uninformative without knowing out of what village.

Gen Pop
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/9/2025 2:56 PM, Kaz Kylheku wrote:

On 2025-10-09, Richard Heathfield <rjh@cpax.org.uk> wrote:

Judging by his contributions to this newsgroup, however, I am
inclined to doubt his claim. 128 isn't a stunning score, but I'd
expect much better reasoning ability from someone purporting to
be that bright.

He may have been bright once, but his brain blew a gasket and threw a
rod since then. (If I must use analogies, make mine automotive.)

It's some combination of crazy + cognitive decline.

Early stages of dementia plus memory issues.

By some system he can recall some snippet of what he wrote in 2004,
but not what transpired in a debate 24 hours ago.

Basically, we here think we are all clinical hotshots who can
cure someone of Alzheimer's through Usenet.

So I take it you did not understand my fully
operational C translation of my 2004 Pseudo code
that I did just today.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/9/2025 10:40 AM, olcott wrote:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

[...]

Complete idiot !

Mensa scored me in the top 3%

Wow. ;^o
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/9/2025 2:11 PM, Chris M. Thomasson wrote:

On 10/9/2025 10:40 AM, olcott wrote:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

[...]

Complete idiot !

Mensa scored me in the top 3%

Wow. ;^o

Does that mean that you might be 97% moron?
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am 09.10.2025 um 20:23 schrieb Richard Heathfield:

Judging by his contributions to this newsgroup, however, I am inclined
to doubt his claim. ...

I didn'T believe that also.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n");
-a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-09 18:12:07 +0000, Bonita Montero said:

Am 09.10.2025 um 19:40 schrieb olcott:

On 10/9/2025 12:13 PM, Bonita Montero wrote:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a-a if (YouSayItHalts)
-a-a-a-a while(true)
-a-a-a-a-a-a ;
-a-a else
-a-a-a-a return;
}

void OutputProgram()
{
-a-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a-a printf("{\n");
-a-a printf("-a if (YouSayItHalts)\n");
-a-a printf("-a-a-a while(true)\n");
-a-a printf("-a-a-a-a-a ;\n");
-a-a printf("-a else\n");
-a-a printf("-a-a-a return;\n");
-a-a printf("}\n\n\n");
}

void Prompt()
{
-a-achar choice = 'x';
-a-aprintf("Does this program Halt?\n");
-a-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-a-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-a-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a{
-a-a-a choice = getch();
-a-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a-a printf("Must be (Y or N)\n");
-a-a}

-a-aif (choice == 'Y' || choice == 'y')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>> -a-a-a LoopIfYouSayItHalts(true);
-a-a}
-a-aif (choice == 'N' || choice == 'n')
-a-a{
-a-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a-a LoopIfYouSayItHalts(false);
-a-a}
}


int main()
{
-a-a OutputProgram();
-a-a Prompt();
-a-a return 0;
}

Complete idiot !

Mensa scored me in the top 3%

The IQ correlates largely with the psychological health,
but in the area of rCirCiparticularly high IQs, the opposite is true,

In top 3% is not particularly high. As observed in Mensa meetings,
in the top 2% stupidity is possible though perhaps not common.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/10/2025 2:57 AM, Mikko wrote:

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>> -a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.

It is a matter of thinking at a deeper philosophical
level to verify whether or not the elements that comprise
undecidable instances of decision problems fit coherently
together.

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors
and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance
of the pertinent proven mathematics.

To those can be added the halting problemists.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--
Alan Mackenzie (Nuremberg, Germany).

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/10/2025 1:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors
and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance
of the pertinent proven mathematics.

To those can be added the halting problemists.

Not when the halting problem is defined to
require a halt decider to have an ability
that Turing machine deciders never have:

Turing machine deciders only compute the
mapping from their inputs to a semantic or
syntactic property that this actual input
actually specifies.

The input to HHH(DD) specifies that it calls
HHH(DD) that requires HHH to simulate an instance
of itself simulating an instance of DD. To ignore
this is to be in psychological denial of reality.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

olcott <polcott333@gmail.com> wrote:

On 10/10/2025 1:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors
and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance
of the pertinent proven mathematics.

To those can be added the halting problemists.

Not when the halting problem is defined to
require a halt decider to have an ability
that Turing machine deciders never have:

Turing machine deciders only compute the
mapping from their inputs to a semantic or
syntactic property that this actual input
actually specifies.

The input to HHH(DD) specifies that it calls
HHH(DD) that requires HHH to simulate an instance
of itself simulating an instance of DD. To ignore
this is to be in psychological denial of reality.

I rest my case.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--
Alan Mackenzie (Nuremberg, Germany).

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/10/2025 4:03 PM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> wrote:

On 10/10/2025 1:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors >>> and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance >>> of the pertinent proven mathematics.

To those can be added the halting problemists.

Not when the halting problem is defined to
require a halt decider to have an ability
that Turing machine deciders never have:

Turing machine deciders only compute the
mapping from their inputs to a semantic or
syntactic property that this actual input
actually specifies.

The input to HHH(DD) specifies that it calls
HHH(DD) that requires HHH to simulate an instance
of itself simulating an instance of DD. To ignore
this is to be in psychological denial of reality.

I rest my case.

So you agree that HHH(DD)==0 because the call
from the simulated DD to the simulated HHH(DD)
cannot possibly return.

HHH1(DD)==1 because the call from the simulated DD
to the simulated HHH(DD) returns.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

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

On 10/10/2025 1:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors
and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance
of the pertinent proven mathematics.

To those can be added the halting problemists.

Not when the halting problem is defined to
require a halt decider to have an ability
that Turing machine deciders never have:

But we didn't //know// that until some smart people came up with the
halting question, and then delved into it!

Someone had to ask, can an algorithm exist (i.e. Turing computation)
which can decide whether any Turing machine can halt?

The answer turned out to be no.

I don't think you would have come up with that on your own, with your
puny intellect; all you can do is criticize the work of others.

Anyway, that question is what we call "the halting problem".

If you think you have another question, you need another term for it;
that one is taken.

Turing machine deciders only compute the
mapping from their inputs to a semantic or
syntactic property that this actual input
actually specifies.

And (1) that's all we have; and (2) it's not enough to decide halting.

The input to HHH(DD) specifies that it calls
HHH(DD) that requires HHH to simulate an instance
of itself simulating an instance of DD. To ignore
this is to be in psychological denial of reality.

Yeah yeah yeah. Look, idiot, everyone knows that a simulation
of a machine doesn't decide halting. It is exactly the same as just
running the program and waiting---only likely slower. For those
programs that do halt, where you are not waiting forever, it
takes longer for the simulation to tell you that they halt.

Simulation does not even begin to be a viable halting decider.

We already have simulation when we are asking the question: we have ways
of running our programs and would like to know if there is a way to tell
that they will not halt, //without// running them.

It is //obvious// that if simulation is proposed as a decider (which
is obviously a non-starter) and if the diagonal trick is perpetrated
against the simulator, you get non-termination: a simulator does
not terminate when deciding its diagonal case.

So ... what ....
--
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.theory

On 2025-10-10, Alan Mackenzie <acm@muc.de> wrote:

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors
and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance
of the pertinent proven mathematics.

But we have a special Genius here who /knows/ that trisecting is
impossible. But that's just the "conventional wisdom" of those
"learn-by-rote" idiots, which is only impossible due to asking
an incorrect question.

If we /redefine/ the problem as quadrisecting the angle, amd then just
multiply the resulting quarter angle by 4/3, ... ta daa!

And notice how 4/3 could come from taking 1/3 from each of the quarters
and adding them together!

So recursively, we just have to trisect the quarters: a problem
we have already solved above.

See, that's why I'm top 3% of Gen Pop according to Mensa!
--
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.theory

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

On 10/10/2025 4:03 PM, Alan Mackenzie wrote:

I rest my case.

So you agree that HHH(DD)==0 because the call

No, that's not what "rest my case" means; you have the reading
comprehension of a chimpanzee or something.

from the simulated DD to the simulated HHH(DD)
cannot possibly return.

HHH(DD) does return; it returns zero, whether
simulated or not.

//Not taking the simulation far enough to show that
the simulated HHH(DD) returns is not the same as HHH(DD) being a
non-returning computation.//

HHH1(DD)==1 because the call from the simulated DD
to the simulated HHH(DD) returns.

HHH(DD) and HHH1(DD) are deciding exactly the same case.

The case is diagonal against HHH, so HHH cannot get the
answer. It doesn't return at all.

The case is /not/ diagonal against HHH1. HHH1 is a simulator
which steps the argument correctly for as long as it takes
for it to terminate. It finds that DD terminates and
returns the correct answer.
--
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.theory

On 2025-10-10 15:44:24 +0000, olcott said:

On 10/10/2025 2:57 AM, Mikko wrote:

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>> -a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.

It is a matter of thinking at a deeper philosophical
level to verify whether or not the elements that comprise
undecidable instances of decision problems fit coherently
together.

No, it is not. It is a matter of ordinary logic.

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

We can regard the world as the infallible word of God. We believe in
the ordinary logic because in the world God created we have found no
examples where the ordinary logic derves a false conclusion ffom true
premises.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 4:21 AM, Mikko wrote:

On 2025-10-10 15:44:24 +0000, olcott said:

On 10/10/2025 2:57 AM, Mikko wrote:

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>>> -a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.

It is a matter of thinking at a deeper philosophical
level to verify whether or not the elements that comprise
undecidable instances of decision problems fit coherently
together.

No, it is not. It is a matter of ordinary logic.

Sure when you are a mindless robot and take the
conventional view as your hard-coded programming.

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

We can regard the world as the infallible word of God. We believe in
the ordinary logic because in the world God created we have found no
examples where the ordinary logic derves a false conclusion ffom true premises.

The principle of explosion is the only aspect
of logic that I am aware of as definitely
incorrect. When all inference is by semantic
logical entailment then the POE is proved to
be incorrect.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 4:21 AM, Mikko wrote:

On 2025-10-10 15:44:24 +0000, olcott said:

On 10/10/2025 2:57 AM, Mikko wrote:

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>>> -a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.

It is a matter of thinking at a deeper philosophical
level to verify whether or not the elements that comprise
undecidable instances of decision problems fit coherently
together.

No, it is not. It is a matter of ordinary logic.

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

We can regard the world as the infallible word of God. We believe in
the ordinary logic because in the world God created we have found no
examples where the ordinary logic derves a false conclusion ffom true premises.

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that the
following requirements can be satisfied:


Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes the following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/10/2025 7:16 PM, Kaz Kylheku wrote:

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

On 10/10/2025 1:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

In comp.theory olcott <polcott333@gmail.com> wrote:

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

No, not blasphemy, just stupidity. The circle squarers, angle trisectors >>> and cube duplicators are not blasphemous, just stupid. Their
intelligence doesn't reach the level needed to appreciate their ignorance >>> of the pertinent proven mathematics.

To those can be added the halting problemists.

Not when the halting problem is defined to
require a halt decider to have an ability
that Turing machine deciders never have:

But we didn't //know// that until some smart people came up with the
halting question, and then delved into it!

Someone had to ask, can an algorithm exist (i.e. Turing computation)
which can decide whether any Turing machine can halt?

The answer turned out to be no.

I don't think you would have come up with that on your own, with your
puny intellect; all you can do is criticize the work of others.

Anyway, that question is what we call "the halting problem".

If you think you have another question, you need another term for it;
that one is taken.

Turing machine deciders only compute the
mapping from their inputs to a semantic or
syntactic property that this actual input
actually specifies.

And (1) that's all we have; and (2) it's not enough to decide halting.

The input to HHH(DD) specifies that it calls
HHH(DD) that requires HHH to simulate an instance
of itself simulating an instance of DD. To ignore
this is to be in psychological denial of reality.

Yeah yeah yeah. Look, idiot, everyone knows that a simulation
of a machine doesn't decide halting. It is exactly the same as just
running the program and waiting---only likely slower. For those
programs that do halt, where you are not waiting forever, it
takes longer for the simulation to tell you that they halt.

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns. You keep calling me an idiot and I
will start calling you a doofus whenever you act like
a doofus like right now. I woild greatly prefer a
professional level of decorum.

Simulation does not even begin to be a viable halting decider.

We already have simulation when we are asking the question: we have ways
of running our programs and would like to know if there is a way to tell
that they will not halt, //without// running them.

It is //obvious// that if simulation is proposed as a decider (which
is obviously a non-starter) and if the diagonal trick is perpetrated
against the simulator, you get non-termination: a simulator does
not terminate when deciding its diagonal case.

So ... what ....

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/10/2025 7:24 PM, Kaz Kylheku wrote:

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

On 10/10/2025 4:03 PM, Alan Mackenzie wrote:

I rest my case.

So you agree that HHH(DD)==0 because the call

No, that's not what "rest my case" means; you have the reading
comprehension of a chimpanzee or something.

from the simulated DD to the simulated HHH(DD)
cannot possibly return.

HHH(DD) does return; it returns zero, whether
simulated or not.

//Not taking the simulation far enough to show that
the simulated HHH(DD) returns is not the same as HHH(DD) being a non-returning computation.//

HHH1(DD)==1 because the call from the simulated DD
to the simulated HHH(DD) returns.

HHH(DD) and HHH1(DD) are deciding exactly the same case.

The case is diagonal against HHH, so HHH cannot get the
answer. It doesn't return at all.

The case is /not/ diagonal against HHH1. HHH1 is a simulator
which steps the argument correctly for as long as it takes
for it to terminate. It finds that DD terminates and
returns the correct answer.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

The input to HHH(DD) specifies that DD calls HHH(DD)
in recursive simulation, such that the call from the
simulated DD to the simulated HHH(DD) cannot possibly
return. *This cannot be correctly ignored*

The input to HHH1(DD) specifies that the call from the
simulated DD to the simulated HHH(DD) does return.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern
because it exists in the halting computation DD.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern
because it exists in the halting computation DD.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

The input to HHH(DD) specifies that DD calls HHH(DD)
in recursive simulation, such that the call from the
simulated DD to the simulated HHH(DD) cannot possibly
return. *This cannot be correctly ignored*

The input to HHH1(DD) specifies that the call from the
simulated DD to the simulated HHH(DD) does return.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 9:44 AM, olcott wrote:

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern
because it exists in the halting computation DD.

<repeat of previously refuted point / irrelevant copy/paste reply>

This constitutes your admission the pattern that HHH matches is *not* in
fact a non-halting behavior pattern.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that the following requirements can be satisfied:

Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes the following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly

That is the false premise.
Turing machine halt deciders never ever compute the
mapping from any actual executing Turing machine.
Instead they always use the proxy of a finite string
machine description.

This is a perfectly good proxy in that the input
finite string almost always specifies the same
behavior as the directly executed Turing machine.

Even in this case the halt decider is not directly
computing the halt status for any directly executed
Turing machine. It is only computing the halt status
that its proxy machine description specifies.

The only correct way to directly measure the actual
behavior that an actual input actually specifies
is when input D is correctly simulated by simulating
halt decider H.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 10:05 AM, olcott wrote:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that the
following requirements can be satisfied:


Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes the
following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the
mapping from any actual executing Turing machine.

But because a Turing machine always does exactly the same thing every
time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string
machine description.

This is a perfectly good proxy in that the input
finite string almost always specifies the same
behavior as the directly executed Turing machine.

Yes always. This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly
computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

It is only computing the halt status
that its proxy machine description specifies.

Which by the meaning of the words is the halt status of the machine
described.

The only correct way to directly measure the actual
behavior that an actual input actually specifies

Is to determine which machine the finite string is a description of.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 09:05:20 -0500 schrieb olcott:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems are also incorrect.
They start with incoherent premises.

Thereby proving the premise false, for example the premise that the
following requirements can be satisfied:
Given any algorithm (i.e. a fixed immutable sequence of instructions) X
described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly

Please stop spamming.

That is the false premise.
Turing machine halt deciders never ever compute the mapping from any
actual executing Turing machine.

Duh.

Instead they always use the proxy of a
finite string machine description.
This is a perfectly good proxy in that the input finite string almost
always specifies the same behavior as the directly executed Turing
machine.

Even in this case the halt decider is not directly computing the halt
status for any directly executed Turing machine. It is only computing
the halt status that its proxy machine description specifies.

The only correct way to directly measure the actual behavior that an
actual input actually specifies is when input D is correctly* simulated
by simulating halt decider H.

*except you can stop simulating whenever you want.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that the
following requirements can be satisfied:


Given any algorithm (i.e. a fixed immutable sequence of instructions)
X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes the
following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the
mapping from any actual executing Turing machine.

But because a Turing machine always does exactly the same thing every
time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string
machine description.

This is a perfectly good proxy in that the input
finite string almost always specifies the same
behavior as the directly executed Turing machine.

Yes always.-a This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly
computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.
That you stubbornly ignore this proof is merely stupid.

It is only computing the halt status
that its proxy machine description specifies.

Which by the meaning of the words is the halt status of the machine described.

The only correct way to directly measure the actual
behavior that an actual input actually specifies

Is to determine which machine the finite string is a description of.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 9:30 AM, joes wrote:

Am Sat, 11 Oct 2025 09:05:20 -0500 schrieb olcott:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems are also incorrect.
They start with incoherent premises.

Thereby proving the premise false, for example the premise that the
following requirements can be satisfied:
Given any algorithm (i.e. a fixed immutable sequence of instructions) X
described as <X> with input Y:
A solution to the halting problem is an algorithm H that computes the
following mapping:
(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly

Please stop spamming.

That is the false premise.
Turing machine halt deciders never ever compute the mapping from any
actual executing Turing machine.

Duh.

Instead they always use the proxy of a
finite string machine description.
This is a perfectly good proxy in that the input finite string almost
always specifies the same behavior as the directly executed Turing
machine.

Even in this case the halt decider is not directly computing the halt
status for any directly executed Turing machine. It is only computing
the halt status that its proxy machine description specifies.

The only correct way to directly measure the actual behavior that an
actual input actually specifies is when input D is correctly* simulated
by simulating halt decider H.

*except you can stop simulating whenever you want.

That is not the way that simulating halt deciders work.

<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 09:35:11 -0500 schrieb olcott:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the mapping from any actual executing Turing
machine.

But because a Turing machine always does exactly the same thing every
time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string machine
description.
This is a perfectly good proxy in that the input finite string almost
always specifies the same behavior as the directly executed Turing
machine.

Yes always.-a This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.

It is only computing the halt status that its proxy machine
description specifies.

Which by the meaning of the words is the halt status of the machine
described.

The only correct way to directly measure the actual behavior that an
actual input actually specifies

Is to determine which machine the finite string is a description of.

UTMs prove it is possible to compute the direct execution of a TM
from its description.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 10:09 AM, joes wrote:

Am Sat, 11 Oct 2025 09:35:11 -0500 schrieb olcott:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the mapping from any actual executing Turing
machine.

But because a Turing machine always does exactly the same thing every
time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string machine
description.
This is a perfectly good proxy in that the input finite string almost
always specifies the same behavior as the directly executed Turing
machine.

Yes always.-a This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.

It is only computing the halt status that its proxy machine
description specifies.

Which by the meaning of the words is the halt status of the machine
described.

The only correct way to directly measure the actual behavior that an
actual input actually specifies

Is to determine which machine the finite string is a description of.

UTMs prove it is possible to compute the direct execution of a TM
from its description.

It is a different sequence of moves unless the input
calls this same UTM. All the LLM's immediately get
this and it need not even be explained to them. They
all get this on the basis of this single principle:

<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 10:44:43 -0500 schrieb olcott:

On 10/11/2025 10:09 AM, joes wrote:

Am Sat, 11 Oct 2025 09:35:11 -0500 schrieb olcott:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.

It is only computing the halt status that its proxy machine
description specifies.

Which by the meaning of the words is the halt status of the machine
described.

The only correct way to directly measure the actual behavior that an >>>>> actual input actually specifies

Is to determine which machine the finite string is a description of.

UTMs prove it is possible to compute the direct execution of a TM from
its description.

It is a different sequence of moves unless the input calls this same
UTM.

ITYM rCRexcept ifrCY
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 11:35 AM, joes wrote:

Am Sat, 11 Oct 2025 10:44:43 -0500 schrieb olcott:

On 10/11/2025 10:09 AM, joes wrote:

Am Sat, 11 Oct 2025 09:35:11 -0500 schrieb olcott:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly computing the halt status for any directly executed >>>>>> Turing machine.

But the description contains all information to know what will happen >>>>> when one is directly executed.

Proven to be counter-factual.

It is only computing the halt status that its proxy machine
description specifies.

Which by the meaning of the words is the halt status of the machine
described.

The only correct way to directly measure the actual behavior that an >>>>>> actual input actually specifies

Is to determine which machine the finite string is a description of.

UTMs prove it is possible to compute the direct execution of a TM from
its description.

It is a different sequence of moves unless the input calls this same
UTM.

ITYM rCRexcept ifrCY

I will repeat this 10,000 times if that is what
it takes to get a proper reply.

It is a different sequence of moves unless the input
calls this same UTM. All the LLM's immediately get
this and it need not even be explained to them. They
all get this on the basis of this single principle:

<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 11:38:33 -0500 schrieb olcott:

On 10/11/2025 11:35 AM, joes wrote:

Am Sat, 11 Oct 2025 10:44:43 -0500 schrieb olcott:

On 10/11/2025 10:09 AM, joes wrote:

Am Sat, 11 Oct 2025 09:35:11 -0500 schrieb olcott:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly computing the halt status for any directly
executed Turing machine.

But the description contains all information to know what will
happen when one is directly executed.

Proven to be counter-factual.

What is it missing?

It is only computing the halt status that its proxy machine
description specifies.

Which by the meaning of the words is the halt status of the machine >>>>>> described.

The only correct way to directly measure the actual behavior that >>>>>>> an actual input actually specifies

What does the input to
int SiMULAtE(ptr DD) { // imagine the same signature as HHH here
step(DD);
return 0;
}
specify?

Is to determine which machine the finite string is a description
of.

UTMs prove it is possible to compute the direct execution of a TM
from its description.

It is a different sequence of moves unless the input calls this same
UTM.

ITYM rCRexcept ifrCY

I will repeat this 10,000 times if that is what it takes to get a proper reply.

ThatrCOs not it.
Anyway we call a simulator that does not produce the same sequence
rCRbuggyrCY. As per your statement that is all of them except the one
the input calls (what if it doesnrCOt?).
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 11:54 AM, joes wrote:

Am Sat, 11 Oct 2025 11:38:33 -0500 schrieb olcott:

On 10/11/2025 11:35 AM, joes wrote:

Am Sat, 11 Oct 2025 10:44:43 -0500 schrieb olcott:

On 10/11/2025 10:09 AM, joes wrote:

Am Sat, 11 Oct 2025 09:35:11 -0500 schrieb olcott:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly computing the halt status for any directly
executed Turing machine.

But the description contains all information to know what will
happen when one is directly executed.

Proven to be counter-factual.

What is it missing?

It is only computing the halt status that its proxy machine
description specifies.

Which by the meaning of the words is the halt status of the machine >>>>>>> described.

The only correct way to directly measure the actual behavior that >>>>>>>> an actual input actually specifies

What does the input to
int SiMULAtE(ptr DD) { // imagine the same signature as HHH here
step(DD);
return 0;
}
specify?

Is to determine which machine the finite string is a description >>>>>>> of.

UTMs prove it is possible to compute the direct execution of a TM
from its description.

It is a different sequence of moves unless the input calls this same
UTM.

ITYM rCRexcept ifrCY

I will repeat this 10,000 times if that is what it takes to get a proper
reply.

ThatrCOs not it.
Anyway we call a simulator that does not produce the same sequence rCRbuggyrCY. As per your statement that is all of them except the one
the input calls (what if it doesnrCOt?).

The input to HHH(DD) specifies that DD calls HHH(DD)
in recursive simulation, such that the call from the
simulated DD to the simulated HHH(DD) cannot possibly
return. *This cannot be correctly ignored*

The input to HHH1(DD) specifies that the call from the
simulated DD to the simulated HHH(DD) does return.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that the
following requirements can be satisfied:


Given any algorithm (i.e. a fixed immutable sequence of
instructions) X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes
the following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the
mapping from any actual executing Turing machine.

But because a Turing machine always does exactly the same thing every
time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string
machine description.

This is a perfectly good proxy in that the input
finite string almost always specifies the same
behavior as the directly executed Turing machine.

Yes always.-a This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly
computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.

In other words, you don't believe in semantic tautologies.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 2:14 PM, dbush wrote:

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that the >>>>> following requirements can be satisfied:


Given any algorithm (i.e. a fixed immutable sequence of
instructions) X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes
the following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed
directly

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the
mapping from any actual executing Turing machine.

But because a Turing machine always does exactly the same thing every
time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string
machine description.

This is a perfectly good proxy in that the input
finite string almost always specifies the same
behavior as the directly executed Turing machine.

Yes always.-a This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly
computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.

In other words, you don't believe in semantic tautologies.

The sequence of moves specified by DD correctly
simulated by HHH is different than the sequence
of moves specified DD correctly simulated by HHH1
because DD calls HHH(DD) in recursive simulation
and DD does not call HHH1 at all.

What I said is proven completely true entirely
on the basis of the meaning its its words. This
would seem to mean that you are either incompetent
or a liar.

All the LLMs systems immediately figured this
out on their own without ever being told. One
thing that these LLM systems excel at is
correctly assessing semantic logical entailment.

There is no opportunity for hallucination when
their only basis is semantic logical entailment
on the basis of axioms that are provided to it.

It is only when they don't have all the facts
that they tend to just make stuff up. When the
axiomatic basis is provided to them they have
zero wiggle room for just making stuff up.

This is the entire axiomatic basis provided to the
LLM systems that figured out entirely one their own
my exact same conclusions.

<Input to LLM systems>
Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/11/2025 3:33 PM, olcott wrote:

On 10/11/2025 2:14 PM, dbush wrote:

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

On 10/11/2025 8:23 AM, dbush wrote:

On 10/11/2025 9:17 AM, olcott wrote:

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Thereby proving the premise false, for example the premise that
the following requirements can be satisfied:


Given any algorithm (i.e. a fixed immutable sequence of
instructions) X described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes >>>>>> the following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly >>>>>> (<X>,Y) maps to 0 if and only if X(Y) does not halt when executed >>>>>> directly

That is the false premise.

As Turing and Linz proved

Turing machine halt deciders

i.e. those that satisfy the above mapping

never ever compute the
mapping from any actual executing Turing machine.

But because a Turing machine always does exactly the same thing
every time for a given input, doing so isn't required.

Instead they always use the proxy of a finite string
machine description.

This is a perfectly good proxy in that the input
finite string almost always specifies the same
behavior as the directly executed Turing machine.

Yes always.-a This is proven true by the meaning of the words.

Even in this case the halt decider

i.e. a machine that satisfies the above mapping

is not directly
computing the halt status for any directly executed
Turing machine.

But the description contains all information to know what will
happen when one is directly executed.

Proven to be counter-factual.

In other words, you don't believe in semantic tautologies.

The sequence of moves specified by DD correctly
simulated by HHH

Does not exist because the fixed immutable set of instructions known as
HHH aborts its simulation of DD in violation of the x86 language,
therefore DD is not correctly simulated by HHH.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-11 13:44:09 +0000, olcott said:

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern
because it exists in the halting computation DD.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

Another way is to use partial halting deciders that are proven to
never give a wrong answer until one of them gives some answer.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-11 13:15:58 +0000, olcott said:

On 10/11/2025 4:21 AM, Mikko wrote:

On 2025-10-10 15:44:24 +0000, olcott said:

On 10/10/2025 2:57 AM, Mikko wrote:

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>>>> -a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.

It is a matter of thinking at a deeper philosophical
level to verify whether or not the elements that comprise
undecidable instances of decision problems fit coherently
together.

No, it is not. It is a matter of ordinary logic.

Sure when you are a mindless robot and take the
conventional view as your hard-coded programming.

Your ad hominem argument is both false and irrelevant.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-11 13:17:18 +0000, olcott said:

On 10/11/2025 4:21 AM, Mikko wrote:

On 2025-10-10 15:44:24 +0000, olcott said:

On 10/10/2025 2:57 AM, Mikko wrote:

On 2025-10-09 17:13:36 +0000, Bonita Montero said:

Am 09.10.2025 um 17:33 schrieb olcott:

// The pseudo code shown below has been converted
// to C compiled as C++
// the pseudo code is easier to read.
// the C code is fully operational.

/***
As I first published here back in 2004:
On 6/23/2004 9:34 PM, Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
-a-a-a-a if YouSayItHalts () then
-a-a-a-a-a-a-a-a while true do {}
-a-a-a-a-a else
-a-a-a-a-a-a-a-a return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
-a-a translated to Boolean as the function's input
-a-a parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

***/

#include <stdio.h>
#include <conio.h>

void LoopIfYouSayItHalts(bool YouSayItHalts)
{
-a if (YouSayItHalts)
-a-a-a while(true)
-a-a-a-a-a ;
-a else
-a-a-a return;
}

void OutputProgram()
{
-a printf("\n\n\nvoid LoopIfYouSayItHalts "
-a-a-a-a-a-a-a-a "(bool YouSayItHalts)\n");
-a printf("{\n");
-a printf("-a if (YouSayItHalts)\n");
-a printf("-a-a-a while(true)\n");
-a printf("-a-a-a-a-a ;\n");
-a printf("-a else\n");
-a printf("-a-a-a return;\n");
-a printf("}\n\n\n");
}

void Prompt()
{
-achar choice = 'x';
-aprintf("Does this program Halt?\n");
-aprintf("(Y or N) translated to Boolean argument"
-a-a-a-a-a-a-a " to LoopIfYouSayItHalts()\n");
-aprintf("\nPlease ONLY PROVIDE CORRECT (Y or N) ANSWERS!\n");
-awhile (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a{
-a-a choice = getch();
-a-a if (choice != 'Y'&& choice != 'y' &&
-a-a-a-a-a-a choice != 'N' && choice != 'n')
-a-a-a-a printf("Must be (Y or N)\n");
-a}

-aif (choice == 'Y' || choice == 'y')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(true) is stuck in a loop!\n\n"); >>>>>> -a-a LoopIfYouSayItHalts(true);
-a}
-aif (choice == 'N' || choice == 'n')
-a{
-a-a printf("\nWrong Answer!\n"
-a-a-a-a-a-a-a-a-a "LoopIfYouSayItHalts(false) halts now!\n\n");
-a-a LoopIfYouSayItHalts(false);
-a}
}


int main()
{
-a OutputProgram();
-a Prompt();
-a return 0;
}

Complete idiot !

I don't think a complete idiot could write a stupid C program.
The lack of the ability to think rationally is common among
normal humans.

It is a matter of thinking at a deeper philosophical
level to verify whether or not the elements that comprise
undecidable instances of decision problems fit coherently
together.

No, it is not. It is a matter of ordinary logic.

The non-philosophical position is to take conventional
wisdom as the infallible word of God and to consider
any challenges to this mere conventional view as a sort
of blasphemy to be ridiculed.

We can regard the world as the infallible word of God. We believe in
the ordinary logic because in the world God created we have found no
examples where the ordinary logic derves a false conclusion ffom true
premises.

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Whether a given Turing machine halts with a given input always has
a correct answer. Finding that answer is not always easy, especially
for computations that do not halt. Conseqeuntly there are known
computations with a not yet determined halting status.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/12/2025 4:25 AM, Mikko wrote:

On 2025-10-11 13:44:09 +0000, olcott said:

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern
because it exists in the halting computation DD.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

Another way is to use partial halting deciders that are proven to
never give a wrong answer until one of them gives some answer.

Determining the halt status of an input that
does the opposite of whatever value is returned
is as bogus as determining whether or not this
Liar Paradox sentence is true or false:
"This sentence is not true".

?- LP = not(true(LP)).
LP = not(true(LP)).

?- unify_with_occurs_check(LP, not(true(LP))).
false.

This proves that LP has an infinitely recursive
structure that never resolves to a truth value.

My own Minimal Type Theory proves the same thing.
LP := ~True(LP)
00 ~ 01
01 True 00

Minimal Type Theory (YACC BNF) https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF --
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/12/2025 4:34 AM, Mikko wrote:

On 2025-10-11 13:17:18 +0000, olcott said:

On 10/11/2025 4:21 AM, Mikko wrote:

We can regard the world as the infallible word of God. We believe in
the ordinary logic because in the world God created we have found no
examples where the ordinary logic derves a false conclusion ffom true
premises.

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Whether a given Turing machine halts with a given input always has
a correct answer. Finding that answer is not always easy, especially
for computations that do not halt. Conseqeuntly there are known
computations with a not yet determined halting status.

When the halt status of HHH(DD) is determined on
the basis of the behavior that the actual input
actually specifies as measured by DD simulated by
HHH according to the semantics of the language
then HHH is correct to reject its input as non halting.

The behavior of the directly executed DD() has never
contradicted this because no directly executed DD()
has ever been exactly one and the same as the argument
to HHH(DD).
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 08:44:09 -0500 schrieb olcott:

The input to HHH(DD) specifies that DD calls HHH(DD)
in recursive simulation, such that the call from the simulated DD to the simulated HHH(DD) cannot possibly return.

DD does not specify a call to some non-halting function. HHH most
assuredly halts.

The input to HHH1(DD) specifies that the call from the simulated DD to
the simulated HHH(DD) does return.

How does it do that when the input is the identical DD?
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-12 15:09:08 +0000, olcott said:

On 10/12/2025 4:25 AM, Mikko wrote:

On 2025-10-11 13:44:09 +0000, olcott said:

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern
because it exists in the halting computation DD.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

Another way is to use partial halting deciders that are proven to
never give a wrong answer until one of them gives some answer.

Determining the halt status of an input that
does the opposite of whatever value is returned
is as bogus as determining whether or not this
Liar Paradox sentence is true or false:
"This sentence is not true".

No, it is not. If a partial halt decider that never gives a wrong
answer syas that that computation halts then we can trust that it
halts and if it says that it does not halt then we can trust that
it does not halt. If it does not answer at all then we can try
other partial deciders until we find one that does.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-12 15:34:43 +0000, olcott said:

On 10/12/2025 4:34 AM, Mikko wrote:

On 2025-10-11 13:17:18 +0000, olcott said:

On 10/11/2025 4:21 AM, Mikko wrote:

We can regard the world as the infallible word of God. We believe in
the ordinary logic because in the world God created we have found no
examples where the ordinary logic derves a false conclusion ffom true
premises.

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Whether a given Turing machine halts with a given input always has
a correct answer. Finding that answer is not always easy, especially
for computations that do not halt. Conseqeuntly there are known
computations with a not yet determined halting status.

When the halt status of HHH(DD) is determined on
the basis of the behavior that the actual input
actually specifies as measured by DD simulated by
HHH according to the semantics of the language
then HHH is correct to reject its input as non halting.

As you said in news:10cbgd7$7ips$1@dont-email.me the expression
"DD simulated by HHH" is ambigous and therefore the above can
be interpreted as a false sentence.

Anyway, from the meaning of the words follows that HHH rejects DD
as non-halting its decision is incorrect.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 3:28 AM, joes wrote:

Am Sat, 11 Oct 2025 08:44:09 -0500 schrieb olcott:

The input to HHH(DD) specifies that DD calls HHH(DD)
in recursive simulation, such that the call from the simulated DD to the
simulated HHH(DD) cannot possibly return.

DD does not specify a call to some non-halting function. HHH most
assuredly halts.

Halts is defined as DD correctly simulated by HHH
does reach its own simulated "return" statement
final halt state on its own without intervention.

The input to HHH1(DD) specifies that the call from the simulated DD to
the simulated HHH(DD) does return.

How does it do that when the input is the identical DD?

I have explained this no less than 100 times.
It is more likely that I explained this 500 times.
DD calls HHH(DD) in recursive simulation and
DD does not call HHH1 at all.

<Input to LLM systems>
Please think this all the way through without making any guesses.

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
(c) If HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.

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

What value should HHH(DD) correctly return?
</Input to LLM systems>
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Mon, 13 Oct 2025 08:35:41 -0500 schrieb olcott:

On 10/13/2025 3:28 AM, joes wrote:

Am Sat, 11 Oct 2025 08:44:09 -0500 schrieb olcott:

DD does not specify a call to some non-halting function. HHH most
assuredly halts.

Halts is defined as DD correctly simulated by HHH does reach its own simulated "return" statement final halt state on its own without intervention.

Even if it were defined that way, we would never know whether the
simulation of DD halts, because HHH abandons it. But halting of a
machine is only defined by its direct execution or equivalent pure
simulation by a UTM or, in this case, HHH1.

DD still specifies a call to a halting function. Simply not simulating
that does not amount to it not halting.

The input to HHH1(DD) specifies that the call from the simulated DD to
the simulated HHH(DD) does return.

How does it do that when the input is the identical DD?

DD calls HHH(DD) in recursive simulation and DD does not call HHH1 at
all.

ItrCOs fucking the same input both times! HHH interprets it incorrectly.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 09:55:45 -0500 schrieb olcott:

On 10/11/2025 9:30 AM, joes wrote:

Am Sat, 11 Oct 2025 09:05:20 -0500 schrieb olcott:

The only correct way to directly measure the actual behavior that an
actual input actually specifies is when input D is correctly*
simulated by simulating halt decider H.

*except you can stop simulating whenever you want.

That is not the way that simulating halt deciders work.

That is precisely how HHH works: it stops simulating on a whim.
I have another decider that decides differently.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Sat, 11 Oct 2025 14:33:17 -0500 schrieb olcott:

On 10/11/2025 2:14 PM, dbush wrote:

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider
is not directly computing the halt status for any directly executed
Turing machine.

Yes it is (for halting machines). A UTM does that.

But the description contains all information to know what will happen
when one is directly executed.

Proven to be counter-factual.

If something were missing you couldnrCOt even do halting analysis on it and your rCRdeciderrCY would need to assume the missing part. What should that be?

The sequence of moves specified by DD correctly simulated by HHH is
different than the sequence of moves specified DD correctly simulated by
HHH1 because DD calls HHH(DD) in recursive simulation and DD does not
call HHH1 at all.

No. DD specifies one sequence, that of its direct execution or a pure simulator/UTM, or HHH1 for that matter. HHH does not produce that.

All the LLMs systems immediately figured this out on their own without
ever being told. One thing that these LLM systems excel at is correctly assessing semantic logical entailment.

That is one thing they are spectacularly bad at.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 3:32 AM, Mikko wrote:

On 2025-10-12 15:09:08 +0000, olcott said:

On 10/12/2025 4:25 AM, Mikko wrote:

On 2025-10-11 13:44:09 +0000, olcott said:

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern >>>>> because it exists in the halting computation DD.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

Another way is to use partial halting deciders that are proven to
never give a wrong answer until one of them gives some answer.

Determining the halt status of an input that
does the opposite of whatever value is returned
is as bogus as determining whether or not this
Liar Paradox sentence is true or false:
"This sentence is not true".

No, it is not. If a partial halt decider that never gives a wrong
answer syas that that computation halts then we can trust that it
halts and if it says that it does not halt then we can trust that
it does not halt. If it does not answer at all then we can try
other partial deciders until we find one that does.

It turns out that no such actual input exists
and when the halting problem requires HHH(DD)
to report on the behavior of DD() it is requiring
the function computed by HHH(DD) to report on
an element that is not in its domain.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 3:41 AM, Mikko wrote:

On 2025-10-12 15:34:43 +0000, olcott said:

On 10/12/2025 4:34 AM, Mikko wrote:

On 2025-10-11 13:17:18 +0000, olcott said:

On 10/11/2025 4:21 AM, Mikko wrote:

We can regard the world as the infallible word of God. We believe in >>>>> the ordinary logic because in the world God created we have found no >>>>> examples where the ordinary logic derves a false conclusion ffom true >>>>> premises.

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Whether a given Turing machine halts with a given input always has
a correct answer. Finding that answer is not always easy, especially
for computations that do not halt. Conseqeuntly there are known
computations with a not yet determined halting status.

When the halt status of HHH(DD) is determined on
the basis of the behavior that the actual input
actually specifies as measured by DD simulated by
HHH according to the semantics of the language
then HHH is correct to reject its input as non halting.

As you said in news:10cbgd7$7ips$1@dont-email.me the expression
"DD simulated by HHH" is ambigous and therefore the above can
be interpreted as a false sentence.

*Thunderbird does now directly link to that*
It is true on the basis of the meaning of its words
when the 4th DD is understood to be the same
[simulated DD] as the prior three references.

It was only ambiguous to humans.

Anyway, from the meaning of the words follows that HHH rejects DD
as non-halting its decision is incorrect.

That the halting problem requires HHH to compute
the function of an input that is not in its domain
(the directly executed DD) is the error.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 8:56 AM, joes wrote:

Am Mon, 13 Oct 2025 08:35:41 -0500 schrieb olcott:

On 10/13/2025 3:28 AM, joes wrote:

Am Sat, 11 Oct 2025 08:44:09 -0500 schrieb olcott:

DD does not specify a call to some non-halting function. HHH most
assuredly halts.

Halts is defined as DD correctly simulated by HHH does reach its own
simulated "return" statement final halt state on its own without
intervention.

Even if it were defined that way, we would never know whether the
simulation of DD halts, because HHH abandons it.

Unless we bothered to pay attention to the correct
non-halting behavior pattern that every LLM system
figured out on its own on this basis:

<Input to LLM systems>
Please think this all the way through without making any guesses.

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
(c) If HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.

But halting of a
machine is only defined by its direct execution or equivalent pure
simulation by a UTM or, in this case, HHH1.

That requires HHH to compute the function for an
input that is not in its domain, thus an incorrect
requirement.

DD still specifies a call to a halting function. Simply not simulating
that does not amount to it not halting.

The input to HHH1(DD) specifies that the call from the simulated DD to >>>> the simulated HHH(DD) does return.

How does it do that when the input is the identical DD?

DD calls HHH(DD) in recursive simulation and DD does not call HHH1 at
all.

ItrCOs fucking the same input both times! HHH interprets it incorrectly.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 8:58 AM, joes wrote:

Am Sat, 11 Oct 2025 09:55:45 -0500 schrieb olcott:

On 10/11/2025 9:30 AM, joes wrote:

Am Sat, 11 Oct 2025 09:05:20 -0500 schrieb olcott:

The only correct way to directly measure the actual behavior that an
actual input actually specifies is when input D is correctly*
simulated by simulating halt decider H.

*except you can stop simulating whenever you want.

That is not the way that simulating halt deciders work.

That is precisely how HHH works: it stops simulating on a whim.
I have another decider that decides differently.

It only seems that way when you make sure to hardly
pay any attention at all.

<Input to LLM systems>
Please think this all the way through without making any guesses.

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) Detects a non-terminating behavior pattern:
abort simulation and return 0.
(b) Simulated input reaches its simulated "return" statement:
return 1.
(c) If HHH must abort its simulation to prevent its own non-termination
then HHH is correct to abort this simulation and return 0.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 9:12 AM, joes wrote:

Am Sat, 11 Oct 2025 14:33:17 -0500 schrieb olcott:

On 10/11/2025 2:14 PM, dbush wrote:

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider
is not directly computing the halt status for any directly executed >>>>>> Turing machine.

Yes it is (for halting machines). A UTM does that.

But the description contains all information to know what will happen >>>>> when one is directly executed.

Proven to be counter-factual.

If something were missing you couldnrCOt even do halting analysis on it and your rCRdeciderrCY would need to assume the missing part. What should that be?

It would be the same as me asking you to compute
the sum of a pair of numbers that only exist in
my mind and mind-reading is ruled out.

The sequence of moves specified by DD correctly simulated by HHH is
different than the sequence of moves specified DD correctly simulated by
HHH1 because DD calls HHH(DD) in recursive simulation and DD does not
call HHH1 at all.

No. DD specifies one sequence, that of its direct execution or a pure simulator/UTM, or HHH1 for that matter. HHH does not produce that.

Counter-factual

All the LLMs systems immediately figured this out on their own without
ever being told. One thing that these LLM systems excel at is correctly
assessing semantic logical entailment.

That is one thing they are spectacularly bad at.

They have 67-fold larger context window than one
year ago. When you test them with a well-defined
set of premises they are quite remarkable now.

Last year when you exceeded their 3000 word limit
that acted just like they had Alzheimer's. They
have a 200,000 word limit now and that changed
everything.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/13/2025 8:51 AM, olcott wrote:

On 10/13/2025 3:41 AM, Mikko wrote:

On 2025-10-12 15:34:43 +0000, olcott said:

On 10/12/2025 4:34 AM, Mikko wrote:

On 2025-10-11 13:17:18 +0000, olcott said:

On 10/11/2025 4:21 AM, Mikko wrote:

We can regard the world as the infallible word of God. We believe in >>>>>> the ordinary logic because in the world God created we have found no >>>>>> examples where the ordinary logic derves a false conclusion ffom true >>>>>> premises.

Most undecidable instances of decision problems
are also incorrect. They start with incoherent premises.

Whether a given Turing machine halts with a given input always has
a correct answer. Finding that answer is not always easy, especially
for computations that do not halt. Conseqeuntly there are known
computations with a not yet determined halting status.

When the halt status of HHH(DD) is determined on
the basis of the behavior that the actual input
actually specifies as measured by DD simulated by
HHH according to the semantics of the language
then HHH is correct to reject its input as non halting.

As you said in news:10cbgd7$7ips$1@dont-email.me the expression
"DD simulated by HHH" is ambigous and therefore the above can
be interpreted as a false sentence.

*Thunderbird does now directly link to that*
It is true on the basis of the meaning of its words
when the 4th DD is understood to be the same
[simulated DD] as the prior three references.

It was only ambiguous to humans.

Huh? You are a human... Right?

Anyway, from the meaning of the words follows that HHH rejects DD
as non-halting its decision is incorrect.

That the halting problem requires HHH to compute
the function of an input that is not in its domain
(the directly executed DD) is the error.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

Am Mon, 13 Oct 2025 11:12:55 -0500 schrieb olcott:

On 10/13/2025 9:12 AM, joes wrote:

Am Sat, 11 Oct 2025 14:33:17 -0500 schrieb olcott:

On 10/11/2025 2:14 PM, dbush wrote:

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider is not directly computing the >>>>>>> halt status for any directly executed Turing machine.

Yes it is (for halting machines). A UTM does that.

If something were missing you couldnrCOt even do halting analysis on it
and your rCRdeciderrCY would need to assume the missing part. What should
that be?

It would be the same as me asking you to compute the sum of a pair of
numbers that only exist in my mind and mind-reading is ruled out.

But what information is HHH missing that the processor has to compute DD?

No. DD specifies one sequence, that of its direct execution or a pure
simulator/UTM, or HHH1 for that matter. HHH does not produce that.

Counter-factual

It is a fact that HHH does not produce the same trace as HHH1.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 2025-10-13 15:45:00 +0000, olcott said:

On 10/13/2025 3:32 AM, Mikko wrote:

On 2025-10-12 15:09:08 +0000, olcott said:

On 10/12/2025 4:25 AM, Mikko wrote:

On 2025-10-11 13:44:09 +0000, olcott said:

On 10/11/2025 8:41 AM, dbush wrote:

On 10/11/2025 9:40 AM, olcott wrote:

That is only because you stupidly ignore the expressly
stated details of correctly matching correct non-halting
behavior patterns.

But the pattern in question is *not* a non-halting behavior pattern >>>>>> because it exists in the halting computation DD.

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

The only way to correctly determine the actual behavior
that an actual input actually specifies is for simulating
halt decider H to simulate its input D.

Another way is to use partial halting deciders that are proven to
never give a wrong answer until one of them gives some answer.

Determining the halt status of an input that
does the opposite of whatever value is returned
is as bogus as determining whether or not this
Liar Paradox sentence is true or false:
"This sentence is not true".

No, it is not. If a partial halt decider that never gives a wrong
answer syas that that computation halts then we can trust that it
halts and if it says that it does not halt then we can trust that
it does not halt. If it does not answer at all then we can try
other partial deciders until we find one that does.

It turns out that no such actual input exists
and when the halting problem requires HHH(DD)
to report on the behavior of DD() it is requiring
the function computed by HHH(DD) to report on
an element that is not in its domain.

It turns out that DD is such input and if we give it to HHH1 it
answers as a partial halt decider is required to answer.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.theory

On 10/14/2025 3:14 AM, joes wrote:

Am Mon, 13 Oct 2025 11:12:55 -0500 schrieb olcott:

On 10/13/2025 9:12 AM, joes wrote:

Am Sat, 11 Oct 2025 14:33:17 -0500 schrieb olcott:

On 10/11/2025 2:14 PM, dbush wrote:

On 10/11/2025 10:35 AM, olcott wrote:

On 10/11/2025 9:18 AM, dbush wrote:

On 10/11/2025 10:05 AM, olcott wrote:

Even in this case the halt decider is not directly computing the >>>>>>>> halt status for any directly executed Turing machine.

Yes it is (for halting machines). A UTM does that.

If something were missing you couldnrCOt even do halting analysis on it
and your rCRdeciderrCY would need to assume the missing part. What should >>> that be?

It would be the same as me asking you to compute the sum of a pair of
numbers that only exist in my mind and mind-reading is ruled out.

But what information is HHH missing that the processor has to compute DD?

See my new post for a comprehensive answer
[Exactly how Ben Bacarisse is proven wrong about H(D)==0]

No. DD specifies one sequence, that of its direct execution or a pure
simulator/UTM, or HHH1 for that matter. HHH does not produce that.

Counter-factual

It is a fact that HHH does not produce the same trace as HHH1.

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2