From Newsgroup: comp.ai.philosophy

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by name.

The actual code has always been based on an x86 emulator that emulates >>>> finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it call the
fixed code that aborts just before the second recursive call? Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for them to
understand that the correct emulation of an input that calls its own
emulator HHH(DDD) can possibly be different than the emulation of the
same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they should not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
HHH(DDD);
return;
}


int main()
{
HHH(DDD);
DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement then it returns 1.

Then they figure out all the other details on their own.

https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c
--
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.ai.philosophy

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by name. >>>>> The actual code has always been based on an x86 emulator that emulates >>>>> finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it call the >>>> fixed code that aborts just before the second recursive call? Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for them to >>>>> understand that the correct emulation of an input that calls its own >>>>> emulator HHH(DDD) can possibly be different than the emulation of the >>>>> same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they should not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same behaviour as >>>> an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
  HHH(DDD);
  return;
}

int main()
{
  HHH(DDD);
  DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement then it returns 1.

These cache-boxes are fed with invalid and contradictory information:
(a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and return.
Still claiming that it sees non-termination, is both incorrect and contradictory.

Then they figure out all the other details on their own.

https://chatgpt.com/share/688521d8-e5fc-8011-9d7c-0d77ac83706c

Going from invalid and contradictory information, any conclusion can be figured out, even incorrect ones.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by name. >>>>>> The actual code has always been based on an x86 emulator that

emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it call >>>>> the
fixed code that aborts just before the second recursive call? Because >>>>> DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever code is >>>> at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for them to >>>>>> understand that the correct emulation of an input that calls its own >>>>>> emulator HHH(DDD) can possibly be different than the emulation of the >>>>>> same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they should not be >>>>> aborted as if the were the same.
If HHH were a correct simulator, it would produce the same
behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input until:
(a) It detects a non-terminating behavior pattern then it aborts its
simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement then
it returns 1.

These cache-boxes are fed with invalid and contradictory information:
(a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.
--
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.ai.philosophy

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by name. >>>>>>> The actual code has always been based on an x86 emulator that

emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it
call the
fixed code that aborts just before the second recursive call? Because >>>>>> DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever
code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for them to >>>>>>> understand that the correct emulation of an input that calls its own >>>>>>> emulator HHH(DDD) can possibly be different than the emulation of >>>>>>> the
same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct your >>>>> mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they should not be >>>>>> aborted as if the were the same.
If HHH were a correct simulator, it would produce the same
behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input until: >>> (a) It detects a non-terminating behavior pattern then it aborts its
simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement then
it returns 1.

These cache-boxes are fed with invalid and contradictory information:
(a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven
by world-class simulators using exactly the same input. The infinity is
only in your dreams.

When HHH fails to see that there is only a finite recursion and aborts,
it is incorrect to feed the chat-box with the idea that HHH recognises non-termination behaviour. There you feed it with your bias.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by >>>>>>>>> name.

The actual code has always been based on an x86 emulator that >>>>>>>> emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it
call the
fixed code that aborts just before the second recursive call?
Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever
code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD, >>>>> because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for
them to
understand that the correct emulation of an input that calls its >>>>>>>> own
emulator HHH(DDD) can possibly be different than the emulation >>>>>>>> of the
same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct your >>>>>> mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the >>>>> abort was correct.

If we prefix all programs we pass to HHH with DDD, they should
not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same
behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) It detects a non-terminating behavior pattern then it aborts its
simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement
then it returns 1.

These cache-boxes are fed with invalid and contradictory information:
(a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and
return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven
by world-class simulators using exactly the same input. The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.
--
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.ai.philosophy

On 7/29/25 5:15 PM, olcott wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by >>>>>>>>>> name.

The actual code has always been based on an x86 emulator that >>>>>>>>> emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it >>>>>>>> call the
fixed code that aborts just before the second recursive call? >>>>>>>> Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever >>>>>>> code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD, >>>>>> because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for >>>>>>>>> them to
understand that the correct emulation of an input that calls >>>>>>>>> its own
emulator HHH(DDD) can possibly be different than the emulation >>>>>>>>> of the
same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct >>>>>>> your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the >>>>>> abort was correct.

If we prefix all programs we pass to HHH with DDD, they should >>>>>>>> not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same
behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) It detects a non-terminating behavior pattern then it aborts
its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement
then it returns 1.

These cache-boxes are fed with invalid and contradictory information:
(a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and
return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as
proven by world-class simulators using exactly the same input. The
infinity is only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

And must CORRECTLY (amd completely) simulate that.

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

Which doesn't affect what the simulation does.

At this point I think that you are a fucking liar.

No, you are just proving you are fucking stupid.

SInce you can't show how the "itself" affect the behavior, it is just a lie. --- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven
by world-class simulators using exactly the same input. The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to
call anybody else here a liar. Glass house inhabitants, throwing stones,
and all that.

And you used to distinguish yourself from other cranks by sticking to
decorous language, and generally being courteous. Not any more. That is
a most unwelcome change.

--
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.ai.philosophy

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven
by world-class simulators using exactly the same input. The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to
call anybody else here a liar. Glass house inhabitants, throwing stones,
and all that.

And you used to distinguish yourself from other cranks by sticking to decorous language, and generally being courteous. Not any more. That is
a most unwelcome change.

void DDD()
{
HHH(DDD);
return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

cannot be reasonably attributed to anything besides
willful deception.
--
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.ai.philosophy

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven
by world-class simulators using exactly the same input. The infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to
call anybody else here a liar. Glass house inhabitants, throwing stones,
and all that.

It has never actually been established that I even
made one single material mistake in any of my claims.

I have proved that the conventional proofs of the halting
problem can easily be overcome by a simulating termination
analyzer.

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

DD correctly simulated by any HHH cannot possibly
reach the classic contradiction at the "if" statement
because DD calls HHH(DD) in recursive simulation.

Everyone here simply denies the possibility the
recursive simulation can possibly exist and claims
that my insistence that it does is a mistake that
I made.
--
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.ai.philosophy

On 7/29/2025 5:38 PM, Richard Damon wrote:

On 7/29/25 5:15 PM, olcott wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by >>>>>>>>>>> name.

The actual code has always been based on an x86 emulator that >>>>>>>>>> emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it >>>>>>>>> call the
fixed code that aborts just before the second recursive call? >>>>>>>>> Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever >>>>>>>> code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD, >>>>>>> because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for >>>>>>>>>> them to
understand that the correct emulation of an input that calls >>>>>>>>>> its own
emulator HHH(DDD) can possibly be different than the emulation >>>>>>>>>> of the
same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct >>>>>>>> your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that >>>>>>> the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they should >>>>>>>>> not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same
behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input >>>>>> until:
(a) It detects a non-terminating behavior pattern then it aborts
its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement
then it returns 1.

These cache-boxes are fed with invalid and contradictory information: >>>>> (a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and
return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as
proven by world-class simulators using exactly the same input. The
infinity is only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

And must CORRECTLY (amd completely) simulate that.

No you fucking liar a person can count to ten
without counting to infinity.
--
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.ai.philosophy

On 7/29/25 9:18 PM, olcott wrote:

On 7/29/2025 5:38 PM, Richard Damon wrote:

On 7/29/25 5:15 PM, olcott wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH >>>>>>>>>>>> by name.

The actual code has always been based on an x86 emulator that >>>>>>>>>>> emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it >>>>>>>>>> call the
fixed code that aborts just before the second recursive call? >>>>>>>>>> Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever >>>>>>>>> code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input >>>>>>>> DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for >>>>>>>>>>> them to
understand that the correct emulation of an input that calls >>>>>>>>>>> its own
emulator HHH(DDD) can possibly be different than the
emulation of the
same input that does not call its own emulator HHH1(DDD). >>>>>>>>>> It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is
correct your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown
that the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they should >>>>>>>>>> not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same >>>>>>>>>> behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input >>>>>>> until:
(a) It detects a non-terminating behavior pattern then it aborts >>>>>>> its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement >>>>>>> then it returns 1.

These cache-boxes are fed with invalid and contradictory information: >>>>>> (a) No non-termination pattern can be detected when it aborts and >>>>>> return, because the simulated HHH is also programmed to abort and >>>>>> return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as
proven by world-class simulators using exactly the same input. The
infinity is only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

And must CORRECTLY (amd completely) simulate that.

No you fucking liar a person can count to ten
without counting to infinity.

Sure, and you can simulate the first 4 instructions of DDD. But that
doesn't say you know or show what DDD will do.

Just like counting 10 pennies out of a full jar of them doesn't let you
know how many pennies are in it, or "prove" that it has an infinite
number of them.

Your problem is you keep on lying about what you get out of your simulation.

The *ONLY* thing that defines Halting or non-halting behavior is a
complete simulation eather reaching a final state, or not reaching ever
a final state, even after an unbounded number of steps.

Note carefully, that doesn't mean you need to do that full simulation,
but prove that such a simulation will behave that way.

And, when doing this that simulation is of EXACTLY the input given,
which needs to contain *ALL* the code it uses, so DDD includes the code
of the specific HHH it calls, and that doesn't change when you think
about this actual correct simulator, it ALWAYS uses the HHH that it was
built on, which is the exact HHH that you claim gives the right answer,
and thus is the HHH that aborts.

Sorry, all you are doing is prove that you logic is based on lying,
since you don't correctly simulate the same input that you claim to be deciding on.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/29/25 7:52 PM, olcott wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven >>>> by world-class simulators using exactly the same input. The infinity is >>>> only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to
call anybody else here a liar.  Glass house inhabitants, throwing stones, >> and all that.

It has never actually been established that I even
made one single material mistake in any of my claims.

Sure it has, you are just proven to be too stupid to understand it.

I have proved that the conventional proofs of the halting
problem can easily be overcome by a simulating termination
analyzer.

Nope, just that you lie, and don't know what the words you use mean.

int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

DD correctly simulated by any HHH cannot possibly
reach the classic contradiction at the "if" statement
because DD calls HHH(DD) in recursive simulation.

But it isn't correctly simuated by HHH, so that doesn't apply, and you
are proven to just be a liar.

Everyone here simply denies the possibility the
recursive simulation can possibly exist and claims
that my insistence that it does is a mistake that
I made.

Nope, you are just too stupid to understand what people say.

It seems you don't even know what you are saying, at least not when we consider the ACTUAL meaning of the words.

Using wrong definitions is just a form of lying, which seems to be you
whole world.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/29/2025 8:37 PM, Richard Damon wrote:

On 7/29/25 9:18 PM, olcott wrote:

On 7/29/2025 5:38 PM, Richard Damon wrote:

On 7/29/25 5:15 PM, olcott wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH >>>>>>>>>>>>> by name.

The actual code has always been based on an x86 emulator >>>>>>>>>>>> that emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does >>>>>>>>>>> it call the
fixed code that aborts just before the second recursive call? >>>>>>>>>>> Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on
whatever code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input >>>>>>>>> DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for >>>>>>>>>>>> them to
understand that the correct emulation of an input that calls >>>>>>>>>>>> its own
emulator HHH(DDD) can possibly be different than the
emulation of the
same input that does not call its own emulator HHH1(DDD). >>>>>>>>>>> It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is
correct your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown >>>>>>>>> that the
abort was correct.

If we prefix all programs we pass to HHH with DDD, they >>>>>>>>>>> should not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same >>>>>>>>>>> behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its
input until:
(a) It detects a non-terminating behavior pattern then it aborts >>>>>>>> its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement >>>>>>>> then it returns 1.

These cache-boxes are fed with invalid and contradictory
information:
(a) No non-termination pattern can be detected when it aborts and >>>>>>> return, because the simulated HHH is also programmed to abort and >>>>>>> return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation >>>>> would reach the final halt state in a finite number of steps, as
proven by world-class simulators using exactly the same input. The
infinity is only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD) >>>

And must CORRECTLY (amd completely) simulate that.

No you fucking liar a person can count to ten
without counting to infinity.

Sure, and you can simulate the first 4 instructions of DDD. But that
doesn't say you know or show what DDD will do.

It is the repeating sequence that cannot possibly
reach the "return" instruction final halt state of
DDD that is recognized in a finite number of steps.

I know that you are smart enough to see this so that
only leaves liar.
--
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.ai.philosophy

On 7/29/2025 8:40 PM, Richard Damon wrote:

On 7/29/25 7:52 PM, olcott wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as
proven
by world-class simulators using exactly the same input. The
infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD) >>>
HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT >>>> CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to >>> call anybody else here a liar.  Glass house inhabitants, throwing
stones,
and all that.

It has never actually been established that I even
made one single material mistake in any of my claims.

Sure it has, you are just proven to be too stupid to understand it.

This ad hominem The way that damned liar forms a rebuttal.

If you were not a damned liar you would have brought up
a concrete example of a material mistake that I made.
Because you are a damned liar you know that no such
mistake exists.
--
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.ai.philosophy

Op 30.jul.2025 om 01:10 schreef olcott:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as proven >>>> by world-class simulators using exactly the same input. The infinity is >>>> only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no position to
call anybody else here a liar.  Glass house inhabitants, throwing stones, >> and all that.

And you used to distinguish yourself from other cranks by sticking to
decorous language, and generally being courteous.  Not any more.  That is >> a most unwelcome change.

void DDD()
{
  HHH(DDD);
  return;
}

*That not one single person here*
(besides those that I invited from the C groups)
acknowledges that DDD simulated by HHH specifies
recursive simulation

As usual counter factual.
I told you many times that it specifies a finite recursion. But you seem
to think that a finite recursion is sufficient reason to conclude
non-halting. It is not. Why closing your eyes for the truth?
It suggests that this attitude

cannot be reasonably attributed to anything besides
willful deception.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

Op 29.jul.2025 om 23:15 schreef olcott:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH by >>>>>>>>>> name.

The actual code has always been based on an x86 emulator that >>>>>>>>> emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does it >>>>>>>> call the
fixed code that aborts just before the second recursive call? >>>>>>>> Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on whatever >>>>>>> code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the input DDD, >>>>>> because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible for >>>>>>>>> them to
understand that the correct emulation of an input that calls >>>>>>>>> its own
emulator HHH(DDD) can possibly be different than the emulation >>>>>>>>> of the
same input that does not call its own emulator HHH1(DDD).

It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is correct >>>>>>> your
mere intuition to the contrary is proven to be incorrect.

The trace only shows it is different. It remains to be shown that the >>>>>> abort was correct.

If we prefix all programs we pass to HHH with DDD, they should >>>>>>>> not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same
behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its input
until:
(a) It detects a non-terminating behavior pattern then it aborts
its simulation and returns 0,
(b) Its simulated input reaches its simulated "return" statement
then it returns 1.

These cache-boxes are fed with invalid and contradictory information:
(a) No non-termination pattern can be detected when it aborts and
return, because the simulated HHH is also programmed to abort and
return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation
would reach the final halt state in a finite number of steps, as
proven by world-class simulators using exactly the same input. The
infinity is only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

Indeed and this 'itself' is HHH, not HHH1.

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)

No, HHH1 must simulate the same as HHH, namely HHH. Because that is what
the input specifies.

So, both must simulate the same thing: HHH. Here HHH fails, because it
cannot simulate itself up to the end, but HHH1 succeeds, because it has
no problem to simulate HHH.

When both are simulating exactly the same thing, namely HHH, where one
does not reach the final halt state and the other one succeeds to reach
it, it is a proof that Hush’s simulation is incorrect.

Further irrelevant and incorrect claims ignored. They only prove the
lack of arguments or honesty.

At this point I think that you are a fucking liar.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/29/25 10:55 PM, olcott wrote:

On 7/29/2025 8:37 PM, Richard Damon wrote:

On 7/29/25 9:18 PM, olcott wrote:

On 7/29/2025 5:38 PM, Richard Damon wrote:

On 7/29/25 5:15 PM, olcott wrote:

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

Op 28.jul.2025 om 14:46 schreef olcott:

On 7/28/2025 3:43 AM, Fred. Zwarts wrote:

Op 26.jul.2025 om 20:46 schreef olcott:

On 7/26/2025 1:11 PM, joes wrote:

Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:

On 7/26/2025 3:05 AM, joes wrote:

Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:

On 7/25/2025 2:10 PM, joes wrote:

Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:

Oh, really now? I thought it referred to its simulator HHH >>>>>>>>>>>>>> by name.

The actual code has always been based on an x86 emulator >>>>>>>>>>>>> that emulates
finite strings of x86 machine code bytes.

But does DDD call whatever is behind the name "HHH" or does >>>>>>>>>>>> it call the
fixed code that aborts just before the second recursive >>>>>>>>>>>> call? Because
DDD calling a modified HHH' is a different program.

When HHH emulates DDD then DDD calls HHH(DDD) based on
whatever code is
at machine address 000015d2.

Ok, so modifying HHH to simulate further also changes the >>>>>>>>>> input DDD,
because it calls the same address. Gotcha.

For three years everyone here acts like it is impossible >>>>>>>>>>>>> for them to
understand that the correct emulation of an input that >>>>>>>>>>>>> calls its own
emulator HHH(DDD) can possibly be different than the >>>>>>>>>>>>> emulation of the
same input that does not call its own emulator HHH1(DDD). >>>>>>>>>>>> It is not impossible to understand. It is wrong.

Since the execution trace conclusively proves that it is >>>>>>>>>>> correct your
mere intuition to the contrary is proven to be incorrect. >>>>>>>>>> The trace only shows it is different. It remains to be shown >>>>>>>>>> that the

abort was correct.

If we prefix all programs we pass to HHH with DDD, they >>>>>>>>>>>> should not be
aborted as if the were the same.
If HHH were a correct simulator, it would produce the same >>>>>>>>>>>> behaviour as
an UTM. (HHH1 is the same as HHH, right?)

Right?

All of the chatbots figure out that I am correct
on their own. I only give them this input:

typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}


int main()
{
   HHH(DDD);
   DDD();
}

Simulating Termination Analyzer HHH correctly simulates its >>>>>>>>> input until:
(a) It detects a non-terminating behavior pattern then it
aborts its simulation and returns 0,
(b) Its simulated input reaches its simulated "return"
statement then it returns 1.

These cache-boxes are fed with invalid and contradictory
information:
(a) No non-termination pattern can be detected when it aborts >>>>>>>> and return, because the simulated HHH is also programmed to
abort and return.

DDD correctly simulated by HHH cannot possibly reach its own
simulated "return" instruction final halt state in one to
infinity steps of correct simulation. This is a verified fact.

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the
simulation would reach the final halt state in a finite number of >>>>>> steps, as proven by world-class simulators using exactly the same >>>>>> input. The infinity is only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls
HHH(DDD)

And must CORRECTLY (amd completely) simulate that.

No you fucking liar a person can count to ten
without counting to infinity.

Sure, and you can simulate the first 4 instructions of DDD. But that
doesn't say you know or show what DDD will do.

It is the repeating sequence that cannot possibly
reach the "return" instruction final halt state of
DDD that is recognized in a finite number of steps.

I know that you are smart enough to see this so that
only leaves liar.

But that 4 instructions are NOT a "correct simulaiton" of the input DDD.

As the correct simulation of the CALL HHH instruction MUST be followed
by the correct simulation of the first instruction in HHH.

All you are doing is proving that you lie, because you keep on insisting
on statements that are not true in the context of the problem you claim
to be working on.

Since the ACTUAL correct simulation of that input will reach the final
state, as you have shown with your x86utm, it can't be also true that it
can never reach such a state.

All you are doing is showing that your logic system is based on the
allowance of contradictions and errors.

Sorry, you are just shwoing that Peter Olcott doesn't know the meaning
of the words he is using, and doesn't care about it.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 7/29/25 10:58 PM, olcott wrote:

On 7/29/2025 8:40 PM, Richard Damon wrote:

On 7/29/25 7:52 PM, olcott wrote:

On 7/29/2025 5:49 PM, Alan Mackenzie wrote:

[ Followup-To: set ]

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

On 7/29/2025 2:39 AM, Fred. Zwarts wrote:

[ .... ]

As usual incorrect claims without evidence.
Your dreams are no verified facts. HHH aborts before the simulation >>>>>> would reach the final halt state in a finite number of steps, as
proven
by world-class simulators using exactly the same input. The
infinity is
only in your dreams.

HHH(DDD) must simulate itself simulating DDD because DDD calls
HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT >>>>> CALL HHH1(DDD)

At this point I think that you are a fucking liar.

As has been established elsewhere in this thread, you are no
position to
call anybody else here a liar.  Glass house inhabitants, throwing
stones,
and all that.

It has never actually been established that I even
made one single material mistake in any of my claims.

Sure it has, you are just proven to be too stupid to understand it.

This ad hominem The way that damned liar forms a rebuttal.

Since you just showed you don't know what an ad hominem is, you are just proving my point.

If you were not a damned liar you would have brought up
a concrete example of a material mistake that I made.
Because you are a damned liar you know that no such
mistake exists.

I have, many times.

The fact that you ignore them just establishes that you are a
pathological liar.

Your time is running short, and if you don't drastically repent, you
WILL find out the cost of your lies.

Since one of your fundamental problems is you don't understand that the
rules of the game are the rules, and you can't change them and still be
in the game, distroys all your arguments.

You have been invited to make you own game, but that requires you to
admit that the existing game IS playable. That by accepted logic, there
ARE statements that are true but unprovable.

Perhaps you don't want to take up the invite to make your own game
because you know it would end up being just a small sand box version
that no one would want to use because to get the rules you want, it
can't do much. Or perhaps, you realize that you just don't know enough
about the basics of system to build one.

So, all you do is prove that you are just a liar, as you keep on getting caught trying to "cheat" in the system by using wrong definitions.

Sorry, you have effectvely banned yourself from the game, but keep on
trying to play.
--- Synchronet 3.21a-Linux NewsLink 1.2